/* $Id: ToDoPane.java 18817 2010-10-27 15:52:25Z tfmorris $
*****************************************************************************
* 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-2008 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.cognitive.ui;
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.List;
import javax.swing.BorderFactory;
import javax.swing.JComboBox;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTree;
import javax.swing.SwingUtilities;
import javax.swing.event.TreeSelectionEvent;
import javax.swing.event.TreeSelectionListener;
import javax.swing.tree.TreeModel;
import javax.swing.tree.TreePath;
import org.apache.log4j.Logger;
import org.argouml.cognitive.Designer;
import org.argouml.cognitive.ToDoItem;
import org.argouml.cognitive.ToDoList;
import org.argouml.cognitive.ToDoListEvent;
import org.argouml.cognitive.ToDoListListener;
import org.argouml.cognitive.Translator;
import org.argouml.ui.DisplayTextTree;
import org.argouml.ui.PerspectiveSupport;
import org.argouml.ui.ProjectBrowser;
import org.argouml.ui.SplashScreen;
/**
* The lower-left pane of the main ArgoUML window, which shows the list
* of active critics and todo items. <p>
*
* This pane shows a list or tree of all the "to do" items that
* the designer should consider. <p>
*
* This class is similar to the NavigatorPane.
* It uses the same treemodel class and JTree implementation. <p>
*
* Perspectives are now built here. <p>
*
* Future plans may involve:<ol>
* <li> DecisionModelListener implementation
* <li> GoalListener implementation
* </ol>
*
*<pre>
* possible future additions:
* ToDoPerspective difficulty = new ToDoByDifficulty();
* ToDoPerspective skill = new ToDoBySkill();
*</pre>
*/
public class ToDoPane extends JPanel
implements ItemListener,
TreeSelectionListener,
MouseListener,
ToDoListListener {
/**
* Logger.
*/
private static final Logger LOG = Logger.getLogger(ToDoPane.class);
private static final int WARN_THRESHOLD = 50;
private static final int ALARM_THRESHOLD = 100;
private static final Color WARN_COLOR = Color.yellow;
private static final Color ALARM_COLOR = Color.pink;
private static int clicksInToDoPane;
private static int dblClicksInToDoPane;
private static int toDoPerspectivesChanged;
private JTree tree;
private JComboBox combo;
/**
* List of TreeModels.
*/
private List<ToDoPerspective> perspectives;
private ToDoPerspective curPerspective;
private ToDoList root;
private JLabel countLabel;
private Object lastSel;
/**
* Construct the ToDoPane.
* @param splash Unused parameter for backwards compatibility.
*
* @deprecated for 0.31.7 by tfmorris. Use 0-arg constructor.
*/
@Deprecated
public ToDoPane(@SuppressWarnings("unused") SplashScreen splash) {
this();
}
/**
* Construct the ToDoPane.
*/
public ToDoPane() {
setLayout(new BorderLayout());
combo = new JComboBox();
tree = new DisplayTextTree();
perspectives = new ArrayList<ToDoPerspective>();
countLabel = new JLabel(formatCountLabel(999));
countLabel.setBorder(BorderFactory.createEmptyBorder(0, 4, 0, 4));
JPanel toolbarPanel = new JPanel(new BorderLayout());
toolbarPanel.add(countLabel, BorderLayout.EAST);
toolbarPanel.add(combo, BorderLayout.CENTER);
add(toolbarPanel, BorderLayout.NORTH);
add(new JScrollPane(tree), BorderLayout.CENTER);
combo.addItemListener(this);
tree.addTreeSelectionListener(this);
tree.setCellRenderer(new ToDoTreeRenderer());
tree.addMouseListener(this);
// next line coming from projectbrowser
setRoot(Designer.theDesigner().getToDoList());
Designer.theDesigner().getToDoList().addToDoListListener(this);
setPerspectives(buildPerspectives());
setMinimumSize(new Dimension(120, 100));
Dimension preferredSize = getPreferredSize();
preferredSize.height = 120;
setPreferredSize(preferredSize);
}
/**
* @param r the root
*/
public void setRoot(ToDoList r) {
root = r;
updateTree();
}
/**
* @return the root
*/
public ToDoList getRoot() {
return root;
}
/**
* @return the perspectives treemodels
*/
public List<ToDoPerspective> getPerspectiveList() {
return perspectives;
}
/**
* @param pers the perspectives
*/
public void setPerspectives(List<ToDoPerspective> pers) {
perspectives = pers;
if (pers.isEmpty()) {
curPerspective = null;
} else {
curPerspective = pers.get(0);
}
for (ToDoPerspective tdp : perspectives) {
combo.addItem(tdp);
}
if (pers.isEmpty()) {
curPerspective = null;
} else if (pers.contains(curPerspective)) {
setCurPerspective(curPerspective);
} else {
setCurPerspective(perspectives.get(0));
}
updateTree();
}
/**
* @return the current perspectives
*/
public ToDoPerspective getCurPerspective() {
return curPerspective;
}
/**
* @param per the current perspective
*/
public void setCurPerspective(TreeModel per) {
if (perspectives == null || !perspectives.contains(per)) {
return;
}
combo.setSelectedItem(per);
toDoPerspectivesChanged++;
}
/**
* @return the last <code>Object</code> in the first selected node's
* <code>TreePath</code>,
* or <code>null</code> if nothing is selected
*/
public Object getSelectedObject() {
return tree.getLastSelectedPathComponent();
}
/**
* @param item the item to be selected
*/
public void selectItem(ToDoItem item) {
Object[] path = new Object[3];
Object category = null;
int size = curPerspective.getChildCount(root);
for (int i = 0; i < size; i++) {
category = curPerspective.getChild(root, i);
if (curPerspective.getIndexOfChild(category, item) != -1) {
break;
}
}
if (category == null) {
return;
}
path[0] = root;
path[1] = category;
path[2] = item;
TreePath trPath = new TreePath(path);
tree.expandPath(trPath);
tree.scrollPathToVisible(trPath);
tree.setSelectionPath(trPath);
}
// ------------ ItemListener implementation ----------------------
/**
* Called when the user selects a perspective from the perspective
* combo. <p>
* {@inheritDoc}
*/
public void itemStateChanged(ItemEvent e) {
if (e.getSource() == combo) {
updateTree();
}
}
// -------------TreeSelectionListener implementation -----------
/*
* @see javax.swing.event.TreeSelectionListener#valueChanged(javax.swing.event.TreeSelectionEvent)
*/
public void valueChanged(TreeSelectionEvent e) {
LOG.debug("ToDoPane valueChanged");
//TODO: should fire its own event and ProjectBrowser
//should register a listener - tfm
Object sel = getSelectedObject();
ProjectBrowser.getInstance().setToDoItem(sel);
LOG.debug("lastselection: " + lastSel);
LOG.debug("sel: " + sel);
if (lastSel instanceof ToDoItem) {
((ToDoItem) lastSel).deselect();
}
if (sel instanceof ToDoItem) {
((ToDoItem) sel).select();
}
lastSel = sel;
}
// ------------- MouseListener implementation ---------------
/*
* @see java.awt.event.MouseListener#mousePressed(java.awt.event.MouseEvent)
*/
public void mousePressed(MouseEvent e) {
// Empty implementation.
}
/*
* @see java.awt.event.MouseListener#mouseReleased(java.awt.event.MouseEvent)
*/
public void mouseReleased(MouseEvent e) {
// Empty implementation.
}
/*
* @see java.awt.event.MouseListener#mouseEntered(java.awt.event.MouseEvent)
*/
public void mouseEntered(MouseEvent e) {
// Empty implementation.
}
/*
* @see java.awt.event.MouseListener#mouseExited(java.awt.event.MouseEvent)
*/
public void mouseExited(MouseEvent e) {
// Empty implementation.
}
/*
* @see java.awt.event.MouseListener#mouseClicked(java.awt.event.MouseEvent)
*/
public void mouseClicked(MouseEvent e) {
int row = tree.getRowForLocation(e.getX(), e.getY());
TreePath path = tree.getPathForLocation(e.getX(), e.getY());
if (row != -1) {
if (e.getClickCount() >= 2) {
myDoubleClick(row, path);
} else {
mySingleClick(row, path);
}
}
e.consume();
}
////////////////////////////////////////////////////////////////
// ToDoListListener implementation
/**
* Invoke a task on the Swing thread. If we are running on the Swing
* thread, this happens immediately. Otherwise the task is queued for later
* execution using SwingUtilities.invokeLater (actually for the moment
* invokeAndWait but this should be resolved in future).
* <p>
* This is necessary because event notification of ToDoListener events is
* likely to be coming from the ToDo Validity Checker thread running in the
* background.
*
* @param task a Runnable task who's run() method will be invoked
*/
private void swingInvoke(Runnable task) {
if (SwingUtilities.isEventDispatchThread()) {
task.run();
} else {
SwingUtilities.invokeLater(task);
}
}
/*
* @see org.argouml.cognitive.ToDoListListener#toDoItemsChanged(org.argouml.cognitive.ToDoListEvent)
*/
public void toDoItemsChanged(final ToDoListEvent tde) {
swingInvoke(new Runnable() {
public void run() {
if (curPerspective instanceof ToDoListListener) {
((ToDoListListener) curPerspective).toDoItemsChanged(tde);
}
}
});
}
/*
* @see org.argouml.cognitive.ToDoListListener#toDoItemsAdded(org.argouml.cognitive.ToDoListEvent)
*/
public void toDoItemsAdded(final ToDoListEvent tde) {
swingInvoke(new Runnable() {
public void run() {
if (curPerspective instanceof ToDoListListener) {
((ToDoListListener) curPerspective).toDoItemsAdded(tde);
}
List<ToDoItem> items = tde.getToDoItemList();
for (ToDoItem todo : items) {
if (todo.getPriority()
>= ToDoItem.INTERRUPTIVE_PRIORITY) {
// keep nagging until the user solves the problem:
// This seems a nice way to nag:
selectItem(todo);
break; // Only interrupt for one todoitem
}
}
updateCountLabel();
}
});
}
/*
* @see org.argouml.cognitive.ToDoListListener#toDoItemsRemoved(org.argouml.cognitive.ToDoListEvent)
*/
public void toDoItemsRemoved(final ToDoListEvent tde) {
swingInvoke(new Runnable() {
public void run() {
if (curPerspective instanceof ToDoListListener) {
((ToDoListListener) curPerspective).toDoItemsRemoved(tde);
}
updateCountLabel();
}
});
}
/*
* @see org.argouml.cognitive.ToDoListListener#toDoListChanged(org.argouml.cognitive.ToDoListEvent)
*/
public void toDoListChanged(final ToDoListEvent tde) {
swingInvoke(new Runnable() {
public void run() {
if (curPerspective instanceof ToDoListListener) {
((ToDoListListener) curPerspective).toDoListChanged(tde);
}
updateCountLabel();
}
});
}
/* TODO: Indicate the direction! */
private static String formatCountLabel(int size) {
switch (size) {
case 0:
return Translator.localize("label.todopane.no-items");
case 1:
return MessageFormat.
format(Translator.localize("label.todopane.item"),
new Object[] {
Integer.valueOf(size),
});
default:
return MessageFormat.
format(Translator.localize("label.todopane.items"),
new Object[] {
Integer.valueOf(size),
});
}
}
/**
* Update the count label.
*/
public void updateCountLabel() {
int size = Designer.theDesigner().getToDoList().size();
countLabel.setText(formatCountLabel(size));
countLabel.setOpaque(size > WARN_THRESHOLD);
countLabel.setBackground((size >= ALARM_THRESHOLD) ? ALARM_COLOR
: WARN_COLOR);
}
/**
* Update the todo tree.
*/
protected void updateTree() {
ToDoPerspective tm = (ToDoPerspective) combo.getSelectedItem();
curPerspective = tm;
if (curPerspective == null) {
tree.setVisible(false);
} else {
LOG.debug("ToDoPane setting tree model");
curPerspective.setRoot(root);
tree.setShowsRootHandles(true);
tree.setModel(curPerspective);
tree.setVisible(true); // blinks?
}
}
/**
* Called when the user clicks once on an item in the tree. <p>
*
* Q: What should the difference be between a single
* and double click? <p>
* A: A single click selects the todo item in the tree,
* shows the red indication on the diagram,
* and selects the todo tab in the details panel.
* A double click additionally
* selects the offender in the explorer,
* and selects the offender in the diagram (blue selection),
* and selects the properties tab in the details panel.
* In both cases, the focus (for keyboard actions) remains in the todo tree.
*
* @param row the selected row in the tree
* @param path the path in the tree of the selected item
*/
public static void mySingleClick(
@SuppressWarnings("unused") int row,
@SuppressWarnings("unused") TreePath path) {
clicksInToDoPane++;
}
/**
* Called when the user clicks twice on an item in the tree.
* myDoubleClick will invoke the action() on the ToDoItem.
*
* @param row the selected row in the tree
* @param path the path in the tree of the selected item
*/
public void myDoubleClick(
@SuppressWarnings("unused") int row,
@SuppressWarnings("unused") TreePath path) {
dblClicksInToDoPane++;
if (getSelectedObject() == null) {
return;
}
Object sel = getSelectedObject();
if (sel instanceof ToDoItem) {
((ToDoItem) sel).action();
}
//TODO: should fire its own event and ProjectBrowser
//TODO: should register a listener
LOG.debug("2: " + getSelectedObject().toString());
}
/**
* The perspectives to be chosen in the combobox are built here.
*/
private static List<ToDoPerspective> buildPerspectives() {
ToDoPerspective priority = new ToDoByPriority();
ToDoPerspective decision = new ToDoByDecision();
ToDoPerspective goal = new ToDoByGoal();
ToDoPerspective offender = new ToDoByOffender();
ToDoPerspective poster = new ToDoByPoster();
ToDoPerspective type = new ToDoByType();
// add the perspectives to a list for the combobox
List<ToDoPerspective> perspectives = new ArrayList<ToDoPerspective>();
perspectives.add(priority);
perspectives.add(decision);
perspectives.add(goal);
perspectives.add(offender);
perspectives.add(poster);
perspectives.add(type);
PerspectiveSupport.registerRule(new GoListToDecisionsToItems());
PerspectiveSupport.registerRule(new GoListToGoalsToItems());
PerspectiveSupport.registerRule(new GoListToPriorityToItem());
PerspectiveSupport.registerRule(new GoListToTypeToItem());
PerspectiveSupport.registerRule(new GoListToOffenderToItem());
PerspectiveSupport.registerRule(new GoListToPosterToItem());
return perspectives;
}
/**
* The UID.
*/
private static final long serialVersionUID = 1911401582875302996L;
}