| /* |
| * 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.ui.MappingListCellRenderer; |
| import com.intellij.ui.IdeBorderFactory; |
| import com.intellij.uiDesigner.UIDesignerBundle; |
| import com.intellij.util.containers.ContainerUtil; |
| import com.jgoodies.forms.layout.*; |
| import org.jetbrains.annotations.NonNls; |
| |
| import javax.swing.*; |
| import javax.swing.event.ChangeEvent; |
| import javax.swing.event.ChangeListener; |
| import java.awt.event.ActionEvent; |
| import java.awt.event.ActionListener; |
| import java.awt.event.ItemEvent; |
| import java.awt.event.ItemListener; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| |
| /** |
| * @author yole |
| */ |
| public class FormLayoutColumnProperties implements CustomPropertiesPanel { |
| private static final Map<Object, String> UNITS_MAP; |
| |
| static { |
| UNITS_MAP = new HashMap<Object, String>(); |
| UNITS_MAP.put("px", UIDesignerBundle.message("unit.pixels")); |
| UNITS_MAP.put("dlu", UIDesignerBundle.message("unit.dialog.units")); |
| UNITS_MAP.put("pt", UIDesignerBundle.message("unit.points")); |
| UNITS_MAP.put("in", UIDesignerBundle.message("unit.inches")); |
| UNITS_MAP.put("cm", UIDesignerBundle.message("unit.centimeters")); |
| UNITS_MAP.put("mm", UIDesignerBundle.message("unit.millimeters")); |
| } |
| |
| private JPanel myRootPanel; |
| private JRadioButton myDefaultRadioButton; |
| private JRadioButton myPreferredRadioButton; |
| private JRadioButton myMinimumRadioButton; |
| private JRadioButton myConstantRadioButton; |
| private JComboBox myConstantSizeUnitsCombo; |
| private JCheckBox myMinimumCheckBox; |
| private JCheckBox myMaximumCheckBox; |
| private JSpinner myMaxSizeSpinner; |
| private JComboBox myMinSizeUnitsCombo; |
| private JComboBox myMaxSizeUnitsCombo; |
| private JSpinner myConstantSizeSpinner; |
| private JSpinner myMinSizeSpinner; |
| private JCheckBox myGrowCheckBox; |
| private JSpinner myGrowSpinner; |
| private JRadioButton myLeftRadioButton; |
| private JRadioButton myCenterRadioButton; |
| private JRadioButton myRightRadioButton; |
| private JRadioButton myFillRadioButton; |
| private JLabel myTitleLabel; |
| private JPanel myAlignmentPanel; |
| private JPanel mySizePanel; |
| private FormLayout myLayout; |
| private int myIndex; |
| private boolean myIsRow; |
| private final List<ChangeListener> myListeners = ContainerUtil.createLockFreeCopyOnWriteList(); |
| private boolean myShowing = false; |
| private boolean mySaving = false; |
| |
| public FormLayoutColumnProperties() { |
| @NonNls String[] unitNames = new String[]{"px", "dlu", "pt", "in", "cm", "mm"}; |
| myConstantSizeUnitsCombo.setModel(new DefaultComboBoxModel(unitNames)); |
| myMinSizeUnitsCombo.setModel(new DefaultComboBoxModel(unitNames)); |
| myMaxSizeUnitsCombo.setModel(new DefaultComboBoxModel(unitNames)); |
| myConstantSizeUnitsCombo.setRenderer(new MappingListCellRenderer(myConstantSizeUnitsCombo.getRenderer(), UNITS_MAP)); |
| myMinSizeUnitsCombo.setRenderer(new MappingListCellRenderer(myMinSizeUnitsCombo.getRenderer(), UNITS_MAP)); |
| myMaxSizeUnitsCombo.setRenderer(new MappingListCellRenderer(myMaxSizeUnitsCombo.getRenderer(), UNITS_MAP)); |
| final MyRadioListener listener = new MyRadioListener(); |
| myDefaultRadioButton.addActionListener(listener); |
| myPreferredRadioButton.addActionListener(listener); |
| myMinimumRadioButton.addActionListener(listener); |
| myConstantRadioButton.addActionListener(listener); |
| |
| myMinimumCheckBox.addChangeListener(new MyCheckboxListener(myMinimumCheckBox, myMinSizeUnitsCombo, myMinSizeSpinner)); |
| myMaximumCheckBox.addChangeListener(new MyCheckboxListener(myMaximumCheckBox, myMaxSizeUnitsCombo, myMaxSizeSpinner)); |
| myConstantRadioButton.addChangeListener(new MyCheckboxListener(myConstantRadioButton, myConstantSizeUnitsCombo, myConstantSizeSpinner)); |
| |
| updateOnRadioChange(); |
| |
| myGrowCheckBox.addChangeListener(new ChangeListener() { |
| public void stateChanged(ChangeEvent e) { |
| myGrowSpinner.setEnabled(myGrowCheckBox.isSelected()); |
| updateSpec(); |
| } |
| }); |
| final MyChangeListener changeListener = new MyChangeListener(); |
| myGrowSpinner.setModel(new SpinnerNumberModel(1.0, 0.0, 10.0, 0.1)); |
| myGrowSpinner.addChangeListener(changeListener); |
| myMinSizeSpinner.addChangeListener(changeListener); |
| myMaxSizeSpinner.addChangeListener(changeListener); |
| myConstantSizeSpinner.addChangeListener(changeListener); |
| myLeftRadioButton.addChangeListener(changeListener); |
| myCenterRadioButton.addChangeListener(changeListener); |
| myRightRadioButton.addChangeListener(changeListener); |
| myFillRadioButton.addChangeListener(changeListener); |
| |
| final MyItemListener itemListener = new MyItemListener(); |
| myMinSizeUnitsCombo.addItemListener(itemListener); |
| myMaxSizeUnitsCombo.addItemListener(itemListener); |
| myConstantSizeUnitsCombo.addItemListener(itemListener); |
| } |
| |
| public JPanel getComponent() { |
| return myRootPanel; |
| } |
| |
| public void addChangeListener(ChangeListener listener) { |
| myListeners.add(listener); |
| } |
| |
| public void removeChangeListener(ChangeListener listener) { |
| myListeners.remove(listener); |
| } |
| |
| public void showProperties(final RadContainer container, final boolean row, final int[] selectedIndices) { |
| if (mySaving) return; |
| if (selectedIndices.length == 1) { |
| showControls(true); |
| myShowing = true; |
| try { |
| myLayout = (FormLayout)container.getLayout(); |
| myIndex = selectedIndices[0] + 1; |
| myIsRow = row; |
| |
| myTitleLabel.setText(myIsRow |
| ? UIDesignerBundle.message("title.row.properties", myIndex) |
| : UIDesignerBundle.message("title.column.properties", myIndex)); |
| myLeftRadioButton.setText(row ? UIDesignerBundle.message("alignment.top") : UIDesignerBundle.message("alignment.left")); |
| myRightRadioButton.setText(row ? UIDesignerBundle.message("alignment.bottom") : UIDesignerBundle.message("alignment.right")); |
| mySizePanel.setBorder(IdeBorderFactory.createTitledBorder(myIsRow |
| ? UIDesignerBundle.message("title.height") |
| : UIDesignerBundle.message("title.width"), true)); |
| |
| FormSpec formSpec = row ? myLayout.getRowSpec(myIndex) : myLayout.getColumnSpec(myIndex); |
| showAlignment(formSpec.getDefaultAlignment()); |
| showSize(formSpec.getSize()); |
| if (formSpec.getResizeWeight() < 0.01) { |
| myGrowCheckBox.setSelected(false); |
| myGrowSpinner.setValue(1.0); |
| } |
| else { |
| myGrowCheckBox.setSelected(true); |
| myGrowSpinner.setValue(formSpec.getResizeWeight()); |
| } |
| } |
| finally { |
| myShowing = false; |
| } |
| } |
| else { |
| showControls(false); |
| if (selectedIndices.length > 1) { |
| myTitleLabel.setText(myIsRow |
| ? UIDesignerBundle.message("title.multiple.rows.selected") |
| : UIDesignerBundle.message("title.multiple.columns.selected")); |
| } |
| else { |
| myTitleLabel.setText(myIsRow |
| ? UIDesignerBundle.message("title.no.rows.selected") |
| : UIDesignerBundle.message("title.no.columns.selected")); |
| } |
| } |
| } |
| |
| private void showControls(final boolean visible) { |
| mySizePanel.setVisible(visible); |
| myAlignmentPanel.setVisible(visible); |
| myGrowCheckBox.setVisible(visible); |
| myGrowSpinner.setVisible(visible); |
| } |
| |
| private void showAlignment(final FormSpec.DefaultAlignment defaultAlignment) { |
| if (defaultAlignment.equals(RowSpec.TOP) || defaultAlignment.equals(ColumnSpec.LEFT)) { |
| myLeftRadioButton.setSelected(true); |
| } |
| else if (defaultAlignment.equals(RowSpec.CENTER)) { |
| myCenterRadioButton.setSelected(true); |
| } |
| else if (defaultAlignment.equals(RowSpec.BOTTOM) || defaultAlignment.equals(ColumnSpec.RIGHT)) { |
| myRightRadioButton.setSelected(true); |
| } |
| else { |
| myFillRadioButton.setSelected(true); |
| } |
| } |
| |
| private void showSize(Size size) { |
| Size minimumSize = null; |
| Size maximumSize = null; |
| if (size instanceof BoundedSize) { |
| BoundedSize boundedSize = (BoundedSize)size; |
| minimumSize = boundedSize.getLowerBound(); |
| maximumSize = boundedSize.getUpperBound(); |
| size = boundedSize.getBasis(); |
| } |
| |
| if (size instanceof ConstantSize) { |
| myConstantRadioButton.setSelected(true); |
| myMinimumCheckBox.setEnabled(false); |
| myMinimumCheckBox.setSelected(false); |
| myMaximumCheckBox.setEnabled(false); |
| myMaximumCheckBox.setSelected(false); |
| showConstantSize((ConstantSize)size, myConstantSizeUnitsCombo, myConstantSizeSpinner); |
| } |
| else { |
| @NonNls String s = size.toString(); |
| if (s.startsWith("m")) { |
| myMinimumRadioButton.setSelected(true); |
| } |
| else if (s.startsWith("p")) { |
| myPreferredRadioButton.setSelected(true); |
| } |
| else { |
| myDefaultRadioButton.setSelected(true); |
| } |
| |
| myMinimumCheckBox.setEnabled(true); |
| myMaximumCheckBox.setEnabled(true); |
| if (minimumSize instanceof ConstantSize) { |
| myMinimumCheckBox.setSelected(true); |
| myMaximumCheckBox.setEnabled(false); // TODO: remove this code when IDEADEV-9678 is implemented |
| showConstantSize((ConstantSize)minimumSize, myMinSizeUnitsCombo, myMinSizeSpinner); |
| } |
| else { |
| myMinimumCheckBox.setSelected(false); |
| } |
| if (maximumSize instanceof ConstantSize) { |
| myMaximumCheckBox.setSelected(true); |
| myMinimumCheckBox.setEnabled(false); // TODO: remove this code when IDEADEV-9678 is implemented |
| showConstantSize((ConstantSize)maximumSize, myMaxSizeUnitsCombo, myMaxSizeSpinner); |
| } |
| else { |
| myMaximumCheckBox.setSelected(false); |
| } |
| } |
| } |
| |
| private static void showConstantSize(final ConstantSize size, final JComboBox unitsCombo, final JSpinner spinner) { |
| double value = size.getValue(); |
| ConstantSize.Unit unit = size.getUnit(); |
| if (unit.equals(ConstantSize.DIALOG_UNITS_X) || unit.equals(ConstantSize.DIALOG_UNITS_Y)) { |
| unitsCombo.setSelectedItem("dlu"); |
| } |
| else { |
| unitsCombo.setSelectedItem(unit.abbreviation()); |
| } |
| |
| spinner.setModel(new SpinnerNumberModel(0.0, 0.0, Double.MAX_VALUE, 1.0)); |
| spinner.setValue(value); |
| } |
| |
| private void updateOnRadioChange() { |
| final boolean canSetBounds = !myConstantRadioButton.isSelected(); |
| myMinimumCheckBox.setEnabled(canSetBounds); |
| myMaximumCheckBox.setEnabled(canSetBounds); |
| |
| // TODO: remove this code when IDEADEV-9678 is implemented |
| if (myMinimumCheckBox.isSelected()) { |
| myMaximumCheckBox.setEnabled(false); |
| myMaximumCheckBox.setSelected(false); |
| } |
| else if (myMaximumCheckBox.isSelected()) { |
| myMinimumCheckBox.setEnabled(false); |
| } |
| |
| if (!canSetBounds) { |
| myMinimumCheckBox.setSelected(false); |
| myMaximumCheckBox.setSelected(false); |
| } |
| updateSpec(); |
| } |
| |
| private void updateSpec() { |
| if (myLayout == null || myShowing) return; |
| mySaving = true; |
| try { |
| Size size = getSelectedSize(); |
| |
| final SpinnerNumberModel model = (SpinnerNumberModel)myGrowSpinner.getModel(); |
| double resizeWeight = myGrowCheckBox.isSelected() ? model.getNumber().doubleValue() : 0.0; |
| FormSpec.DefaultAlignment alignment = getSelectedAlignment(); |
| |
| if (myIsRow) { |
| myLayout.setRowSpec(myIndex, new RowSpec(alignment, size, resizeWeight)); |
| } |
| else { |
| myLayout.setColumnSpec(myIndex, new ColumnSpec(alignment, size, resizeWeight)); |
| } |
| for (ChangeListener listener : myListeners) { |
| listener.stateChanged(new ChangeEvent(this)); |
| } |
| } |
| finally { |
| mySaving = false; |
| } |
| } |
| |
| private Size getSelectedSize() { |
| Size size; |
| if (myDefaultRadioButton.isSelected()) { |
| size = Sizes.DEFAULT; |
| } |
| else if (myPreferredRadioButton.isSelected()) { |
| size = Sizes.PREFERRED; |
| } |
| else if (myMinimumRadioButton.isSelected()) { |
| size = Sizes.MINIMUM; |
| } |
| else { |
| size = getConstantSize(myConstantSizeUnitsCombo, myConstantSizeSpinner); |
| } |
| |
| if (myMinimumCheckBox.isSelected() || myMaximumCheckBox.isSelected()) { |
| Size minSize = null; |
| Size maxSize = null; |
| if (myMinimumCheckBox.isSelected()) { |
| minSize = getConstantSize(myMinSizeUnitsCombo, myMinSizeSpinner); |
| } |
| if (myMaximumCheckBox.isSelected()) { |
| maxSize = getConstantSize(myMaxSizeUnitsCombo, myMaxSizeSpinner); |
| } |
| size = Sizes.bounded(size, minSize, maxSize); |
| } |
| return size; |
| } |
| |
| private FormSpec.DefaultAlignment getSelectedAlignment() { |
| if (myLeftRadioButton.isSelected()) { |
| return myIsRow ? RowSpec.TOP : ColumnSpec.LEFT; |
| } |
| if (myCenterRadioButton.isSelected()) { |
| return RowSpec.CENTER; |
| } |
| if (myRightRadioButton.isSelected()) { |
| return myIsRow ? RowSpec.BOTTOM : ColumnSpec.RIGHT; |
| } |
| return RowSpec.FILL; |
| } |
| |
| private ConstantSize getConstantSize(final JComboBox unitsCombo, final JSpinner spinner) { |
| return Sizes.constant(spinner.getValue().toString() + unitsCombo.getSelectedItem().toString(), myIsRow); |
| } |
| |
| private class MyRadioListener implements ActionListener { |
| public void actionPerformed(ActionEvent e) { |
| updateOnRadioChange(); |
| } |
| } |
| |
| private class MyCheckboxListener implements ChangeListener { |
| private boolean myWasSelected; |
| private final AbstractButton myButton; |
| private final JComboBox myUnitsCombo; |
| private final JSpinner mySpinner; |
| |
| public MyCheckboxListener(final AbstractButton button, final JComboBox unitsCombo, final JSpinner spinner) { |
| myButton = button; |
| myUnitsCombo = unitsCombo; |
| mySpinner = spinner; |
| myWasSelected = myButton.isSelected(); |
| } |
| |
| public void stateChanged(ChangeEvent e) { |
| if (myWasSelected != myButton.isSelected()) { |
| myWasSelected = myButton.isSelected(); |
| myUnitsCombo.setEnabled(myButton.isSelected()); |
| mySpinner.setEnabled(myButton.isSelected()); |
| if (myButton.isSelected() && mySpinner.getValue().equals(new Integer(0))) { |
| mySpinner.setValue(100); |
| } |
| updateOnRadioChange(); |
| } |
| } |
| } |
| |
| private class MyChangeListener implements ChangeListener { |
| public void stateChanged(ChangeEvent e) { |
| updateSpec(); |
| } |
| } |
| |
| private class MyItemListener implements ItemListener { |
| public void itemStateChanged(ItemEvent e) { |
| updateSpec(); |
| } |
| } |
| } |
