| /* |
| * Copyright 2000-2009 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.core; |
| |
| import java.awt.*; |
| |
| /** |
| * @author Anton Katilin |
| * @author Vladimir Kondratyev |
| */ |
| public final class GridConstraints implements Cloneable { |
| public static final GridConstraints[] EMPTY_ARRAY = new GridConstraints[0]; |
| public static final int FILL_NONE = 0; |
| public static final int FILL_HORIZONTAL = 1; |
| public static final int FILL_VERTICAL = 2; |
| public static final int FILL_BOTH = FILL_HORIZONTAL | FILL_VERTICAL; |
| |
| /** |
| * Put the component in the center of its display area. |
| */ |
| public static final int ANCHOR_CENTER = 0; |
| |
| /** |
| * Put the component at the top of its display area, |
| * centered horizontally. |
| */ |
| public static final int ANCHOR_NORTH = 1; |
| |
| /** |
| * Put the component at the bottom of its display area, centered |
| * horizontally. |
| */ |
| public static final int ANCHOR_SOUTH = 2; |
| |
| /** |
| * Put the component on the right side of its display area, |
| * centered vertically. |
| */ |
| public static final int ANCHOR_EAST = 4; |
| |
| /** |
| * Put the component on the left side of its display area, |
| * centered vertically. |
| */ |
| public static final int ANCHOR_WEST = 8; |
| |
| /** |
| * Put the component at the top-right corner of its display area. |
| */ |
| public static final int ANCHOR_NORTHEAST = ANCHOR_NORTH | ANCHOR_EAST; |
| |
| /** |
| * Put the component at the bottom-right corner of its display area. |
| */ |
| public static final int ANCHOR_SOUTHEAST = ANCHOR_SOUTH | ANCHOR_EAST; |
| |
| /** |
| * Put the component at the bottom-left corner of its display area. |
| */ |
| public static final int ANCHOR_SOUTHWEST = ANCHOR_SOUTH | ANCHOR_WEST; |
| |
| |
| /** |
| * Put the component at the top-left corner of its display area. |
| */ |
| public static final int ANCHOR_NORTHWEST = ANCHOR_NORTH | ANCHOR_WEST; |
| |
| /** |
| * TODO[anton,vova] write javadoc |
| */ |
| public static final int SIZEPOLICY_FIXED = 0; |
| public static final int SIZEPOLICY_CAN_SHRINK = 1; |
| public static final int SIZEPOLICY_CAN_GROW = 2; |
| public static final int SIZEPOLICY_WANT_GROW = 4; |
| |
| public static final int ALIGN_LEFT = 0; |
| public static final int ALIGN_CENTER = 1; |
| public static final int ALIGN_RIGHT = 2; |
| public static final int ALIGN_FILL = 3; |
| |
| private int myRow; |
| private int myColumn; |
| private int myRowSpan; |
| private int myColSpan; |
| private int myVSizePolicy; |
| private int myHSizePolicy; |
| private int myFill; |
| private int myAnchor; |
| |
| /** |
| * @see #myPreferredSize |
| */ |
| public final Dimension myMinimumSize; |
| |
| /** |
| * overridden preferred size. Never <code>null</code>. Term "overridden" means that GridLayoutManager gets |
| * preferred size from the constrains first. Moreover if one of the returned dimensions (x or y) |
| * is negative then the corresponding dimension is also calculated by the component. |
| * It means that it's possible to override any particular dimension without subclassing |
| * of the component. Stantard Swing doesn't have such capability. |
| */ |
| public final Dimension myPreferredSize; |
| |
| /** |
| * @see #myPreferredSize |
| */ |
| public final Dimension myMaximumSize; |
| |
| /** |
| * Additonal offset of the component from the left part of its cell boundary, expressed in multiples |
| * of the HIG-specified indent step. |
| */ |
| private int myIndent; |
| |
| /** |
| * If true, a component with grid layout embedded in a parent with grid layout uses the parent's |
| * column sizes. |
| */ |
| private boolean myUseParentLayout; |
| |
| public GridConstraints(){ |
| myRowSpan = 1; |
| myColSpan = 1; |
| myVSizePolicy = SIZEPOLICY_CAN_GROW | SIZEPOLICY_CAN_SHRINK; |
| myHSizePolicy = SIZEPOLICY_CAN_GROW | SIZEPOLICY_CAN_SHRINK; |
| myFill = FILL_NONE; |
| myAnchor = ANCHOR_CENTER; |
| myMinimumSize = new Dimension(-1, -1); |
| myPreferredSize = new Dimension(-1, -1); |
| myMaximumSize = new Dimension(-1, -1); |
| myIndent = 0; |
| } |
| |
| public GridConstraints( |
| final int row, |
| final int column, |
| final int rowSpan, |
| final int colSpan, |
| final int anchor, |
| final int fill, |
| final int HSizePolicy, |
| final int VSizePolicy, |
| final Dimension minimumSize, |
| final Dimension preferredSize, |
| final Dimension maximumSize) { |
| myRow = row; |
| myColumn = column; |
| myRowSpan = rowSpan; |
| myColSpan = colSpan; |
| myAnchor = anchor; |
| myFill = fill; |
| myHSizePolicy = HSizePolicy; |
| myVSizePolicy = VSizePolicy; |
| myMinimumSize = minimumSize != null ? new Dimension(minimumSize) : new Dimension(-1,-1); |
| myPreferredSize = preferredSize != null ? new Dimension(preferredSize) : new Dimension(-1,-1); |
| myMaximumSize = maximumSize != null ? new Dimension(maximumSize) : new Dimension(-1,-1); |
| myIndent = 0; |
| } |
| |
| public GridConstraints( |
| final int row, |
| final int column, |
| final int rowSpan, |
| final int colSpan, |
| final int anchor, |
| final int fill, |
| final int HSizePolicy, |
| final int VSizePolicy, |
| final Dimension minimumSize, |
| final Dimension preferredSize, |
| final Dimension maximumSize, |
| final int indent){ |
| this(row, column, rowSpan, colSpan, anchor, fill, HSizePolicy, VSizePolicy, minimumSize, preferredSize, maximumSize); |
| myIndent = indent; |
| } |
| |
| public GridConstraints( |
| final int row, |
| final int column, |
| final int rowSpan, |
| final int colSpan, |
| final int anchor, |
| final int fill, |
| final int HSizePolicy, |
| final int VSizePolicy, |
| final Dimension minimumSize, |
| final Dimension preferredSize, |
| final Dimension maximumSize, |
| final int indent, |
| final boolean useParentLayout){ |
| this(row, column, rowSpan, colSpan, anchor, fill, HSizePolicy, VSizePolicy, minimumSize, preferredSize, maximumSize, indent); |
| myUseParentLayout = useParentLayout; |
| } |
| |
| /** |
| * @return deep copy of the {@link GridConstraints} |
| */ |
| public Object clone() { |
| return new GridConstraints( |
| myRow, myColumn, myRowSpan, myColSpan, myAnchor, myFill, myHSizePolicy, myVSizePolicy, |
| new Dimension(myMinimumSize), new Dimension(myPreferredSize), new Dimension(myMaximumSize), myIndent, myUseParentLayout); |
| } |
| |
| public int getColumn(){ |
| return myColumn; |
| } |
| |
| public void setColumn(final int column){ |
| if (column < 0) { |
| throw new IllegalArgumentException("wrong column: " + column); |
| } |
| myColumn = column; |
| } |
| |
| public int getRow(){ |
| return myRow; |
| } |
| |
| public void setRow(final int row){ |
| if(row<0){ |
| throw new IllegalArgumentException("wrong row: "+row); |
| } |
| myRow = row; |
| } |
| |
| public int getRowSpan(){ |
| return myRowSpan; |
| } |
| |
| public void setRowSpan(final int rowSpan){ |
| if (rowSpan <= 0) { |
| throw new IllegalArgumentException("wrong rowSpan: " + rowSpan); |
| } |
| myRowSpan = rowSpan; |
| } |
| |
| public int getColSpan(){ |
| return myColSpan; |
| } |
| |
| public void setColSpan(final int colSpan){ |
| if (colSpan <= 0) { |
| throw new IllegalArgumentException("wrong colSpan: " + colSpan); |
| } |
| myColSpan = colSpan; |
| } |
| |
| public int getHSizePolicy(){ |
| return myHSizePolicy; |
| } |
| |
| public void setHSizePolicy(final int sizePolicy){ |
| if (sizePolicy < 0 || sizePolicy > 7) { |
| throw new IllegalArgumentException("invalid sizePolicy: " + sizePolicy); |
| } |
| myHSizePolicy = sizePolicy; |
| } |
| |
| public int getVSizePolicy(){ |
| return myVSizePolicy; |
| } |
| |
| public void setVSizePolicy(final int sizePolicy){ |
| if (sizePolicy < 0 || sizePolicy > 7) { |
| throw new IllegalArgumentException("invalid sizePolicy: " + sizePolicy); |
| } |
| myVSizePolicy = sizePolicy; |
| } |
| |
| public int getAnchor(){ |
| return myAnchor; |
| } |
| |
| public void setAnchor(final int anchor){ |
| if (anchor < 0 || anchor > 15){ |
| throw new IllegalArgumentException("invalid anchor: " + anchor); |
| } |
| myAnchor = anchor; |
| } |
| |
| public int getFill(){ |
| return myFill; |
| } |
| |
| public void setFill(final int fill){ |
| if ( |
| fill != FILL_NONE && |
| fill != FILL_HORIZONTAL && |
| fill != FILL_VERTICAL && |
| fill != FILL_BOTH |
| ){ |
| throw new IllegalArgumentException("invalid fill: " + fill); |
| } |
| myFill = fill; |
| } |
| |
| public int getIndent() { |
| return myIndent; |
| } |
| |
| public void setIndent(final int indent) { |
| myIndent = indent; |
| } |
| |
| public boolean isUseParentLayout() { |
| return myUseParentLayout; |
| } |
| |
| public void setUseParentLayout(final boolean useParentLayout) { |
| myUseParentLayout = useParentLayout; |
| } |
| |
| public GridConstraints store() { |
| final GridConstraints copy = new GridConstraints(); |
| |
| copy.setRow(myRow); |
| copy.setColumn(myColumn); |
| copy.setColSpan(myColSpan); |
| copy.setRowSpan(myRowSpan); |
| copy.setVSizePolicy(myVSizePolicy); |
| copy.setHSizePolicy(myHSizePolicy); |
| copy.setFill(myFill); |
| copy.setAnchor(myAnchor); |
| copy.setIndent(myIndent); |
| copy.setUseParentLayout(myUseParentLayout); |
| |
| copy.myMinimumSize.setSize(myMinimumSize); |
| copy.myPreferredSize.setSize(myPreferredSize); |
| copy.myMaximumSize.setSize(myMaximumSize); |
| |
| return copy; |
| } |
| |
| public void restore(final GridConstraints constraints) { |
| myRow = constraints.myRow; |
| myColumn = constraints.myColumn; |
| myRowSpan = constraints.myRowSpan; |
| myColSpan = constraints.myColSpan; |
| myHSizePolicy = constraints.myHSizePolicy; |
| myVSizePolicy = constraints.myVSizePolicy; |
| myFill = constraints.myFill; |
| myAnchor = constraints.myAnchor; |
| myIndent = constraints.myIndent; |
| myUseParentLayout = constraints.myUseParentLayout; |
| |
| // Restore sizes |
| myMinimumSize.setSize(constraints.myMinimumSize); |
| myPreferredSize.setSize(constraints.myPreferredSize); |
| myMaximumSize.setSize(constraints.myMaximumSize); |
| } |
| |
| public boolean equals(Object o) { |
| if (this == o) return true; |
| if (!(o instanceof GridConstraints)) return false; |
| |
| final GridConstraints gridConstraints = (GridConstraints)o; |
| |
| if (myAnchor != gridConstraints.myAnchor) return false; |
| if (myColSpan != gridConstraints.myColSpan) return false; |
| if (myColumn != gridConstraints.myColumn) return false; |
| if (myFill != gridConstraints.myFill) return false; |
| if (myHSizePolicy != gridConstraints.myHSizePolicy) return false; |
| if (myRow != gridConstraints.myRow) return false; |
| if (myRowSpan != gridConstraints.myRowSpan) return false; |
| if (myVSizePolicy != gridConstraints.myVSizePolicy) return false; |
| if (myMaximumSize != null ? !myMaximumSize.equals(gridConstraints.myMaximumSize) : gridConstraints.myMaximumSize != null) return false; |
| if (myMinimumSize != null ? !myMinimumSize.equals(gridConstraints.myMinimumSize) : gridConstraints.myMinimumSize != null) return false; |
| if (myPreferredSize != null ? !myPreferredSize.equals(gridConstraints.myPreferredSize) : gridConstraints.myPreferredSize != null) return false; |
| if (myIndent != gridConstraints.myIndent) return false; |
| if (myUseParentLayout != gridConstraints.myUseParentLayout) return false; |
| |
| return true; |
| } |
| |
| public int hashCode() { |
| int result; |
| result = myRow; |
| result = 29 * result + myColumn; |
| result = 29 * result + myRowSpan; |
| result = 29 * result + myColSpan; |
| result = 29 * result + myVSizePolicy; |
| result = 29 * result + myHSizePolicy; |
| result = 29 * result + myFill; |
| result = 29 * result + myAnchor; |
| result = 29 * result + (myMinimumSize != null ? myMinimumSize.hashCode() : 0); |
| result = 29 * result + (myPreferredSize != null ? myPreferredSize.hashCode() : 0); |
| result = 29 * result + (myMaximumSize != null ? myMaximumSize.hashCode() : 0); |
| result = 29 * result + myIndent; |
| result = 29 * result + (myUseParentLayout ? 1 : 0); |
| return result; |
| } |
| |
| public int getCell(final boolean isRow){ |
| return isRow ? getRow() : getColumn(); |
| } |
| |
| public void setCell(final boolean isRow, final int value) { |
| if (isRow) { |
| setRow(value); |
| } |
| else { |
| setColumn(value); |
| } |
| } |
| |
| public int getSpan(final boolean isRow){ |
| return isRow ? getRowSpan() : getColSpan(); |
| } |
| |
| public void setSpan(final boolean isRow, final int value) { |
| if (isRow) { |
| setRowSpan(value); |
| } |
| else { |
| setColSpan(value); |
| } |
| } |
| |
| public boolean contains(final boolean isRow, final int cell) { |
| if (isRow) { |
| return cell >= myRow && cell < myRow + myRowSpan; |
| } |
| return cell >= myColumn && cell < myColumn + myColSpan; |
| } |
| |
| public String toString() { |
| //noinspection HardCodedStringLiteral |
| return "GridConstraints (row=" + myRow + ", col=" + myColumn + ", rowspan=" + myRowSpan + ", colspan=" + myColSpan + ")"; |
| } |
| } |