| /* |
| * 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.compiler; |
| |
| import com.intellij.uiDesigner.core.GridConstraints; |
| import com.intellij.uiDesigner.core.GridLayoutManager; |
| import com.intellij.uiDesigner.core.AbstractLayout; |
| import com.intellij.uiDesigner.core.Util; |
| import com.intellij.uiDesigner.lw.*; |
| |
| import javax.swing.*; |
| import java.awt.*; |
| import java.util.ArrayList; |
| import java.util.Iterator; |
| import java.util.Map; |
| |
| /** |
| * @author yole |
| */ |
| public class GridBagConverter { |
| private final Insets myInsets; |
| private int myHGap; |
| private int myVGap; |
| private boolean mySameSizeHorz; |
| private boolean mySameSizeVert; |
| private final ArrayList myComponents = new ArrayList(); |
| private final ArrayList myConstraints = new ArrayList(); |
| private int myLastRow = -1; |
| private int myLastCol = -1; |
| |
| public GridBagConverter() { |
| myInsets = new Insets(0, 0, 0, 0); |
| } |
| |
| public GridBagConverter(final Insets insets, final int hgap, final int vgap, final boolean sameSizeHorz, final boolean sameSizeVert) { |
| myInsets = insets; |
| myHGap = hgap; |
| myVGap = vgap; |
| mySameSizeHorz = sameSizeHorz; |
| mySameSizeVert = sameSizeVert; |
| } |
| |
| public void addComponent(final JComponent component, final GridConstraints constraints) { |
| myComponents.add(component); |
| myConstraints.add(constraints); |
| } |
| |
| public static void prepareConstraints(final LwContainer container, final Map idToConstraintsMap) { |
| GridLayoutManager gridLayout = (GridLayoutManager) container.getLayout(); |
| GridBagConverter converter = new GridBagConverter(gridLayout.getMargin(), |
| getGap(container, true), |
| getGap(container, false), |
| gridLayout.isSameSizeHorizontally(), |
| gridLayout.isSameSizeVertically()); |
| for(int i=0; i<container.getComponentCount(); i++) { |
| final LwComponent component = (LwComponent)container.getComponent(i); |
| if (component instanceof LwHSpacer || component instanceof LwVSpacer) { |
| GridConstraints constraints = component.getConstraints().store(); |
| constraints.setHSizePolicy(constraints.getHSizePolicy() & ~GridConstraints.SIZEPOLICY_WANT_GROW); |
| constraints.setVSizePolicy(constraints.getVSizePolicy() & ~GridConstraints.SIZEPOLICY_WANT_GROW); |
| converter.addComponent(null, constraints); |
| } |
| else { |
| converter.addComponent(null, component.getConstraints()); |
| } |
| } |
| Result[] results = converter.convert(); |
| int componentIndex = 0; |
| for(int i=0; i<results.length; i++) { |
| if (!results [i].isFillerPanel) { |
| final LwComponent component = (LwComponent)container.getComponent(componentIndex++); |
| idToConstraintsMap.put(component.getId(), results [i]); |
| } |
| // else generateFillerPanel(generator, componentLocal, results [i]); |
| } |
| } |
| |
| private static int getGap(LwContainer container, final boolean horizontal) { |
| while(container != null) { |
| final LayoutManager layout = container.getLayout(); |
| if (layout instanceof AbstractLayout) { |
| AbstractLayout aLayout = (AbstractLayout) layout; |
| final int gap = horizontal ? aLayout.getHGap() : aLayout.getVGap(); |
| if (gap >= 0) { |
| return gap; |
| } |
| } |
| container = container.getParent(); |
| } |
| return horizontal ? AbstractLayout.DEFAULT_HGAP : AbstractLayout.DEFAULT_VGAP; |
| } |
| |
| public static class Result { |
| public JComponent component; |
| public boolean isFillerPanel; |
| public GridBagConstraints constraints; |
| public Dimension preferredSize; |
| public Dimension minimumSize; |
| public Dimension maximumSize; |
| |
| public Result(final JComponent component) { |
| this.component = component; |
| constraints = new GridBagConstraints(); |
| } |
| } |
| |
| public Result[] convert() { |
| ArrayList results = new ArrayList(); |
| for(int i=0; i<myComponents.size(); i++) { |
| results.add(convert((JComponent) myComponents.get(i), (GridConstraints) myConstraints.get(i))); |
| } |
| //addFillerPanels(results); |
| final Result[] resultArray = (Result[])results.toArray(new Result[results.size()]); |
| if (myHGap > 0 || myVGap > 0) { |
| applyGaps(resultArray); |
| } |
| if (mySameSizeHorz) { |
| makeSameSizes(resultArray, true); |
| } |
| if (mySameSizeVert) { |
| makeSameSizes(resultArray, false); |
| } |
| |
| return resultArray; |
| } |
| |
| private void applyGaps(final Result[] resultArray) { |
| int leftGap = myHGap/2; |
| int rightGap = myHGap - myHGap/2; |
| int topGap = myVGap / 2; |
| int bottomGap = myVGap - myVGap/2; |
| for(int i=0; i<resultArray.length; i++) { |
| Result result = resultArray [i]; |
| if (result.constraints.gridx > 0) { |
| result.constraints.insets.left += leftGap; |
| } |
| if (result.constraints.gridx + result.constraints.gridwidth-1 < myLastCol) { |
| result.constraints.insets.right += rightGap; |
| } |
| if (result.constraints.gridy > 0) { |
| result.constraints.insets.top += topGap; |
| } |
| if (result.constraints.gridy + result.constraints.gridheight-1 < myLastRow) { |
| result.constraints.insets.bottom += bottomGap; |
| } |
| } |
| } |
| |
| private static void makeSameSizes(final Result[] resultArray, boolean horizontal) { |
| int minimum = -1; |
| int preferred = -1; |
| for(int i=0; i<resultArray.length; i++) { |
| Result result = resultArray [i]; |
| Dimension minSize = result.minimumSize != null || result.component == null |
| ? result.minimumSize |
| : result.component.getMinimumSize(); |
| Dimension prefSize = result.preferredSize != null || result.component == null |
| ? result.preferredSize |
| : result.component.getPreferredSize(); |
| if (minSize != null) { |
| minimum = Math.max(minimum, horizontal ? minSize.width : minSize.height); |
| } |
| if (prefSize != null) { |
| preferred = Math.max(preferred, horizontal ? prefSize.width : prefSize.height); |
| } |
| } |
| |
| if (minimum >= 0 || preferred >= 0) { |
| for(int i=0; i<resultArray.length; i++) { |
| Result result = resultArray [i]; |
| |
| if ((result.minimumSize != null || result.component != null) && minimum >= 0) { |
| if (result.minimumSize == null) { |
| result.minimumSize = result.component.getMinimumSize(); |
| } |
| if (horizontal) { |
| result.minimumSize.width = minimum; |
| } |
| else { |
| result.minimumSize.height = minimum; |
| } |
| } |
| |
| if ((result.preferredSize != null || result.component != null) && preferred >= 0) { |
| if (result.preferredSize == null) { |
| result.preferredSize = result.component.getPreferredSize(); |
| } |
| if (horizontal) { |
| result.preferredSize.width = preferred; |
| } |
| else { |
| result.preferredSize.height = preferred; |
| } |
| } |
| } |
| } |
| } |
| |
| private Result convert(final JComponent component, final GridConstraints constraints) { |
| final Result result = new Result(component); |
| |
| int endRow = constraints.getRow() + constraints.getRowSpan()-1; |
| myLastRow = Math.max(myLastRow, endRow); |
| int endCol = constraints.getColumn() + constraints.getColSpan()-1; |
| myLastCol = Math.max(myLastCol, endCol); |
| |
| int indent = Util.DEFAULT_INDENT * constraints.getIndent(); |
| |
| constraintsToGridBag(constraints, result.constraints); |
| result.constraints.weightx = getWeight(constraints, true); |
| result.constraints.weighty = getWeight(constraints, false); |
| result.constraints.insets = new Insets(myInsets.top, myInsets.left + indent, myInsets.bottom, myInsets.right); |
| |
| Dimension minSize = constraints.myMinimumSize; |
| if (component != null && minSize.width <= 0 && minSize.height <= 0) { |
| minSize = component.getMinimumSize(); |
| } |
| |
| if ((constraints.getHSizePolicy() & GridConstraints.SIZEPOLICY_CAN_SHRINK) == 0) { |
| minSize.width = constraints.myPreferredSize.width > 0 || component == null |
| ? constraints.myPreferredSize.width |
| : component.getPreferredSize().width; |
| } |
| if ((constraints.getVSizePolicy() & GridConstraints.SIZEPOLICY_CAN_SHRINK) == 0) { |
| minSize.height = constraints.myPreferredSize.height > 0 || component == null |
| ? constraints.myPreferredSize.height |
| : component.getPreferredSize().height; |
| } |
| |
| if (minSize.width != -1 || minSize.height != -1) { |
| result.minimumSize = minSize; |
| } |
| |
| if (constraints.myPreferredSize.width > 0 && constraints.myPreferredSize.height > 0) { |
| result.preferredSize = constraints.myPreferredSize; |
| } |
| if (constraints.myMaximumSize.width > 0 && constraints.myMaximumSize.height > 0) { |
| result.maximumSize = constraints.myMaximumSize; |
| } |
| |
| return result; |
| } |
| |
| public static GridBagConstraints getGridBagConstraints(IComponent component) { |
| final GridBagConstraints gbc; |
| if (component.getCustomLayoutConstraints() instanceof GridBagConstraints) { |
| gbc = (GridBagConstraints) component.getCustomLayoutConstraints(); |
| } |
| else { |
| gbc = new GridBagConstraints(); |
| } |
| constraintsToGridBag(component.getConstraints(), gbc); |
| return gbc; |
| } |
| |
| public static void constraintsToGridBag(final GridConstraints constraints, final GridBagConstraints result) { |
| result.gridx = constraints.getColumn(); |
| result.gridy = constraints.getRow(); |
| result.gridwidth = constraints.getColSpan(); |
| result.gridheight = constraints.getRowSpan(); |
| switch(constraints.getFill()) { |
| case GridConstraints.FILL_HORIZONTAL: result.fill = GridBagConstraints.HORIZONTAL; break; |
| case GridConstraints.FILL_VERTICAL: result.fill = GridBagConstraints.VERTICAL; break; |
| case GridConstraints.FILL_BOTH: result.fill = GridBagConstraints.BOTH; break; |
| default: result.fill = GridBagConstraints.NONE; break; |
| } |
| switch(constraints.getAnchor()) { |
| case GridConstraints.ANCHOR_NORTHWEST: result.anchor = GridBagConstraints.NORTHWEST; break; |
| case GridConstraints.ANCHOR_NORTH: result.anchor = GridBagConstraints.NORTH; break; |
| case GridConstraints.ANCHOR_NORTHEAST: result.anchor = GridBagConstraints.NORTHEAST; break; |
| case GridConstraints.ANCHOR_EAST: result.anchor = GridBagConstraints.EAST; break; |
| case GridConstraints.ANCHOR_SOUTHEAST: result.anchor = GridBagConstraints.SOUTHEAST; break; |
| case GridConstraints.ANCHOR_SOUTH: result.anchor = GridBagConstraints.SOUTH; break; |
| case GridConstraints.ANCHOR_SOUTHWEST: result.anchor = GridBagConstraints.SOUTHWEST; break; |
| case GridConstraints.ANCHOR_WEST: result.anchor = GridBagConstraints.WEST; break; |
| } |
| } |
| |
| private double getWeight(final GridConstraints constraints, final boolean horizontal) { |
| int policy = horizontal ? constraints.getHSizePolicy() : constraints.getVSizePolicy(); |
| if ((policy & GridConstraints.SIZEPOLICY_WANT_GROW) != 0) { |
| return 1.0; |
| } |
| boolean canGrow = ((policy & GridConstraints.SIZEPOLICY_CAN_GROW) != 0); |
| for (Iterator iterator = myConstraints.iterator(); iterator.hasNext();) { |
| GridConstraints otherConstraints = (GridConstraints)iterator.next(); |
| |
| if (!constraintsIntersect(horizontal, constraints, otherConstraints)) { |
| int otherPolicy = horizontal ? otherConstraints.getHSizePolicy() : otherConstraints.getVSizePolicy(); |
| if ((otherPolicy & GridConstraints.SIZEPOLICY_WANT_GROW) != 0) { |
| return 0.0; |
| } |
| if (!canGrow && ((otherPolicy & GridConstraints.SIZEPOLICY_CAN_GROW) != 0)) { |
| return 0.0; |
| } |
| } |
| } |
| return 1.0; |
| } |
| |
| private boolean constraintsIntersect(final boolean horizontal, |
| final GridConstraints constraints, |
| final GridConstraints otherConstraints) { |
| int start = constraints.getCell(!horizontal); |
| int end = start + constraints.getSpan(!horizontal) - 1; |
| int otherStart = otherConstraints.getCell(!horizontal); |
| int otherEnd = otherStart + otherConstraints.getSpan(!horizontal) - 1; |
| return start <= otherEnd && otherStart <= end; |
| } |
| } |
