| /******************************************************************************* |
| * Copyright (c) 2011-2013 EclipseSource Muenchen GmbH and others. |
| * |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License 2.0 |
| * which accompanies this distribution, and is available at |
| * https://www.eclipse.org/legal/epl-2.0/ |
| * |
| * SPDX-License-Identifier: EPL-2.0 |
| * |
| * Contributors: |
| * Johannes Faltermeier - initial API and implementation |
| ******************************************************************************/ |
| package org.eclipse.emf.ecp.view.spi.section.swt; |
| |
| import java.util.ArrayList; |
| import java.util.Iterator; |
| import java.util.LinkedHashSet; |
| import java.util.List; |
| import java.util.Set; |
| |
| import javax.inject.Inject; |
| |
| import org.eclipse.core.databinding.beans.PojoProperties; |
| import org.eclipse.core.databinding.observable.value.IObservableValue; |
| import org.eclipse.core.databinding.observable.value.WritableValue; |
| import org.eclipse.emf.databinding.edit.EMFEditObservables; |
| import org.eclipse.emf.ecp.view.spi.context.ViewModelContext; |
| import org.eclipse.emf.ecp.view.spi.model.ModelChangeListener; |
| import org.eclipse.emf.ecp.view.spi.model.ModelChangeNotification; |
| import org.eclipse.emf.ecp.view.spi.model.VElement; |
| import org.eclipse.emf.ecp.view.spi.model.VViewPackage; |
| import org.eclipse.emf.ecp.view.spi.section.model.VSection; |
| import org.eclipse.emf.ecp.view.spi.section.model.VSectionPackage; |
| import org.eclipse.emf.ecp.view.spi.swt.reporting.RenderingFailedReport; |
| import org.eclipse.emf.ecp.view.template.model.VTViewTemplateProvider; |
| import org.eclipse.emf.edit.domain.AdapterFactoryEditingDomain; |
| import org.eclipse.emf.edit.domain.EditingDomain; |
| import org.eclipse.emfforms.common.Optional; |
| import org.eclipse.emfforms.spi.common.report.ReportService; |
| import org.eclipse.emfforms.spi.swt.core.AbstractSWTRenderer; |
| import org.eclipse.emfforms.spi.swt.core.EMFFormsNoRendererException; |
| import org.eclipse.emfforms.spi.swt.core.layout.GridDescriptionFactory; |
| import org.eclipse.emfforms.spi.swt.core.layout.SWTGridCell; |
| import org.eclipse.emfforms.spi.swt.core.layout.SWTGridDescription; |
| import org.eclipse.jface.layout.GridLayoutFactory; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.graphics.Point; |
| import org.eclipse.swt.layout.GridData; |
| import org.eclipse.swt.widgets.Composite; |
| import org.eclipse.swt.widgets.Control; |
| import org.eclipse.ui.forms.events.ExpansionEvent; |
| import org.eclipse.ui.forms.events.IExpansionListener; |
| import org.eclipse.ui.forms.widgets.ExpandableComposite; |
| |
| /** |
| * Renderer for {@link VSection} with child items. |
| * |
| * @author jfaltermeier |
| * |
| */ |
| public class SectionNodeSWTRenderer extends AbstractSectionSWTRenderer { |
| |
| /** |
| * @param vElement the view model element to be rendered |
| * @param viewContext the view context |
| * @param reportService the {@link ReportService} |
| * @param viewTemplateProvider the {@link VTViewTemplateProvider} |
| * @since 1.18 |
| */ |
| @Inject |
| public SectionNodeSWTRenderer(VSection vElement, ViewModelContext viewContext, ReportService reportService, |
| VTViewTemplateProvider viewTemplateProvider) { |
| super(vElement, viewContext, reportService, viewTemplateProvider); |
| } |
| |
| private Set<AbstractSectionSWTRenderer> childRenderers; |
| private SWTGridDescription rendererGridDescription; |
| private ModelChangeListener listener; |
| private ExpandableComposite expandableComposite; |
| |
| @Override |
| protected void preInit() { |
| super.preInit(); |
| listener = new ModelChangeListener() { |
| |
| @Override |
| public void notifyChange(ModelChangeNotification notification) { |
| if (notification.getRawNotification().isTouch()) { |
| return; |
| } |
| if (notification.getNotifier() != getVElement()) { |
| return; |
| } |
| if (notification.getStructuralFeature() == VSectionPackage.eINSTANCE |
| .getSection_Collapsed()) { |
| handleCollapseState(); |
| } |
| } |
| }; |
| getViewModelContext().registerViewChangeListener(listener); |
| } |
| |
| @Override |
| public SWTGridDescription getGridDescription( |
| SWTGridDescription gridDescription) { |
| |
| rendererGridDescription = new SWTGridDescription(); |
| childRenderers = new LinkedHashSet<AbstractSectionSWTRenderer>(); |
| |
| /* get griddescriptions from child sections */ |
| final List<SWTGridDescription> childGridDescriptions = new ArrayList<SWTGridDescription>(); |
| for (final VSection item : getVElement().getChildItems()) { |
| AbstractSWTRenderer<?> itemRenderer; |
| try { |
| itemRenderer = getEMFFormsRendererFactory() |
| .getRendererInstance(item, getViewModelContext()); |
| } catch (final EMFFormsNoRendererException ex) { |
| getReportService().report(new RenderingFailedReport(ex)); |
| continue; |
| } |
| final SWTGridDescription itemGridDescription = itemRenderer |
| .getGridDescription(GridDescriptionFactory.INSTANCE |
| .createEmptyGridDescription()); |
| childRenderers.add((AbstractSectionSWTRenderer) itemRenderer); |
| childGridDescriptions.add(itemGridDescription); |
| } |
| |
| /* compute required column count based on self and children */ |
| final int selfColumns = 1 + getVElement().getChildren().size(); |
| int columns = selfColumns; |
| for (final SWTGridDescription childGridDescription : childGridDescriptions) { |
| columns = childGridDescription.getColumns() > columns ? childGridDescription.getColumns() : columns; |
| } |
| |
| /* create grid description for this renderer */ |
| rendererGridDescription.setColumns(columns); |
| final List<SWTGridCell> gridCells = new ArrayList<SWTGridCell>(); |
| int emptyCellColumnIndicator = -1; |
| |
| /* add self */ |
| int row = 0; |
| |
| /* label */ |
| final Optional<Integer> labelWidth = getLabelWidth(); |
| Point prefSize; |
| if (labelWidth.isPresent()) { |
| prefSize = new Point(labelWidth.get(), SWT.DEFAULT); |
| } else { |
| prefSize = new Point(SWT.DEFAULT, SWT.DEFAULT); |
| } |
| int curSelfColumn = 0; |
| gridCells.add(createGridCell(row, curSelfColumn++, this, prefSize)); |
| /* empty columns */ |
| final int emptyColumns = columns - selfColumns; |
| for (int i = 0; i < emptyColumns; i++) { |
| gridCells.add(createGridCell(row, emptyCellColumnIndicator--, this)); |
| } |
| /* regular columns */ |
| for (int columnToAdd = 0; columnToAdd < getVElement().getChildren().size(); columnToAdd++) { |
| gridCells.add(createGridCell(row, curSelfColumn++, this)); |
| } |
| row += 1; |
| |
| /* add children */ |
| for (final SWTGridDescription childGridDescription : childGridDescriptions) { |
| final SWTGridCell[][] sortedChildGridCells = getArrangedChildGridCells(childGridDescription, columns); |
| for (final SWTGridCell[] rowGridCells : sortedChildGridCells) { |
| /* There is always at least one column (index) */ |
| final int currentRow = rowGridCells[0].getRow() + row; |
| final AbstractSWTRenderer<?> renderer = rowGridCells[0].getRenderer(); |
| for (int i = 0; i < rowGridCells.length; i++) { |
| final SWTGridCell swtGridCell = rowGridCells[i]; |
| if (swtGridCell != null) { |
| gridCells.add( |
| createGridCell( |
| currentRow, |
| swtGridCell.getColumn(), |
| swtGridCell.getRenderer(), |
| swtGridCell.getPreferredSize())); |
| } else { |
| /* create empty column */ |
| gridCells.add(createGridCell(currentRow, emptyCellColumnIndicator--, renderer)); |
| } |
| } |
| } |
| row += childGridDescription.getRows(); |
| } |
| |
| rendererGridDescription.setRows(row); |
| rendererGridDescription.setGrid(gridCells); |
| return rendererGridDescription; |
| } |
| |
| private SWTGridCell[][] getArrangedChildGridCells(SWTGridDescription childGridDescription, int columns) { |
| final SWTGridCell[][] result = new SWTGridCell[childGridDescription.getRows()][columns]; |
| for (final SWTGridCell swtGridCell : childGridDescription.getGrid()) { |
| if (swtGridCell.getColumn() < 0) { |
| continue; |
| } |
| result[swtGridCell.getRow()][swtGridCell.getColumn()] = swtGridCell; |
| } |
| for (final SWTGridCell[] columnArray : result) { |
| shiftElementsToEndOfArrayButFirstElement(columnArray); |
| } |
| return result; |
| } |
| |
| private static void shiftElementsToEndOfArrayButFirstElement(SWTGridCell[] columnArray) { |
| final int length = columnArray.length; |
| for (int i = length - 1; i >= 0; i--) { |
| if (columnArray[i] == null) { |
| final int index = getIndexToMove(columnArray, i); |
| if (index == -1) { |
| return; |
| } |
| columnArray[i] = columnArray[index]; |
| columnArray[index] = null; |
| } else { |
| return; |
| } |
| } |
| } |
| |
| private static int getIndexToMove(SWTGridCell[] columnArray, int index) { |
| for (int i = index - 1; i > 0; i--) { |
| if (columnArray[i] != null) { |
| return i; |
| } |
| } |
| return -1; |
| } |
| |
| private SWTGridCell createGridCell(int row, int column, |
| AbstractSWTRenderer<? extends VElement> renderer) { |
| final SWTGridCell gridCell = new SWTGridCell(row, column, renderer); |
| gridCell.setVerticalFill(false); |
| gridCell.setVerticalGrab(false); |
| if (column == 3) { |
| gridCell.setHorizontalGrab(true); |
| } else { |
| gridCell.setHorizontalGrab(false); |
| } |
| return gridCell; |
| |
| } |
| |
| private SWTGridCell createGridCell(int row, int column, |
| AbstractSWTRenderer<? extends VElement> renderer, Point prefSize) { |
| final SWTGridCell gridCell = createGridCell(row, column, renderer); |
| gridCell.setPreferredSize(prefSize); |
| return gridCell; |
| } |
| |
| @Override |
| protected Control createFirstColumn(Composite parent) { |
| final Composite composite = new Composite(parent, SWT.NONE); |
| GridLayoutFactory.fillDefaults().numColumns(1) |
| .extendedMargins(computeLeftMargin(), 0, 0, 0) |
| .applyTo(composite); |
| |
| setExpandableComposite(new ExpandableComposite( |
| composite, SWT.NONE, ExpandableComposite.TWISTIE)); |
| getExpandableComposite().setExpanded(!getVElement().isCollapsed()); |
| final EditingDomain editingDomain = AdapterFactoryEditingDomain.getEditingDomainFor(getVElement()); |
| |
| final IObservableValue modelLabelValue = EMFEditObservables.observeValue( |
| editingDomain, |
| getVElement(), |
| VViewPackage.eINSTANCE.getElement_Label()); |
| final String text = "text"; //$NON-NLS-1$ |
| final WritableValue value = new WritableValue(text, String.class); |
| final IObservableValue textObservable = PojoProperties.value(ExpandableComposite.class, text, String.class) |
| .observe(expandableComposite); |
| |
| getDataBindingContext().bindValue(textObservable, modelLabelValue); |
| |
| initExpandableComposite(getExpandableComposite()); |
| |
| final IObservableValue modelTooltipValue = EMFEditObservables.observeValue( |
| editingDomain, |
| getVElement(), |
| VViewPackage.eINSTANCE.getHasTooltip_Tooltip()); |
| final IObservableValue targetTooltipValue = new ExpandableCompositeTooltipProperty() |
| .observe(getExpandableComposite()); |
| getDataBindingContext().bindValue(targetTooltipValue, modelTooltipValue); |
| |
| return composite; |
| } |
| |
| private void initExpandableComposite(ExpandableComposite expandableComposite) { |
| expandableComposite.addExpansionListener(new IExpansionListener() { |
| |
| @Override |
| public void expansionStateChanging(ExpansionEvent e) { |
| } |
| |
| @Override |
| public void expansionStateChanged(ExpansionEvent e) { |
| getVElement().setCollapsed(!e.getState()); |
| } |
| }); |
| } |
| |
| @Override |
| protected void adjustLayoutData(boolean vis) { |
| super.adjustLayoutData(vis); |
| for (final AbstractSectionSWTRenderer childRenderer : childRenderers) { |
| boolean visible = vis; |
| if (getVElement().isCollapsed()) { |
| visible = false; |
| } |
| childRenderer.adjustLayoutData(visible); |
| } |
| } |
| |
| @Override |
| protected void applyEnable() { |
| getExpandableComposite().setEnabled(getVElement().isEffectivelyEnabled()); |
| } |
| |
| @Override |
| protected void dispose() { |
| getViewModelContext().unregisterViewChangeListener(listener); |
| super.dispose(); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.ecp.view.spi.section.swt.AbstractSectionSWTRenderer#initCollapseState() |
| * @since 1.6 |
| */ |
| @Override |
| protected void initCollapseState() { |
| /* top root gets current width as width hint so that further resizes will keep the column width intact */ |
| final Iterator<Control> iterator = getControls().values().iterator(); |
| while (iterator.hasNext()) { |
| final Control control = iterator.next(); |
| final int width = control.getSize().x; |
| final Object layoutData = control.getLayoutData(); |
| if (GridData.class.isInstance(layoutData)) { |
| final GridData gridData = (GridData) layoutData; |
| if (gridData == null) { |
| continue; |
| } |
| gridData.widthHint = width; |
| if (iterator.hasNext()) { |
| continue; |
| } |
| gridData.grabExcessHorizontalSpace = true; |
| } |
| |
| } |
| |
| handleCollapseState(); |
| } |
| |
| private void handleCollapseState() { |
| for (final AbstractSectionSWTRenderer childRenderer : childRenderers) { |
| childRenderer.adjustLayoutData(!getVElement() |
| .isCollapsed()); |
| } |
| getControls().values().iterator().next().getParent() |
| .layout(false); |
| getExpandableComposite().setExpanded(!getVElement() |
| .isCollapsed()); |
| } |
| |
| /** |
| * @return the expandableComposite |
| * @since 1.13 |
| */ |
| protected ExpandableComposite getExpandableComposite() { |
| return expandableComposite; |
| } |
| |
| /** |
| * @param expandableComposite the expandableComposite to set |
| * @since 1.13 |
| */ |
| protected void setExpandableComposite(ExpandableComposite expandableComposite) { |
| this.expandableComposite = expandableComposite; |
| } |
| |
| } |
