/* $Id: PerspectiveConfigurator.java 17843 2010-01-12 19:23:29Z linus $
*****************************************************************************
* Copyright (c) 2009 Contributors - see below
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* tfmorris
*****************************************************************************
*
* Some portions of this file was previously release using the BSD License:
*/
// Copyright (c) 1996-2007 The Regents of the University of California. All
// Rights Reserved. Permission to use, copy, modify, and distribute this
// software and its documentation without fee, and without a written
// agreement is hereby granted, provided that the above copyright notice
// and this paragraph appear in all copies. This software program and
// documentation are copyrighted by The Regents of the University of
// California. The software program and documentation are supplied "AS
// IS", without any accompanying services from The Regents. The Regents
// does not warrant that the operation of the program will be
// uninterrupted or error-free. The end-user understands that the program
// was developed for research purposes and is advised not to rely
// exclusively on the program for any reason. IN NO EVENT SHALL THE
// UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT,
// SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST PROFITS,
// ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF
// THE UNIVERSITY OF CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF
// SUCH DAMAGE. THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY
// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE
// PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND THE UNIVERSITY OF
// CALIFORNIA HAS NO OBLIGATIONS TO PROVIDE MAINTENANCE, SUPPORT,
// UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
package org.argouml.ui.explorer;
import java.awt.BorderLayout;
import java.awt.FlowLayout;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.GridLayout;
import java.awt.Insets;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import javax.swing.BorderFactory;
import javax.swing.BoxLayout;
import javax.swing.DefaultListModel;
import javax.swing.JButton;
import javax.swing.JLabel;
import javax.swing.JList;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JSplitPane;
import javax.swing.JTextField;
import javax.swing.ListSelectionModel;
import javax.swing.event.DocumentEvent;
import javax.swing.event.DocumentListener;
import javax.swing.event.ListSelectionEvent;
import javax.swing.event.ListSelectionListener;
import org.apache.log4j.Logger;
import org.argouml.i18n.Translator;
import org.argouml.swingext.SpacerPanel;
import org.argouml.ui.explorer.rules.PerspectiveRule;
import org.argouml.util.ArgoDialog;
/**
* The "Configure Perspectives" dialog.<p>
*
* This class implements the following features:<p>
* <ul>
* <li>- saving perspectives to the user profile.
* <li>- adding new perspectives.
* <li>- deleting perspectives.
* <li>- renaming perspectives.
* <li>- duplicating existing perspectives.
* <li>- reordering perspectives.
* <li>- selecting any number and combination of rules for a perspective.
* </ul><p>
*
* This dialog behaves almost exactly as described in
* http://java.sun.com/products/jlf/at/book/Idioms6.html#57371
*
* @since 21 December 2003.
* @author alexb
*/
public class PerspectiveConfigurator extends ArgoDialog {
/**
* Logger.
*/
private static final Logger LOG =
Logger.getLogger(PerspectiveConfigurator.class);
/**
* Insets in pixels.
*/
private static final int INSET_PX = 3;
////////////////////////////////////////////////////////////////
// instance variables
private JPanel configPanelNorth;
private JPanel configPanelSouth;
private JSplitPane splitPane;
private JTextField renameTextField;
private JButton newPerspectiveButton;
private JButton removePerspectiveButton;
private JButton duplicatePerspectiveButton;
private JButton moveUpButton, moveDownButton;
private JButton addRuleButton;
private JButton removeRuleButton;
private JButton resetToDefaultButton;
private JList perspectiveList;
private JList perspectiveRulesList;
private JList ruleLibraryList;
private DefaultListModel perspectiveListModel; // at the top
private DefaultListModel perspectiveRulesListModel; // right bottom
private DefaultListModel ruleLibraryListModel; // left bottom
private JLabel persLabel;
private JLabel ruleLibLabel;
private JLabel rulesLabel;
/**
* Creates a new instance of PerspectiveDesignerDialog.
*/
public PerspectiveConfigurator() {
super(Translator.localize("dialog.title.configure-perspectives"),
ArgoDialog.OK_CANCEL_OPTION,
true); // the dialog is modal
configPanelNorth = new JPanel();
configPanelSouth = new JPanel();
makeLists();
makeButtons();
makeLayout();
updateRuleLabel();
makeListeners();
loadPerspectives();
loadLibrary();
//sortJListModel(ruleLibraryList);
splitPane =
new JSplitPane(JSplitPane.VERTICAL_SPLIT,
configPanelNorth, configPanelSouth);
splitPane.setContinuousLayout(true);
setContent(splitPane);
}
/**
* Make the lists on the dialog box and fill them.
*/
private void makeLists() {
renameTextField = new JTextField();
perspectiveListModel = new DefaultListModel();
perspectiveList = new JList(perspectiveListModel);
perspectiveRulesListModel = new DefaultListModel();
perspectiveRulesList = new JList(perspectiveRulesListModel);
ruleLibraryListModel = new DefaultListModel();
ruleLibraryList = new JList(ruleLibraryListModel);
perspectiveList.setBorder(BorderFactory.createEmptyBorder(
INSET_PX, INSET_PX, INSET_PX, INSET_PX));
perspectiveRulesList.setBorder(BorderFactory.createEmptyBorder(
INSET_PX, INSET_PX, INSET_PX, INSET_PX));
ruleLibraryList.setBorder(BorderFactory.createEmptyBorder(
INSET_PX, INSET_PX, INSET_PX, INSET_PX));
perspectiveList.setSelectionMode(
ListSelectionModel.SINGLE_SELECTION);
perspectiveRulesList.setSelectionMode(
ListSelectionModel.SINGLE_SELECTION);
ruleLibraryList.setSelectionMode(
ListSelectionModel.SINGLE_SELECTION);
}
/**
* Make the buttons on the dialog box with localized strings and mnemonics.
*/
private void makeButtons() {
newPerspectiveButton = new JButton();
nameButton(newPerspectiveButton, "button.new");
newPerspectiveButton.setToolTipText(
Translator.localize("button.new.tooltip"));
removePerspectiveButton = new JButton();
nameButton(removePerspectiveButton, "button.remove");
removePerspectiveButton.setToolTipText(
Translator.localize("button.remove.tooltip"));
duplicatePerspectiveButton = new JButton();
nameButton(duplicatePerspectiveButton, "button.duplicate");
duplicatePerspectiveButton.setToolTipText(
Translator.localize("button.duplicate.tooltip"));
moveUpButton = new JButton();
nameButton(moveUpButton, "button.move-up");
moveUpButton.setToolTipText(
Translator.localize("button.move-up.tooltip"));
moveDownButton = new JButton();
nameButton(moveDownButton, "button.move-down");
moveDownButton.setToolTipText(
Translator.localize("button.move-down.tooltip"));
addRuleButton = new JButton(">>");
addRuleButton.setToolTipText(Translator.localize("button.add-rule"));
removeRuleButton = new JButton("<<");
removeRuleButton.setToolTipText(Translator.localize(
"button.remove-rule"));
resetToDefaultButton = new JButton();
nameButton(resetToDefaultButton, "button.restore-defaults");
resetToDefaultButton.setToolTipText(
Translator.localize("button.restore-defaults.tooltip"));
//disable the buttons for now, since no selection has been made yet
removePerspectiveButton.setEnabled(false);
duplicatePerspectiveButton.setEnabled(false);
moveUpButton.setEnabled(false);
moveDownButton.setEnabled(false);
addRuleButton.setEnabled(false);
removeRuleButton.setEnabled(false);
renameTextField.setEnabled(false);
}
/**
* Make the layout for the dialog box.
*/
private void makeLayout() {
GridBagLayout gb = new GridBagLayout();
configPanelNorth.setLayout(gb);
configPanelSouth.setLayout(gb);
GridBagConstraints c = new GridBagConstraints();
c.ipadx = 3;
c.ipady = 3;
persLabel = new JLabel(); // the text will be set later
persLabel.setBorder(BorderFactory.createEmptyBorder(
INSET_PX, INSET_PX, INSET_PX, INSET_PX));
c.fill = GridBagConstraints.BOTH;
c.gridx = 0;
c.gridy = 0;
c.gridwidth = 3;
c.weightx = 1.0; c.weighty = 0.0;
gb.setConstraints(persLabel, c);
configPanelNorth.add(persLabel);
JPanel persPanel = new JPanel(new BorderLayout());
JScrollPane persScroll =
new JScrollPane(perspectiveList,
JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED,
JScrollPane.HORIZONTAL_SCROLLBAR_NEVER);
persPanel.add(renameTextField, BorderLayout.NORTH);
persPanel.add(persScroll, BorderLayout.CENTER);
c.gridx = 0;
c.gridy = 1;
c.gridwidth = 4;
c.weightx = 1.0; c.weighty = 1.0;
gb.setConstraints(persPanel, c);
configPanelNorth.add(persPanel);
JPanel persButtons = new JPanel(new GridLayout(6, 1, 0, 5));
persButtons.add(newPerspectiveButton);
persButtons.add(removePerspectiveButton);
persButtons.add(duplicatePerspectiveButton);
persButtons.add(moveUpButton);
persButtons.add(moveDownButton);
persButtons.add(resetToDefaultButton);
JPanel persButtonWrapper =
new JPanel(new FlowLayout(FlowLayout.RIGHT, 0, 0));
persButtonWrapper.add(persButtons);
c.gridx = 4;
c.gridy = 1;
c.gridwidth = 1;
c.weightx = 0.0; c.weighty = 0.0;
c.ipadx = 0; c.ipady = 0;
c.insets = new Insets(0, 5, 0, 0);
gb.setConstraints(persButtonWrapper, c);
configPanelNorth.add(persButtonWrapper);
ruleLibLabel = new JLabel(); // the text will be set later
ruleLibLabel.setBorder(BorderFactory.createEmptyBorder(
INSET_PX, INSET_PX, INSET_PX, INSET_PX));
c.gridx = 0;
c.gridy = 3;
c.gridwidth = 1;
c.weightx = 1.0;
c.weighty = 0.0;
c.ipadx = 3;
c.ipady = 3;
c.insets = new Insets(10, 0, 0, 0);
gb.setConstraints(ruleLibLabel, c);
configPanelSouth.add(ruleLibLabel);
addRuleButton.setMargin(new Insets(2, 15, 2, 15));
removeRuleButton.setMargin(new Insets(2, 15, 2, 15));
JPanel xferButtons = new JPanel();
xferButtons.setLayout(new BoxLayout(xferButtons, BoxLayout.Y_AXIS));
xferButtons.add(addRuleButton);
xferButtons.add(new SpacerPanel());
xferButtons.add(removeRuleButton);
c.gridx = 2;
c.gridy = 4;
c.weightx = 0.0;
c.weighty = 0.0;
c.insets = new Insets(0, 3, 0, 5);
gb.setConstraints(xferButtons, c);
configPanelSouth.add(xferButtons);
rulesLabel = new JLabel(); // the text will be set later
rulesLabel.setBorder(BorderFactory.createEmptyBorder(
INSET_PX, INSET_PX, INSET_PX, INSET_PX));
c.gridx = 3;
c.gridy = 3;
c.gridwidth = 1;
c.weightx = 1.0;
c.insets = new Insets(10, 0, 0, 0);
gb.setConstraints(rulesLabel, c);
configPanelSouth.add(rulesLabel);
c.gridx = 0;
c.gridy = 4;
c.weighty = 1.0;
c.gridwidth = 2;
c.gridheight = 2;
c.insets = new Insets(0, 0, 0, 0);
JScrollPane ruleLibScroll =
new JScrollPane(ruleLibraryList,
JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED,
JScrollPane.HORIZONTAL_SCROLLBAR_NEVER);
gb.setConstraints(ruleLibScroll, c);
configPanelSouth.add(ruleLibScroll);
c.gridx = 3;
c.gridy = 4;
c.gridwidth = 2;
c.gridheight = 2;
JScrollPane rulesScroll =
new JScrollPane(perspectiveRulesList,
JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED,
JScrollPane.HORIZONTAL_SCROLLBAR_NEVER);
gb.setConstraints(rulesScroll, c);
configPanelSouth.add(rulesScroll);
}
/**
* Add action listeners to the buttons and lists.
*/
private void makeListeners() {
renameTextField.addActionListener(new RenameListener());
renameTextField.getDocument().addDocumentListener(
new RenameDocumentListener());
newPerspectiveButton.addActionListener(new NewPerspectiveListener());
removePerspectiveButton.addActionListener(
new RemovePerspectiveListener());
duplicatePerspectiveButton.addActionListener(
new DuplicatePerspectiveListener());
moveUpButton.addActionListener(new MoveUpListener());
moveDownButton.addActionListener(new MoveDownListener());
addRuleButton.addActionListener(new RuleListener());
removeRuleButton.addActionListener(new RuleListener());
resetToDefaultButton.addActionListener(new ResetListener());
perspectiveList.addListSelectionListener(
new PerspectiveListSelectionListener());
perspectiveRulesList.addListSelectionListener(
new RulesListSelectionListener());
perspectiveRulesList.addMouseListener(new RuleListMouseListener());
ruleLibraryList.addListSelectionListener(
new LibraryListSelectionListener());
ruleLibraryList.addMouseListener(new RuleListMouseListener());
getOkButton().addActionListener(new OkListener());
}
/**
* Load all the existing rules from the perspective manager
* for presentation. These will be presented as the library of rules
* the user may pick from.
*/
private void loadLibrary() {
List<PerspectiveRule> rulesLib = new ArrayList<PerspectiveRule>();
rulesLib.addAll(PerspectiveManager.getInstance().getRules());
Collections.sort(rulesLib, new Comparator<PerspectiveRule>() {
public int compare(PerspectiveRule o1, PerspectiveRule o2) {
return o1.toString().compareTo(o2.toString());
}
});
// remove the ones already selected (if a perspective is selected)
ExplorerPerspective selPers =
(ExplorerPerspective) perspectiveList.getSelectedValue();
if (selPers != null) {
for (PerspectiveRule persRule : selPers.getList()) {
for (PerspectiveRule libRule : rulesLib) {
if (libRule.toString().equals(persRule.toString())) {
rulesLib.remove(libRule);
break;
}
}
}
}
// add them
ruleLibraryListModel.clear();
for (PerspectiveRule rule : rulesLib) {
ruleLibraryListModel.addElement(rule);
}
updateLibLabel();
}
/**
* Load the perspectives from the perspective manager for presentation.
*/
private void loadPerspectives() {
List<ExplorerPerspective> perspectives =
PerspectiveManager.getInstance().getPerspectives();
// must add an editable list of new ExplorerPerspective's
// to the list model so that the original ones are not changed
// in the case of a cancel action by the user.
for (ExplorerPerspective perspective : perspectives) {
List<PerspectiveRule> rules = perspective.getList();
ExplorerPerspective editablePerspective =
new ExplorerPerspective(perspective.toString());
for (PerspectiveRule rule : rules) {
editablePerspective.addRule(rule);
}
perspectiveListModel.addElement(editablePerspective);
}
updatePersLabel();
}
/**
* Update the label above the list of perspectives with count.
*/
private void updatePersLabel() {
persLabel.setText(Translator.localize("label.perspectives")
+ " (" + perspectiveListModel.size() + ")");
}
/**
* Update the label above the library of rules list with count.
*/
private void updateLibLabel() {
// update the label (which shows the number of rules)
ruleLibLabel.setText(Translator.localize("label.rules-library")
+ " (" + ruleLibraryListModel.size() + ")");
}
/**
* Update the label above the library of rules list with count.
*/
private void updateRuleLabel() {
// update the label (which shows the number of rules)
rulesLabel.setText(Translator.localize("label.selected-rules")
+ " (" + perspectiveRulesListModel.size() + ")");
}
/**
* @param list the JList to be sorted
*/
private void sortJListModel(JList list) {
DefaultListModel model = (DefaultListModel) list.getModel();
List all = new ArrayList();
for (int i = 0; i < model.getSize(); i++) {
all.add(model.getElementAt(i));
}
model.clear();
Collections.sort(all, new Comparator() {
public int compare(Object o1, Object o2) {
return o1.toString().compareTo(o2.toString());
}
});
for (Object obj : all) {
model.addElement(obj);
}
}
/**
* Handles pressing the OK button. <p>
*
* Updates the perspectives in the explorer,
* saves the user perspectives and exits.
*/
class OkListener implements ActionListener {
public void actionPerformed(ActionEvent e) {
PerspectiveManager.getInstance().removeAllPerspectives();
for (int i = 0; i < perspectiveListModel.size(); i++) {
ExplorerPerspective perspective =
(ExplorerPerspective) perspectiveListModel.get(i);
PerspectiveManager.getInstance().addPerspective(perspective);
}
PerspectiveManager.getInstance().saveUserPerspectives();
}
}
/**
* Handles pressing the Reset-To-Default button. <p>
*
* Resets all perspectives to the build-in defaults.
*/
class ResetListener implements ActionListener {
public void actionPerformed(ActionEvent e) {
Collection<ExplorerPerspective> c =
PerspectiveManager.getInstance().getDefaultPerspectives();
if (c.size() > 0) {
perspectiveListModel.removeAllElements();
for (ExplorerPerspective p : c) {
perspectiveListModel.addElement(p);
}
updatePersLabel();
}
}
}
/**
* Handles pressing the "New" button.
*/
class NewPerspectiveListener implements ActionListener {
public void actionPerformed(ActionEvent e) {
Object[] msgArgs = {
Integer.valueOf((perspectiveList.getModel().getSize() + 1)),
};
ExplorerPerspective newPers =
new ExplorerPerspective(Translator.messageFormat(
"dialog.perspective.explorer-perspective", msgArgs));
perspectiveListModel.insertElementAt(newPers, 0);
perspectiveList.setSelectedValue(newPers, true);
perspectiveRulesListModel.clear();
updatePersLabel();
updateRuleLabel();
}
}
/**
* Handles pressing the "Remove" button.
*/
class RemovePerspectiveListener implements ActionListener {
public void actionPerformed(ActionEvent e) {
Object sel = perspectiveList.getSelectedValue();
if (perspectiveListModel.getSize() > 1) {
perspectiveListModel.removeElement(sel);
}
perspectiveList.setSelectedIndex(0);
if (perspectiveListModel.getSize() == 1) {
removePerspectiveButton.setEnabled(false);
}
updatePersLabel();
}
}
/**
* Handles pressing the Duplicate button.
*/
class DuplicatePerspectiveListener implements ActionListener {
public void actionPerformed(ActionEvent e) {
Object sel = perspectiveList.getSelectedValue();
if (sel != null) {
Object[] msgArgs = {sel.toString() };
ExplorerPerspective newPers =
((ExplorerPerspective) sel).makeNamedClone(Translator
.messageFormat("dialog.perspective.copy-of", msgArgs));
perspectiveListModel.insertElementAt(newPers, 0);
perspectiveList.setSelectedValue(newPers, true);
}
updatePersLabel();
}
}
/**
* Handles pressing the ">>" or "<<" buttons.
*/
class RuleListener implements ActionListener {
public void actionPerformed(ActionEvent e) {
Object src = e.getSource();
if (perspectiveList.getSelectedValue() == null) {
return;
}
if (src == addRuleButton) {
doAddRule();
} else if (src == removeRuleButton) {
doRemoveRule();
}
}
}
/**
* Handles double-clicking on the library list or on the ruleslist.
* This triggers the same functions as ">>" or "<<".
*/
class RuleListMouseListener extends MouseAdapter {
public void mouseClicked(MouseEvent me) {
Object src = me.getSource();
if (me.getClickCount() != 2
|| perspectiveList.getSelectedValue() == null) {
return;
}
if (src == ruleLibraryList && addRuleButton.isEnabled()) {
doAddRule();
}
if (src == perspectiveRulesList && removeRuleButton.isEnabled()) {
doRemoveRule();
}
}
}
/**
* Add the currently selected rule from the library to the rules list
* for the current perspective.
*/
private void doAddRule() {
Object sel = ruleLibraryList.getSelectedValue();
int selLibNr = ruleLibraryList.getSelectedIndex();
try {
PerspectiveRule newRule =
(PerspectiveRule) sel.getClass().newInstance();
perspectiveRulesListModel.insertElementAt(newRule, 0);
((ExplorerPerspective) perspectiveList.getSelectedValue())
.addRule(newRule);
sortJListModel(perspectiveRulesList);
perspectiveRulesList.setSelectedValue(newRule, true);
// remove the rule from the library list
loadLibrary();
// set the newly selected item in the library list
if (!(ruleLibraryListModel.size() > selLibNr)) {
selLibNr = ruleLibraryListModel.size() - 1;
}
ruleLibraryList.setSelectedIndex(selLibNr);
updateRuleLabel();
} catch (Exception e) {
LOG.error("problem adding rule", e);
}
}
/**
* Remove the currently selected rule from the rules list
* for the current perspective.
*/
private void doRemoveRule() {
int selLibNr = ruleLibraryList.getSelectedIndex();
PerspectiveRule sel =
(PerspectiveRule) perspectiveRulesList.getSelectedValue();
int selectedItem = perspectiveRulesList.getSelectedIndex();
Object selPers = perspectiveList.getSelectedValue();
perspectiveRulesListModel.removeElement(sel);
((ExplorerPerspective) selPers).removeRule(sel);
if (perspectiveRulesListModel.getSize() > selectedItem) {
perspectiveRulesList.setSelectedIndex(selectedItem);
} else if (perspectiveRulesListModel.getSize() > 0) {
perspectiveRulesList.setSelectedIndex(
perspectiveRulesListModel.getSize() - 1);
}
loadLibrary();
// set the newly selected item in the library list
ruleLibraryList.setSelectedIndex(selLibNr);
updateRuleLabel();
}
/**
* Handles pressing the move up button.
*/
class MoveUpListener implements ActionListener {
/*
* @see java.awt.event.ActionListener#actionPerformed(java.awt.event.ActionEvent)
*/
public void actionPerformed(ActionEvent e) {
int sel = perspectiveList.getSelectedIndex();
if (sel > 0) {
Object selObj = perspectiveListModel.get(sel);
Object prevObj = perspectiveListModel.get(sel - 1);
perspectiveListModel.set(sel, prevObj);
perspectiveListModel.set(sel - 1, selObj);
perspectiveList.setSelectedIndex(sel - 1);
perspectiveList.ensureIndexIsVisible(sel - 1);
}
}
}
/**
* Handles pressing the move down button.
*/
class MoveDownListener implements ActionListener {
public void actionPerformed(ActionEvent e) {
int sel = perspectiveList.getSelectedIndex();
if (sel < (perspectiveListModel.getSize() - 1)) {
Object selObj = perspectiveListModel.get(sel);
Object nextObj = perspectiveListModel.get(sel + 1);
perspectiveListModel.set(sel, nextObj);
perspectiveListModel.set(sel + 1, selObj);
perspectiveList.setSelectedIndex(sel + 1);
perspectiveList.ensureIndexIsVisible(sel + 1);
}
}
}
/**
* Handles confirming a changed text in the text-entry field
* (e.g. pressing Enter) for the perspective name.
*/
class RenameListener implements ActionListener {
public void actionPerformed(ActionEvent e) {
int sel = perspectiveList.getSelectedIndex();
Object selPers = perspectiveList.getSelectedValue();
String newName = renameTextField.getText();
if (sel >= 0 && newName.length() > 0) {
((ExplorerPerspective) selPers).setName(newName);
perspectiveListModel.set(sel, selPers);
/* TODO: Replace the functioncall in the next line
* by .requestFocusInWindow() once
* we do not support Java 1.3 any more.
*/
perspectiveList.requestFocus();
}
}
}
/**
* Handles changes in the text in the text-entry field
* for the perspective name.
*/
class RenameDocumentListener implements DocumentListener {
public void insertUpdate(DocumentEvent e) {
update();
}
public void removeUpdate(DocumentEvent e) {
update();
}
public void changedUpdate(DocumentEvent e) {
update();
}
private void update() {
int sel = perspectiveList.getSelectedIndex();
Object selPers = perspectiveList.getSelectedValue();
String newName = renameTextField.getText();
if (sel >= 0 && newName.length() > 0) {
((ExplorerPerspective) selPers).setName(newName);
perspectiveListModel.set(sel, selPers);
}
}
}
/**
* Handles selection changes in the perspective list.
*/
class PerspectiveListSelectionListener implements ListSelectionListener {
/*
* @see javax.swing.event.ListSelectionListener#valueChanged(javax.swing.event.ListSelectionEvent)
*/
public void valueChanged(ListSelectionEvent lse) {
if (lse.getValueIsAdjusting()) {
return;
}
Object selPers = perspectiveList.getSelectedValue();
loadLibrary();
Object selRule = ruleLibraryList.getSelectedValue();
renameTextField.setEnabled(selPers != null);
removePerspectiveButton.setEnabled(selPers != null);
duplicatePerspectiveButton.setEnabled(selPers != null);
moveUpButton.setEnabled(perspectiveList.getSelectedIndex() > 0);
moveDownButton.setEnabled((selPers != null)
&& (perspectiveList.getSelectedIndex()
< (perspectiveList.getModel().getSize() - 1)));
if (selPers == null) {
return;
}
renameTextField.setText(selPers.toString());
ExplorerPerspective pers = (ExplorerPerspective) selPers;
perspectiveRulesListModel.clear();
for (PerspectiveRule rule : pers.getList()) {
perspectiveRulesListModel.insertElementAt(rule, 0);
}
sortJListModel(perspectiveRulesList);
addRuleButton.setEnabled(selPers != null && selRule != null);
updateRuleLabel();
}
}
/**
* Handles selection changes in the rules list.
*/
class RulesListSelectionListener implements ListSelectionListener {
/*
* @see javax.swing.event.ListSelectionListener#valueChanged(javax.swing.event.ListSelectionEvent)
*/
public void valueChanged(ListSelectionEvent lse) {
if (lse.getValueIsAdjusting()) {
return;
}
Object selPers = null;
if (perspectiveListModel.size() > 0) {
selPers = perspectiveList.getSelectedValue();
}
Object selRule = null;
if (perspectiveRulesListModel.size() > 0) {
selRule = perspectiveRulesList.getSelectedValue();
}
removeRuleButton.setEnabled(selPers != null && selRule != null);
}
}
/**
* Handles selection changes in the library list.
*
*/
class LibraryListSelectionListener implements ListSelectionListener {
/*
* @see javax.swing.event.ListSelectionListener#valueChanged(javax.swing.event.ListSelectionEvent)
*/
public void valueChanged(ListSelectionEvent lse) {
if (lse.getValueIsAdjusting()) {
return;
}
Object selPers = perspectiveList.getSelectedValue();
Object selRule = ruleLibraryList.getSelectedValue();
addRuleButton.setEnabled(selPers != null && selRule != null);
}
}
}