| /* |
| * Copyright 2000-2012 JetBrains s.r.o. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package com.intellij.uiDesigner.radComponents; |
| |
| import com.intellij.openapi.actionSystem.ActionGroup; |
| import com.intellij.openapi.actionSystem.DefaultActionGroup; |
| import com.intellij.openapi.project.Project; |
| import com.intellij.openapi.util.io.BufferExposingByteArrayOutputStream; |
| import com.intellij.uiDesigner.GridChangeUtil; |
| import com.intellij.uiDesigner.UIDesignerBundle; |
| import com.intellij.uiDesigner.UIFormXmlConstants; |
| import com.intellij.uiDesigner.XmlWriter; |
| import com.intellij.uiDesigner.actions.*; |
| import com.intellij.uiDesigner.compiler.FormLayoutUtils; |
| import com.intellij.uiDesigner.compiler.Utils; |
| import com.intellij.uiDesigner.core.GridConstraints; |
| import com.intellij.uiDesigner.designSurface.*; |
| import com.intellij.uiDesigner.lw.FormLayoutSerializer; |
| import com.intellij.uiDesigner.propertyInspector.Property; |
| import com.intellij.uiDesigner.propertyInspector.properties.AbstractInsetsProperty; |
| import com.intellij.uiDesigner.propertyInspector.properties.AlignPropertyProvider; |
| import com.intellij.uiDesigner.propertyInspector.properties.HorzAlignProperty; |
| import com.intellij.uiDesigner.propertyInspector.properties.VertAlignProperty; |
| import com.intellij.uiDesigner.snapShooter.SnapshotContext; |
| import com.intellij.util.ArrayUtil; |
| import com.intellij.util.ui.PlatformColors; |
| import com.jgoodies.forms.factories.FormFactory; |
| import com.jgoodies.forms.layout.*; |
| import org.jetbrains.annotations.NonNls; |
| import org.jetbrains.annotations.NotNull; |
| import org.jetbrains.annotations.Nullable; |
| |
| import javax.swing.*; |
| import java.awt.*; |
| import java.io.ByteArrayInputStream; |
| import java.io.InputStream; |
| import java.io.ObjectInputStream; |
| import java.io.ObjectOutputStream; |
| import java.lang.reflect.Method; |
| import java.util.ArrayList; |
| import java.util.List; |
| |
| /** |
| * @author yole |
| */ |
| public class RadFormLayoutManager extends RadAbstractGridLayoutManager implements AlignPropertyProvider { |
| private FormLayoutColumnProperties myPropertiesPanel; |
| |
| @NonNls private static final String ENCODED_FORMSPEC_GROW = "d:grow"; |
| private static final Size DEFAULT_NOGROW_SIZE = new BoundedSize(Sizes.DEFAULT, new ConstantSize(4, ConstantSize.PIXEL), null); |
| |
| @Nullable public String getName() { |
| return UIFormXmlConstants.LAYOUT_FORM; |
| } |
| |
| @Override @Nullable |
| public LayoutManager createLayout() { |
| return new FormLayout(ENCODED_FORMSPEC_GROW, ENCODED_FORMSPEC_GROW); |
| } |
| |
| @Override |
| protected void changeLayoutFromGrid(final RadContainer container, final List<RadComponent> contents, final List<Boolean> canRowsGrow, |
| final List<Boolean> canColumnsGrow) { |
| int rowCount = canRowsGrow.size(); |
| int columnCount = canColumnsGrow.size(); |
| int rowCountWithGaps = (rowCount == 0) ? 0 : rowCount * 2 - 1; |
| int columnCountWithGaps = (columnCount == 0) ? 0 : columnCount * 2 - 1; |
| RowSpec[] rowSpecs = new RowSpec [rowCountWithGaps]; |
| ColumnSpec[] colSpecs = new ColumnSpec [columnCountWithGaps]; |
| |
| for(int i=0; i<rowCount; i++) { |
| rowSpecs [i*2] = canRowsGrow.get(i).booleanValue() ? new RowSpec(ENCODED_FORMSPEC_GROW) : new RowSpec(DEFAULT_NOGROW_SIZE); |
| if (i*2+1 < rowSpecs.length) { |
| rowSpecs [i*2+1] = FormFactory.RELATED_GAP_ROWSPEC; |
| } |
| } |
| for(int i=0; i<columnCount; i++) { |
| colSpecs [i*2] = canColumnsGrow.get(i).booleanValue() ? new ColumnSpec(ENCODED_FORMSPEC_GROW) : new ColumnSpec(DEFAULT_NOGROW_SIZE); |
| if (i*2+1 < colSpecs.length) { |
| colSpecs [i*2+1] = FormFactory.RELATED_GAP_COLSPEC; |
| } |
| } |
| |
| container.setLayoutManager(this, new FormLayout(colSpecs, rowSpecs)); |
| } |
| |
| @Override |
| protected void changeLayoutFromIndexed(final RadContainer container, final List<RadComponent> components) { |
| int maxSizePolicy = 0; |
| for(RadComponent c: components) { |
| maxSizePolicy = Math.max(maxSizePolicy, c.getConstraints().getHSizePolicy()); |
| } |
| ColumnSpec[] colSpecs = new ColumnSpec [components.size() * 2 - 1]; |
| for(int i=0; i<components.size(); i++) { |
| colSpecs [i*2] = components.get(i).getConstraints().getHSizePolicy() == maxSizePolicy |
| ? new ColumnSpec(ENCODED_FORMSPEC_GROW) |
| : FormFactory.DEFAULT_COLSPEC; |
| if (i*2+1 < colSpecs.length) { |
| colSpecs [i*2+1] = FormFactory.RELATED_GAP_COLSPEC; |
| } |
| } |
| container.setLayoutManager(this, new FormLayout(colSpecs, new RowSpec[] { FormFactory.DEFAULT_ROWSPEC } )); |
| } |
| |
| @Override |
| public void writeLayout(final XmlWriter writer, final RadContainer radContainer) { |
| FormLayout layout = (FormLayout) radContainer.getLayout(); |
| for(int i=1; i<=layout.getRowCount(); i++) { |
| RowSpec rowSpec = layout.getRowSpec(i); |
| writer.startElement(UIFormXmlConstants.ELEMENT_ROWSPEC); |
| try { |
| writer.addAttribute(UIFormXmlConstants.ATTRIBUTE_VALUE, FormLayoutUtils.getEncodedSpec(rowSpec)); |
| } |
| finally { |
| writer.endElement(); |
| } |
| } |
| for(int i=1; i<=layout.getColumnCount(); i++) { |
| ColumnSpec columnSpec = layout.getColumnSpec(i); |
| writer.startElement(UIFormXmlConstants.ELEMENT_COLSPEC); |
| try { |
| writer.addAttribute(UIFormXmlConstants.ATTRIBUTE_VALUE, FormLayoutUtils.getEncodedSpec(columnSpec)); |
| } |
| finally { |
| writer.endElement(); |
| } |
| } |
| writeGroups(writer, UIFormXmlConstants.ELEMENT_ROWGROUP, layout.getRowGroups()); |
| writeGroups(writer, UIFormXmlConstants.ELEMENT_COLGROUP, layout.getColumnGroups()); |
| } |
| |
| private static void writeGroups(final XmlWriter writer, final String elementName, final int[][] groups) { |
| for(int[] group: groups) { |
| writer.startElement(elementName); |
| try { |
| for(int member: group) { |
| writer.startElement(UIFormXmlConstants.ELEMENT_MEMBER); |
| writer.addAttribute(UIFormXmlConstants.ATTRIBUTE_INDEX, member); |
| writer.endElement(); |
| } |
| } |
| finally { |
| writer.endElement(); |
| } |
| } |
| } |
| |
| @Override |
| public void addComponentToContainer(final RadContainer container, final RadComponent component, final int index) { |
| super.addComponentToContainer(container, component, index); |
| final CellConstraints cc = gridToCellConstraints(component); |
| if (component.getCustomLayoutConstraints() instanceof CellConstraints) { |
| CellConstraints customCellConstraints = (CellConstraints) component.getCustomLayoutConstraints(); |
| cc.insets = customCellConstraints.insets; |
| } |
| component.setCustomLayoutConstraints(cc); |
| container.getDelegee().add(component.getDelegee(), cc, index); |
| } |
| |
| private static CellConstraints gridToCellConstraints(final RadComponent component) { |
| GridConstraints gc = component.getConstraints(); |
| CellConstraints.Alignment hAlign = ((gc.getHSizePolicy() & GridConstraints.SIZEPOLICY_WANT_GROW) != 0) |
| ? CellConstraints.FILL |
| : CellConstraints.DEFAULT; |
| CellConstraints.Alignment vAlign = ((gc.getVSizePolicy() & GridConstraints.SIZEPOLICY_WANT_GROW) != 0) |
| ? CellConstraints.FILL |
| : CellConstraints.DEFAULT; |
| if (component.getCustomLayoutConstraints() instanceof CellConstraints) { |
| CellConstraints cc = (CellConstraints) component.getCustomLayoutConstraints(); |
| hAlign = cc.hAlign; |
| vAlign = cc.vAlign; |
| } |
| return new CellConstraints(gc.getColumn()+1, gc.getRow()+1, gc.getColSpan(), gc.getRowSpan(), hAlign, vAlign); |
| } |
| |
| @Override |
| public void writeChildConstraints(final XmlWriter writer, final RadComponent child) { |
| writeGridConstraints(writer, child); |
| if (child.getCustomLayoutConstraints() instanceof CellConstraints) { |
| CellConstraints cc = (CellConstraints) child.getCustomLayoutConstraints(); |
| writer.startElement(UIFormXmlConstants.ELEMENT_FORMS); |
| try { |
| if (!cc.insets.equals(new Insets(0, 0, 0, 0))) { |
| writer.addAttribute(UIFormXmlConstants.ATTRIBUTE_TOP, cc.insets.top); |
| writer.addAttribute(UIFormXmlConstants.ATTRIBUTE_LEFT, cc.insets.left); |
| writer.addAttribute(UIFormXmlConstants.ATTRIBUTE_BOTTOM, cc.insets.bottom); |
| writer.addAttribute(UIFormXmlConstants.ATTRIBUTE_RIGHT, cc.insets.right); |
| } |
| if (cc.hAlign != CellConstraints.DEFAULT) { |
| writer.addAttribute(UIFormXmlConstants.ATTRIBUTE_DEFAULTALIGN_HORZ, false); |
| } |
| if (cc.vAlign != CellConstraints.DEFAULT) { |
| writer.addAttribute(UIFormXmlConstants.ATTRIBUTE_DEFAULTALIGN_VERT, false); |
| } |
| } |
| finally { |
| writer.endElement(); |
| } |
| } |
| } |
| |
| private static FormLayout getFormLayout(final RadContainer container) { |
| return (FormLayout) container.getLayout(); |
| } |
| |
| @Override public int getGridRowCount(RadContainer container) { |
| return getFormLayout(container).getRowCount(); |
| } |
| |
| @Override public int getGridColumnCount(RadContainer container) { |
| return getFormLayout(container).getColumnCount(); |
| } |
| |
| @Override public int[] getGridCellCoords(RadContainer container, boolean isRow) { |
| final FormLayout.LayoutInfo layoutInfo = getFormLayout(container).getLayoutInfo(container.getDelegee()); |
| int[] origins = isRow ? layoutInfo.rowOrigins : layoutInfo.columnOrigins; |
| int[] result = new int [origins.length-1]; |
| System.arraycopy(origins, 0, result, 0, result.length); |
| return result; |
| } |
| |
| @Override public int[] getGridCellSizes(RadContainer container, boolean isRow) { |
| final FormLayout.LayoutInfo layoutInfo = getFormLayout(container).getLayoutInfo(container.getDelegee()); |
| int[] origins = isRow ? layoutInfo.rowOrigins : layoutInfo.columnOrigins; |
| int[] result = new int [origins.length-1]; |
| for(int i=0; i<result.length; i++) { |
| result [i] = origins [i+1] - origins [i]; |
| } |
| return result; |
| } |
| |
| @Override public int[] getHorizontalGridLines(RadContainer container) { |
| final FormLayout.LayoutInfo layoutInfo = getFormLayout(container).getLayoutInfo(container.getDelegee()); |
| return layoutInfo.rowOrigins; |
| } |
| |
| @Override public int[] getVerticalGridLines(RadContainer container) { |
| final FormLayout.LayoutInfo layoutInfo = getFormLayout(container).getLayoutInfo(container.getDelegee()); |
| return layoutInfo.columnOrigins; |
| } |
| |
| @Override public int getGridRowAt(RadContainer container, int y) { |
| final FormLayout.LayoutInfo layoutInfo = getFormLayout(container).getLayoutInfo(container.getDelegee()); |
| return findCell(layoutInfo.rowOrigins, y); |
| } |
| |
| @Override public int getGridColumnAt(RadContainer container, int x) { |
| final FormLayout.LayoutInfo layoutInfo = getFormLayout(container).getLayoutInfo(container.getDelegee()); |
| return findCell(layoutInfo.columnOrigins, x); |
| } |
| |
| private static int findCell(final int[] origins, final int coord) { |
| for(int i=0; i<origins.length-1; i++) { |
| if (coord >= origins [i] && coord < origins [i+1]) return i; |
| } |
| return -1; |
| } |
| |
| @NotNull @Override |
| public ComponentDropLocation getDropLocation(@NotNull RadContainer container, @Nullable final Point location) { |
| FormLayout formLayout = getFormLayout(container); |
| if (formLayout.getRowCount() == 0 || formLayout.getColumnCount() == 0) { |
| if (location != null) { |
| Rectangle rc = new Rectangle(new Point(), container.getDelegee().getSize()); |
| return new FormFirstComponentInsertLocation(container, location, rc); |
| } |
| } |
| final FormLayout.LayoutInfo layoutInfo = formLayout.getLayoutInfo(container.getDelegee()); |
| if (location != null && location.x > layoutInfo.getWidth()) { |
| int row = findCell(layoutInfo.rowOrigins, location.y); |
| if (row == -1) { |
| return NoDropLocation.INSTANCE; |
| } |
| return new GridInsertLocation(container, row, getGridColumnCount(container)-1, GridInsertMode.ColumnAfter); |
| } |
| if (location != null && location.y > layoutInfo.getHeight()) { |
| int column = findCell(layoutInfo.columnOrigins, location.x); |
| if (column == -1) { |
| return NoDropLocation.INSTANCE; |
| } |
| return new GridInsertLocation(container, getGridRowCount(container)-1, column, GridInsertMode.RowAfter); |
| } |
| |
| if (container.getGridRowCount() == 1 && container.getGridColumnCount() == 1 && |
| getComponentAtGrid(container, 0, 0) == null) { |
| final Rectangle rc = getGridCellRangeRect(container, 0, 0, 0, 0); |
| if (location == null) { |
| return new FormFirstComponentInsertLocation(container, rc, 0, 0); |
| } |
| return new FormFirstComponentInsertLocation(container, location, rc); |
| } |
| |
| return super.getDropLocation(container, location); |
| } |
| |
| @Override |
| public CustomPropertiesPanel getRowColumnPropertiesPanel(RadContainer container, boolean isRow, int[] selectedIndices) { |
| if (myPropertiesPanel == null) { |
| myPropertiesPanel = new FormLayoutColumnProperties(); |
| } |
| myPropertiesPanel.showProperties(container, isRow, selectedIndices); |
| return myPropertiesPanel; |
| } |
| |
| @Override |
| public ActionGroup getCaptionActions() { |
| DefaultActionGroup group = new DefaultActionGroup(); |
| group.add(new InsertBeforeAction()); |
| group.add(new InsertAfterAction()); |
| group.add(new SplitAction()); |
| group.add(new DeleteAction()); |
| group.add(new GroupRowsColumnsAction()); |
| group.add(new UngroupRowsColumnsAction()); |
| return group; |
| } |
| |
| @Override |
| public boolean canCellGrow(RadContainer container, boolean isRow, int index) { |
| FormLayout layout = (FormLayout) container.getLayout(); |
| FormSpec spec = isRow ? layout.getRowSpec(index+1) : layout.getColumnSpec(index+1); |
| return spec.getResizeWeight() > 0.01d; |
| } |
| |
| @Override |
| public void setChildDragging(RadComponent child, boolean dragging) { |
| // do nothing here - otherwise the layout will jump around |
| } |
| |
| @Override |
| public void paintCaptionDecoration(final RadContainer container, final boolean isRow, final int index, final Graphics2D g2d, |
| final Rectangle rc) { |
| // don't paint gap rows/columns with red background |
| if (isGapCell(container, isRow, index)) { |
| g2d.setColor(Color.LIGHT_GRAY); |
| g2d.fillRect(rc.x, rc.y, rc.width, rc.height); |
| } |
| |
| if (canCellGrow(container, isRow, index)) { |
| drawGrowMarker(isRow, g2d, rc); |
| } |
| |
| FormLayout layout = (FormLayout) container.getLayout(); |
| int[][] groups = isRow ? layout.getRowGroups() : layout.getColumnGroups(); |
| //noinspection MultipleVariablesInDeclaration |
| boolean haveTopLeft = false, haveTopRight = false, haveTopLine = false; |
| //noinspection MultipleVariablesInDeclaration |
| boolean haveBottomLeft = false, haveBottomRight = false, haveBottomLine = false; |
| boolean inGroup = false; |
| for(int i=0; i<groups.length; i++) { |
| int minMember = Integer.MAX_VALUE; |
| int maxMember = -1; |
| for(int member: groups [i]) { |
| minMember = Math.min(member-1, minMember); |
| maxMember = Math.max(member-1, maxMember); |
| inGroup = inGroup || (member-1 == index); |
| } |
| if (minMember <= index && index <= maxMember) { |
| if (i % 2 == 0) { |
| haveTopLeft = haveTopLeft || index > minMember; |
| haveTopRight = haveTopRight || index < maxMember; |
| haveTopLine = haveTopLine || inGroup; |
| } |
| else { |
| haveBottomLeft = haveBottomLeft || index > minMember; |
| haveBottomRight = haveBottomRight || index < maxMember; |
| haveBottomLine = haveBottomLine || inGroup; |
| } |
| } |
| } |
| |
| g2d.setColor(PlatformColors.BLUE); |
| drawGroupLine(rc, isRow, g2d, true, haveTopLeft, haveTopRight, haveTopLine); |
| drawGroupLine(rc, isRow, g2d, false, haveBottomLeft, haveBottomRight, haveBottomLine); |
| } |
| |
| private static void drawGroupLine(final Rectangle rc, final boolean isRow, final Graphics2D g2d, boolean isTop, |
| final boolean haveLeft, final boolean haveRight, final boolean haveLine) { |
| |
| int maxX = (int) rc.getMaxX(); |
| int maxY = (int) rc.getMaxY(); |
| Point linePos = isTop ? new Point(rc.x+1, rc.y+1) : new Point(rc.x+3, rc.y+3); |
| Point markerPos = new Point(rc.x+6, rc.y+6); |
| |
| int midX = (int) rc.getCenterX(); |
| int midY = (int) rc.getCenterY(); |
| if (haveLine) { |
| if (isRow) { |
| g2d.drawLine(linePos.x, midY, markerPos.x, midY); |
| } |
| else { |
| g2d.drawLine(midX, linePos.y, midX, markerPos.y); |
| } |
| } |
| if (haveLeft) { |
| if (isRow) { |
| g2d.drawLine(linePos.x, rc.y, linePos.x, midY); |
| } |
| else { |
| g2d.drawLine(rc.x, linePos.y, midX, linePos.y); |
| } |
| } |
| if (haveRight) { |
| if (isRow) { |
| g2d.drawLine(linePos.x, midY, linePos.x, maxY); |
| } |
| else { |
| g2d.drawLine(midX, linePos.y, maxX, linePos.y); |
| } |
| } |
| } |
| |
| @Override |
| public Property[] getContainerProperties(final Project project) { |
| return Property.EMPTY_ARRAY; |
| } |
| |
| @Override |
| public Property[] getComponentProperties(final Project project, final RadComponent component) { |
| return new Property[] { |
| HorzAlignProperty.getInstance(project), |
| VertAlignProperty.getInstance(project), |
| new ComponentInsetsProperty() |
| }; |
| } |
| |
| @Override |
| public int insertGridCells(final RadContainer grid, final int cellIndex, final boolean isRow, final boolean isBefore, final boolean grow) { |
| FormSpec formSpec; |
| if (isRow) { |
| formSpec = grow ? new RowSpec(ENCODED_FORMSPEC_GROW) : new RowSpec(DEFAULT_NOGROW_SIZE); |
| } |
| else { |
| formSpec = grow ? new ColumnSpec(ENCODED_FORMSPEC_GROW) : new ColumnSpec(DEFAULT_NOGROW_SIZE); |
| } |
| insertGridCells(grid, cellIndex, isRow, isBefore, formSpec); |
| return getGridCellCount(grid, isRow) == 1 ? 1 : 2; |
| } |
| |
| @Override |
| public void copyGridCells(RadContainer source, final RadContainer destination, final boolean isRow, int cellIndex, int cellCount, int targetIndex) { |
| FormLayout sourceLayout = getFormLayout(source); |
| FormLayout destinationLayout = getFormLayout(destination); |
| if (isRow) { |
| insertOrAppendRow(destinationLayout, targetIndex+1, FormFactory.RELATED_GAP_ROWSPEC); |
| } |
| else { |
| insertOrAppendColumn(destinationLayout, targetIndex+1, FormFactory.RELATED_GAP_COLSPEC); |
| } |
| targetIndex++; |
| if (targetIndex < cellIndex) cellIndex++; |
| copyFormSpecs(sourceLayout, destinationLayout, isRow, cellIndex, cellCount, targetIndex); |
| updateGridConstraintsFromCellConstraints(destination); |
| } |
| |
| private static void copyFormSpecs(final FormLayout sourceLayout, |
| final FormLayout destinationLayout, |
| final boolean isRow, |
| int cellIndex, |
| int cellCount, |
| int targetIndex) { |
| for(int i=0; i < cellCount; i++) { |
| if (isRow) { |
| RowSpec rowSpec = sourceLayout.getRowSpec(cellIndex + 1); |
| insertOrAppendRow(destinationLayout, targetIndex+1, rowSpec); |
| } |
| else { |
| ColumnSpec colSpec = sourceLayout.getColumnSpec(cellIndex + 1); |
| insertOrAppendColumn(destinationLayout, targetIndex+1, colSpec); |
| } |
| cellIndex += (targetIndex < cellIndex && sourceLayout == destinationLayout) ? 2 : 1; |
| targetIndex++; |
| } |
| } |
| |
| @Override |
| public void copyGridSection(final RadContainer source, final RadContainer destination, final Rectangle rc) { |
| final FormLayout destinationLayout = new FormLayout(); |
| destination.setLayout(destinationLayout); |
| copyFormSpecs(getFormLayout(source), destinationLayout, true, rc.y, rc.height, 0); |
| copyFormSpecs(getFormLayout(source), destinationLayout, false, rc.x, rc.width, 0); |
| } |
| |
| @Override |
| public int getGapCellCount() { |
| return 1; |
| } |
| |
| @Override |
| public int getGapCellSize(final RadContainer container, boolean isRow) { |
| Size size = isRow ? FormFactory.RELATED_GAP_ROWSPEC.getSize() : FormFactory.RELATED_GAP_COLSPEC.getSize(); |
| if (size instanceof ConstantSize) { |
| return ((ConstantSize) size).getPixelSize(container.getDelegee()); |
| } |
| return 0; |
| } |
| |
| @Override |
| public boolean isGapCell(RadContainer grid, boolean isRow, int cellIndex) { |
| if (cellIndex < 0 || cellIndex >= getGridCellCount(grid, isRow)) { |
| return false; |
| } |
| if (cellIndex % 2 == 1) { |
| final GridChangeUtil.CellStatus status = GridChangeUtil.canDeleteCell(grid, cellIndex, isRow); |
| if (status == GridChangeUtil.CellStatus.Empty || status == GridChangeUtil.CellStatus.Redundant) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| @Override |
| public int getCellIndexBase() { |
| return 1; |
| } |
| |
| /** |
| * @return index where new column or row was actually inserted (0-based) |
| */ |
| private int insertGridCells(RadContainer grid, int cellIndex, boolean isRow, boolean isBefore, FormSpec formSpec) { |
| FormLayout formLayout = (FormLayout) grid.getLayout(); |
| int index = isBefore ? cellIndex+1 : cellIndex+2; |
| if (isRow) { |
| if (getGridCellCount(grid, true) > 0) { |
| insertOrAppendRow(formLayout, index, FormFactory.RELATED_GAP_ROWSPEC); |
| if (!isBefore) index++; |
| } |
| insertOrAppendRow(formLayout, index, (RowSpec) formSpec); |
| } |
| else { |
| if (getGridCellCount(grid, false) > 0) { |
| insertOrAppendColumn(formLayout, index, FormFactory.RELATED_GAP_COLSPEC); |
| if (!isBefore) index++; |
| } |
| insertOrAppendColumn(formLayout, index, (ColumnSpec)formSpec); |
| } |
| updateGridConstraintsFromCellConstraints(grid); |
| return index-1; |
| } |
| |
| private static void insertOrAppendRow(final FormLayout formLayout, final int index, final RowSpec rowSpec) { |
| if (index == formLayout.getRowCount()+1) { |
| formLayout.appendRow(rowSpec); |
| } |
| else { |
| formLayout.insertRow(index, rowSpec); |
| } |
| } |
| |
| private static void insertOrAppendColumn(final FormLayout formLayout, final int index, final ColumnSpec columnSpec) { |
| if (index == formLayout.getColumnCount()+1) { |
| formLayout.appendColumn(columnSpec); |
| } |
| else { |
| formLayout.insertColumn(index, columnSpec); |
| } |
| } |
| |
| @Override |
| public int deleteGridCells(final RadContainer grid, final int cellIndex, final boolean isRow) { |
| int result = 1; |
| FormLayout formLayout = (FormLayout) grid.getLayout(); |
| adjustDeletedCellOrigins(grid, cellIndex, isRow); |
| if (isRow) { |
| int[][] groupIndices = formLayout.getRowGroups(); |
| groupIndices = removeDeletedCell(groupIndices, cellIndex+1); |
| formLayout.setRowGroups(groupIndices); |
| formLayout.removeRow(cellIndex+1); |
| updateGridConstraintsFromCellConstraints(grid); |
| if (formLayout.getRowCount() > 0 && formLayout.getRowCount() % 2 == 0) { |
| int gapRowIndex = (cellIndex >= grid.getGridRowCount()) ? cellIndex-1 : cellIndex; |
| if (GridChangeUtil.isRowEmpty(grid, gapRowIndex)) { |
| formLayout.removeRow(gapRowIndex+1); |
| updateGridConstraintsFromCellConstraints(grid); |
| result++; |
| } |
| } |
| } |
| else { |
| int[][] groupIndices = formLayout.getColumnGroups(); |
| groupIndices = removeDeletedCell(groupIndices, cellIndex+1); |
| formLayout.setColumnGroups(groupIndices); |
| formLayout.removeColumn(cellIndex+1); |
| updateGridConstraintsFromCellConstraints(grid); |
| if (formLayout.getColumnCount() > 0 && formLayout.getColumnCount() % 2 == 0) { |
| int gapColumnIndex = (cellIndex >= grid.getGridColumnCount()) ? cellIndex-1 : cellIndex; |
| if (GridChangeUtil.isColumnEmpty(grid, gapColumnIndex)) { |
| formLayout.removeColumn(gapColumnIndex+1); |
| updateGridConstraintsFromCellConstraints(grid); |
| result++; |
| } |
| } |
| } |
| return result; |
| } |
| |
| private void adjustDeletedCellOrigins(final RadContainer grid, final int cellIndex, final boolean isRow) { |
| int gapCellDelta = isGapCell(grid, isRow, cellIndex+1) ? 2 : 1; |
| for(RadComponent component: grid.getComponents()) { |
| // ensure that we don't have component origins in the deleted cells |
| final GridConstraints gc = component.getConstraints(); |
| if (gc.getCell(isRow) == cellIndex) { |
| final int span = gc.getSpan(isRow); |
| if (span > gapCellDelta) { |
| gc.setCell(isRow, cellIndex+gapCellDelta); |
| gc.setSpan(isRow, span -gapCellDelta); |
| updateConstraints(component); |
| } |
| else { |
| throw new IllegalArgumentException("Attempt to delete grid row/column which contains origins of 1-span components"); |
| } |
| } |
| } |
| } |
| |
| private static int[][] removeDeletedCell(final int[][] groupIndices, final int deletedIndex) { |
| for(int i=0; i<groupIndices.length; i++) { |
| for(int j=0; j<groupIndices [i].length; j++) { |
| if (groupIndices [i][j] == deletedIndex) { |
| int[][] newIndices; |
| if (groupIndices [i].length <= 2) { |
| // deleted cell is contained in a group with 1 or 2 cells => delete entire group |
| newIndices = new int[groupIndices.length-1][]; |
| for (int newI = 0; newI < i; newI++) { |
| newIndices [newI] = new int[groupIndices [newI].length]; |
| System.arraycopy(groupIndices [newI], 0, newIndices [newI], 0, groupIndices [newI].length); |
| } |
| for(int newI=i+1; newI<groupIndices.length; newI++) { |
| newIndices [newI-1] = new int[groupIndices [newI].length]; |
| System.arraycopy(groupIndices [newI], 0, newIndices [newI-1], 0, groupIndices [newI].length); |
| } |
| } |
| else { |
| // deleted cell is contained in a group with more than 2 cells => keep the group and delete only the item |
| newIndices = new int[groupIndices.length][]; |
| for(int newI=0; newI<groupIndices.length; newI++) { |
| if (newI == i) { |
| newIndices [newI] = new int[groupIndices [newI].length-1]; |
| System.arraycopy(groupIndices [newI], 0, newIndices [newI], 0, j); |
| System.arraycopy(groupIndices [newI], j+1, newIndices [newI], j, groupIndices [i].length-j-1); |
| } |
| else { |
| newIndices [newI] = new int[groupIndices [newI].length]; |
| System.arraycopy(groupIndices [newI], 0, newIndices [newI], 0, groupIndices [i].length); |
| } |
| } |
| } |
| return newIndices; |
| } |
| } |
| } |
| return groupIndices; |
| } |
| |
| @Override @Nullable |
| public String getCellResizeTooltip(RadContainer container, boolean isRow, int cell, int newSize) { |
| final String size = getUpdatedSize(container, isRow, cell, newSize).toString(); |
| return isRow |
| ? UIDesignerBundle.message("tooltip.resize.row", cell+getCellIndexBase(), size) |
| : UIDesignerBundle.message("tooltip.resize.column", cell+getCellIndexBase(), size); |
| } |
| |
| @Override |
| public void processCellResized(RadContainer container, final boolean isRow, final int cell, final int newSize) { |
| FormLayout formLayout = (FormLayout) container.getLayout(); |
| final ConstantSize updatedSize = getUpdatedSize(container, isRow, cell, newSize); |
| FormSpec newSpec; |
| if (isRow) { |
| RowSpec rowSpec = formLayout.getRowSpec(cell+1); |
| newSpec = new RowSpec(rowSpec.getDefaultAlignment(), updatedSize, rowSpec.getResizeWeight()); |
| } |
| else { |
| ColumnSpec colSpec = formLayout.getColumnSpec(cell+1); |
| newSpec = new ColumnSpec(colSpec.getDefaultAlignment(), updatedSize, colSpec.getResizeWeight()); |
| } |
| setSpec(formLayout, newSpec, cell+1, isRow); |
| resizeSameGroupCells(cell, formLayout, newSpec, isRow); |
| } |
| |
| // Explicitly resize all cells in the group to desired size to make sure that the resize operation is effective (IDEADEV-10202) |
| private static void resizeSameGroupCells(final int cell, final FormLayout formLayout, final FormSpec newSpec, final boolean isRow) { |
| int[][] groups = isRow ? formLayout.getRowGroups() : formLayout.getColumnGroups(); |
| for(int[] group: groups) { |
| boolean foundGroup = false; |
| for(int groupCell: group) { |
| if (groupCell == cell+1) { |
| foundGroup = true; |
| break; |
| } |
| } |
| if (foundGroup) { |
| for(int groupCell: group) { |
| setSpec(formLayout, newSpec, groupCell, isRow); |
| } |
| break; |
| } |
| } |
| } |
| |
| private static void setSpec(final FormLayout formLayout, final FormSpec newSpec, final int cell, boolean isRow) { |
| if (isRow) { |
| formLayout.setRowSpec(cell, (RowSpec) newSpec); |
| } |
| else { |
| formLayout.setColumnSpec(cell, (ColumnSpec) newSpec); |
| } |
| } |
| |
| private static ConstantSize getUpdatedSize(RadContainer container, boolean isRow, int cell, int newPx) { |
| FormLayout formLayout = (FormLayout) container.getLayout(); |
| if (isRow) { |
| return scaleSize(formLayout.getRowSpec(cell+1), container, newPx); |
| } |
| else { |
| return scaleSize(formLayout.getColumnSpec(cell+1), container, newPx); |
| } |
| } |
| |
| private static ConstantSize scaleSize(final FormSpec rowSpec, final RadContainer container, final int newPx) { |
| if (rowSpec.getSize() instanceof ConstantSize) { |
| ConstantSize oldSize = (ConstantSize) rowSpec.getSize(); |
| int oldPx = oldSize.getPixelSize(container.getDelegee()); |
| double newValue = Math.round(oldSize.getValue() * newPx / oldPx * 10) / 10; |
| return new ConstantSize(newValue, oldSize.getUnit()); |
| } |
| return new ConstantSize(newPx, ConstantSize.PIXEL); |
| } |
| |
| @Override |
| public void processCellsMoved(final RadContainer container, final boolean isRow, final int[] cellsToMove, int targetCell) { |
| for(int i=0; i<cellsToMove.length; i++) { |
| final int sourceCell = cellsToMove[i]; |
| moveCells(container, isRow, sourceCell, targetCell); |
| if (sourceCell < targetCell) { |
| for(int j=i+1; j<cellsToMove.length; j++) { |
| cellsToMove [j] -= 2; |
| } |
| } |
| else { |
| targetCell += 2; |
| } |
| } |
| } |
| |
| private void moveCells(final RadContainer container, final boolean isRow, final int cell, int targetCell) { |
| if (targetCell >= cell && targetCell <= cell+2) { |
| return; |
| } |
| FormLayout layout = (FormLayout) container.getLayout(); |
| List<RadComponent> componentsToMove = new ArrayList<RadComponent>(); |
| FormSpec oldSpec = isRow ? layout.getRowSpec(cell+1) : layout.getColumnSpec(cell+1); |
| for(RadComponent c: container.getComponents()) { |
| if (c.getConstraints().getCell(isRow) == cell) { |
| componentsToMove.add(c); |
| container.removeComponent(c); |
| } |
| } |
| int count = deleteGridCells(container, cell, isRow); |
| int insertCell = (targetCell > cell) ? targetCell - count - 1 : targetCell; |
| final boolean isBefore = targetCell < cell; |
| int newIndex = insertGridCells(container, insertCell, isRow, isBefore, oldSpec); |
| for(RadComponent c: componentsToMove) { |
| c.getConstraints().setCell(isRow, newIndex); |
| container.addComponent(c); |
| } |
| } |
| |
| private static void updateGridConstraintsFromCellConstraints(RadContainer grid) { |
| FormLayout layout = (FormLayout) grid.getLayout(); |
| for(RadComponent c: grid.getComponents()) { |
| CellConstraints cc = layout.getConstraints(c.getDelegee()); |
| GridConstraints gc = c.getConstraints(); |
| copyCellToGridConstraints(gc, cc); |
| } |
| } |
| |
| private static void copyCellToGridConstraints(final GridConstraints gc, final CellConstraints cc) { |
| gc.setColumn(cc.gridX-1); |
| gc.setRow(cc.gridY-1); |
| gc.setColSpan(cc.gridWidth); |
| gc.setRowSpan(cc.gridHeight); |
| } |
| |
| public int getAlignment(RadComponent component, boolean horizontal) { |
| CellConstraints cc = (CellConstraints) component.getCustomLayoutConstraints(); |
| CellConstraints.Alignment al = horizontal ? cc.hAlign : cc.vAlign; |
| if (al == CellConstraints.DEFAULT) { |
| FormLayout formLayout = (FormLayout) component.getParent().getLayout(); |
| FormSpec formSpec = horizontal |
| ? formLayout.getColumnSpec(component.getConstraints().getColumn()+1) |
| : formLayout.getRowSpec(component.getConstraints().getRow()+1); |
| final FormSpec.DefaultAlignment defaultAlignment = formSpec.getDefaultAlignment(); |
| if (defaultAlignment.equals(RowSpec.FILL)) { |
| return GridConstraints.ALIGN_FILL; |
| } |
| if (defaultAlignment.equals(RowSpec.TOP) || defaultAlignment.equals(ColumnSpec.LEFT)) { |
| return GridConstraints.ALIGN_LEFT; |
| } |
| if (defaultAlignment.equals(RowSpec.CENTER)) { |
| return GridConstraints.ALIGN_CENTER; |
| } |
| return GridConstraints.ALIGN_RIGHT; |
| } |
| return Utils.alignFromConstraints(component.getConstraints(), horizontal); |
| } |
| |
| public void setAlignment(RadComponent component, boolean horizontal, int alignment) { |
| CellConstraints cc = (CellConstraints) component.getCustomLayoutConstraints(); |
| if (horizontal) { |
| cc.hAlign = FormLayoutSerializer.ourHorizontalAlignments [alignment]; |
| } |
| else { |
| cc.vAlign = FormLayoutSerializer.ourVerticalAlignments [alignment]; |
| } |
| updateConstraints(component); |
| } |
| |
| public void resetAlignment(RadComponent component, boolean horizontal) { |
| CellConstraints cc = (CellConstraints) component.getCustomLayoutConstraints(); |
| if (horizontal) { |
| cc.hAlign = CellConstraints.DEFAULT; |
| } |
| else { |
| cc.vAlign = CellConstraints.DEFAULT; |
| } |
| updateConstraints(component); |
| } |
| |
| public boolean isAlignmentModified(RadComponent component, boolean horizontal) { |
| CellConstraints cc = (CellConstraints) component.getCustomLayoutConstraints(); |
| CellConstraints.Alignment al = horizontal ? cc.hAlign : cc.vAlign; |
| return al != CellConstraints.DEFAULT; |
| } |
| |
| @Override |
| protected void updateConstraints(final RadComponent component) { |
| FormLayout layout = (FormLayout) component.getParent().getLayout(); |
| layout.setConstraints(component.getDelegee(), gridToCellConstraints(component)); |
| super.updateConstraints(component); |
| } |
| |
| public int getMinCellCount() { |
| return 0; |
| } |
| |
| @Override |
| public void createSnapshotLayout(final SnapshotContext context, |
| final JComponent parent, |
| final RadContainer container, |
| final LayoutManager layout) { |
| ColumnSpec[] colSpecs; |
| RowSpec[] rowSpecs; |
| int[][] rowGroups; |
| int[][] columnGroups; |
| try { |
| Method method = layout.getClass().getMethod("getRowCount", ArrayUtil.EMPTY_CLASS_ARRAY); |
| int rowCount = ((Integer)method.invoke(layout, ArrayUtil.EMPTY_OBJECT_ARRAY)).intValue(); |
| method = layout.getClass().getMethod("getColumnCount", ArrayUtil.EMPTY_CLASS_ARRAY); |
| int columnCount = ((Integer)method.invoke(layout, ArrayUtil.EMPTY_OBJECT_ARRAY)).intValue(); |
| |
| rowSpecs = new RowSpec[rowCount]; |
| colSpecs = new ColumnSpec[columnCount]; |
| |
| method = layout.getClass().getMethod("getRowSpec", int.class); |
| for (int i = 0; i < rowCount; i++) { |
| rowSpecs[i] = (RowSpec)createSerializedCopy(method.invoke(layout, i + 1)); |
| } |
| method = layout.getClass().getMethod("getColumnSpec", int.class); |
| for (int i = 0; i < columnCount; i++) { |
| colSpecs[i] = (ColumnSpec)createSerializedCopy(method.invoke(layout, i + 1)); |
| } |
| |
| method = layout.getClass().getMethod("getRowGroups", ArrayUtil.EMPTY_CLASS_ARRAY); |
| rowGroups = (int[][])method.invoke(layout); |
| |
| method = layout.getClass().getMethod("getColumnGroups", ArrayUtil.EMPTY_CLASS_ARRAY); |
| columnGroups = (int[][])method.invoke(layout); |
| } |
| catch (Exception ex) { |
| throw new RuntimeException(ex); |
| } |
| |
| final FormLayout formLayout = new FormLayout(colSpecs, rowSpecs); |
| formLayout.setRowGroups(rowGroups); |
| formLayout.setColumnGroups(columnGroups); |
| container.setLayout(formLayout); |
| } |
| |
| private static Object createSerializedCopy(final Object original) { |
| // FormLayout may have been loaded with a different classloader, so we need to create a copy through serialization |
| Object copy; |
| try { |
| BufferExposingByteArrayOutputStream baos = new BufferExposingByteArrayOutputStream(); |
| ObjectOutputStream os = new ObjectOutputStream(baos); |
| try { |
| os.writeObject(original); |
| } |
| finally { |
| os.close(); |
| } |
| |
| InputStream bais = new ByteArrayInputStream(baos.getInternalBuffer(), 0, baos.size()); |
| ObjectInputStream is = new ObjectInputStream(bais); |
| try { |
| copy = is.readObject(); |
| } |
| finally { |
| is.close(); |
| } |
| } |
| catch (Exception e) { |
| throw new RuntimeException(e); |
| } |
| return copy; |
| } |
| |
| @Override |
| public void addSnapshotComponent(final JComponent parent, |
| final JComponent child, |
| final RadContainer container, |
| final RadComponent component) { |
| CellConstraints cc; |
| try { |
| LayoutManager layout = parent.getLayout(); |
| //noinspection HardCodedStringLiteral |
| Method method = layout.getClass().getMethod("getConstraints", Component.class); |
| cc = (CellConstraints)createSerializedCopy(method.invoke(layout, child)); |
| } |
| catch (Exception ex) { |
| throw new RuntimeException(ex); |
| } |
| copyCellToGridConstraints(component.getConstraints(), cc); |
| component.setCustomLayoutConstraints(cc); |
| container.addComponent(component); |
| } |
| |
| private static class ComponentInsetsProperty extends AbstractInsetsProperty<RadComponent> { |
| public ComponentInsetsProperty() { |
| super(null, "Insets"); |
| } |
| |
| public Insets getValue(final RadComponent component) { |
| if (component.getCustomLayoutConstraints() instanceof CellConstraints) { |
| final CellConstraints cellConstraints = (CellConstraints)component.getCustomLayoutConstraints(); |
| return cellConstraints.insets; |
| } |
| return new Insets(0, 0, 0, 0); |
| } |
| |
| protected void setValueImpl(final RadComponent component, final Insets value) throws Exception { |
| if (component.getCustomLayoutConstraints() instanceof CellConstraints) { |
| final CellConstraints cellConstraints = (CellConstraints)component.getCustomLayoutConstraints(); |
| cellConstraints.insets = value; |
| |
| FormLayout layout = (FormLayout) component.getParent().getLayout(); |
| CellConstraints cc = (CellConstraints)layout.getConstraints(component.getDelegee()).clone(); |
| cc.insets = value; |
| layout.setConstraints(component.getDelegee(), cc); |
| } |
| } |
| } |
| } |
