java/src/IceGridGUI/LiveDeploymentPane.java

   1 // **********************************************************************
   2 //
   3 // Copyright (c) 2003-2011 ZeroC, Inc. All rights reserved.
   4 //
   5 // This copy of Ice is licensed to you under the terms described in the
   6 // ICE_LICENSE file included in this distribution.
   7 //
   8 // **********************************************************************
   9
  10 package IceGridGUI;
  11
  12 import java.awt.*;
  13 import java.awt.event.WindowAdapter;
  14 import java.awt.event.WindowEvent;
  15 import java.awt.event.ActionEvent;
  16 import java.awt.event.MouseAdapter;
  17 import java.awt.event.MouseEvent;
  18
  19 import javax.swing.*;
  20 import javax.swing.border.AbstractBorder;
  21 import javax.swing.border.EmptyBorder;
  22 import javax.swing.event.TreeSelectionEvent;
  23 import javax.swing.event.TreeSelectionListener;
  24 import javax.swing.plaf.SplitPaneUI;
  25 import javax.swing.plaf.basic.BasicSplitPaneUI;
  26 import javax.swing.tree.TreeCellRenderer;
  27 import javax.swing.tree.TreeSelectionModel;
  28 import javax.swing.tree.TreePath;
  29
  30 import com.jgoodies.forms.factories.Borders;
  31
  32 import IceGrid.*;
  33 import IceGridGUI.LiveDeployment.Editor;
  34 import IceGridGUI.LiveDeployment.Root;
  35 import IceGridGUI.LiveDeployment.TreeNode;
  36
  37 public class LiveDeploymentPane extends JSplitPane implements Tab
  38 {
  39     public void updateUI()
  40     {
  41         super.updateUI();
  42         setEmptyDividerBorder();
  43     }
  44
  45     public void selected()
  46     {
  47         Coordinator c = _root.getCoordinator();
  48
  49         if(c.connected())
  50         {
  51             c.getShowLiveDeploymentFiltersAction().setEnabled(true);
  52         }
  53         c.getCloseApplicationAction().setEnabled(false);
  54         c.getSaveAction().setEnabled(false);
  55         c.getSaveToRegistryAction().setEnabled(false);
  56         c.getSaveToFileAction().setEnabled(false);
  57         c.getDiscardUpdatesAction().setEnabled(false);
  58
  59         c.getBackAction().setEnabled(_previousNodes.size() > 0);
  60         c.getForwardAction().setEnabled(_nextNodes.size() > 0);
  61         c.showActions(_currentNode);
  62     }
  63
  64     public void refresh()
  65     {
  66         if(_currentNode != null)
  67         {
  68             _currentNode.getEditor();
  69
  70             if(_root.getCoordinator().getCurrentTab() == this)
  71             {
  72                 //
  73                 // Refresh actions as well
  74                 //
  75                 _root.getCoordinator().showActions(_currentNode);
  76             }
  77         }
  78     }
  79
  80     public void showNode(TreeNodeBase node)
  81     {
  82         TreeNode newNode = (TreeNode)node;
  83
  84         if(newNode != _currentNode)
  85         {
  86             if(newNode == null)
  87             {
  88                 _currentNode = null;
  89                 showCurrentNode();
  90             }
  91             else
  92             {
  93                 if(_currentNode != null && _root.hasNode(_currentNode))
  94                 {
  95                     _previousNodes.add(_currentNode);
  96                     while(_previousNodes.size() >= HISTORY_MAX_SIZE)
  97                     {
  98                         _previousNodes.removeFirst();
  99                     }
 100                     _root.getCoordinator().getBackAction().setEnabled(true);
 101                 }
 102                 _nextNodes.clear();
 103                 _root.getCoordinator().getForwardAction().setEnabled(false);
 104                 _currentNode = newNode;
 105                 showCurrentNode();
 106             }
 107         }
 108         else
 109         {
 110             refresh();
 111         }
 112     }
 113
 114     public void back()
 115     {
 116         TreeNode previousNode = null;
 117         do
 118         {
 119             previousNode = _previousNodes.removeLast();
 120         } while(_previousNodes.size() > 0 && (previousNode == _currentNode || !_root.hasNode(previousNode)));
 121
 122         if(_previousNodes.size() == 0)
 123         {
 124             _root.getCoordinator().getBackAction().setEnabled(false);
 125         }
 126
 127         if(previousNode != _currentNode)
 128         {
 129             if(_currentNode != null)
 130             {
 131                 _nextNodes.addFirst(_currentNode);
 132                 _root.getCoordinator().getForwardAction().setEnabled(true);
 133             }
 134
 135             _currentNode = previousNode;
 136             _selectionListenerEnabled = false;
 137             _root.setSelectedNode(_currentNode);
 138             _selectionListenerEnabled = true;
 139             showCurrentNode();
 140         }
 141     }
 142
 143     public void forward()
 144     {
 145         TreeNode nextNode = null;
 146         do
 147         {
 148             nextNode = _nextNodes.removeFirst();
 149         } while(_nextNodes.size() > 0 && (nextNode == _currentNode || !_root.hasNode(nextNode)));
 150
 151         if(_nextNodes.size() == 0)
 152         {
 153             _root.getCoordinator().getForwardAction().setEnabled(false);
 154         }
 155
 156         if(nextNode != _currentNode)
 157         {
 158             if(_currentNode != null)
 159             {
 160                 _previousNodes.add(_currentNode);
 161                 _root.getCoordinator().getBackAction().setEnabled(true);
 162             }
 163
 164             _currentNode = nextNode;
 165             _selectionListenerEnabled = false;
 166             _root.setSelectedNode(_currentNode);
 167             _selectionListenerEnabled = true;
 168             showCurrentNode();
 169         }
 170     }
 171
 172     public void save()
 173     {
 174         assert false;
 175     }
 176
 177     public void saveToRegistry()
 178     {
 179         assert false;
 180     }
 181
 182     public void saveToFile()
 183     {
 184         assert false;
 185     }
 186
 187     public void discardUpdates()
 188     {
 189         assert false;
 190     }
 191
 192     public boolean close()
 193     {
 194         return false;
 195     }
 196
 197     LiveDeploymentPane(Root root)
 198     {
 199         super(JSplitPane.HORIZONTAL_SPLIT, true);
 200         _root = root;
 201         setBorder(new EmptyBorder(10, 10, 10, 10));
 202
 203         //
 204         // Tree display
 205         //
 206         TreeCellRenderer renderer = new CellRenderer();
 207         PopupListener popupListener = new PopupListener();
 208
 209         JTree tree = _root.getTree();
 210
 211         tree.setBorder(new EmptyBorder(5, 5, 5, 5));
 212         tree.setCellRenderer(renderer);
 213         ToolTipManager.sharedInstance().registerComponent(tree);
 214         tree.addMouseListener(popupListener);
 215
 216         tree.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);
 217
 218         tree.addTreeSelectionListener(new SelectionListener());
 219
 220         tree.setRootVisible(false);
 221
 222         JScrollPane leftScroll =
 223             new JScrollPane(tree,
 224                             JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED,
 225                             JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
 226         leftScroll.setBorder(Borders.EMPTY_BORDER);
 227
 228         _leftPane = new SimpleInternalFrame("Runtime Components");
 229         _leftPane.setContent(leftScroll);
 230         _leftPane.setPreferredSize(new Dimension(280, 350));
 231
 232         //
 233         // Right pane
 234         //
 235         _propertiesFrame = new SimpleInternalFrame("Properties");
 236
 237         setLeftComponent(_leftPane);
 238         setRightComponent(_propertiesFrame);
 239     }
 240
 241     private void showCurrentNode()
 242     {
 243         _root.getCoordinator().showActions(_currentNode);
 244         if(_currentNode == null)
 245         {
 246             Component oldContent = _propertiesFrame.getContent();
 247             if(oldContent != null)
 248             {
 249                 _propertiesFrame.remove(oldContent);
 250             }
 251             _propertiesFrame.setTitle("Properties");
 252             _propertiesFrame.setToolBar(null);
 253         }
 254         else
 255         {
 256             Editor editor = _currentNode.getEditor();
 257             Component currentProperties = editor.getProperties();
 258             _propertiesFrame.setContent(currentProperties);
 259             _propertiesFrame.setTitle(currentProperties.getName());
 260             _propertiesFrame.setToolBar(editor.getToolBar());
 261         }
 262         _propertiesFrame.validate();
 263         _propertiesFrame.repaint();
 264     }
 265
 266     private void setEmptyDividerBorder()
 267     {
 268         SplitPaneUI splitPaneUI = getUI();
 269         if(splitPaneUI instanceof BasicSplitPaneUI)
 270         {
 271             BasicSplitPaneUI basicUI = (BasicSplitPaneUI)splitPaneUI;
 272             basicUI.getDivider().setBorder(BorderFactory.createEmptyBorder());
 273         }
 274     }
 275
 276     private class SelectionListener implements TreeSelectionListener
 277     {
 278         public void valueChanged(TreeSelectionEvent e)
 279         {
 280             if(_selectionListenerEnabled)
 281             {
 282                 TreePath path = null;
 283                 if(e.isAddedPath())
 284                 {
 285                     path = e.getPath();
 286                 }
 287
 288                 if(path == null)
 289                 {
 290                     showNode(null);
 291                 }
 292                 else
 293                 {
 294                     showNode((TreeNode)path.getLastPathComponent());
 295                 }
 296             }
 297         }
 298     }
 299
 300     private class PopupListener extends MouseAdapter
 301     {
 302         public void mousePressed(MouseEvent e)
 303         {
 304             maybeShowPopup(e);
 305         }
 306
 307         public void mouseReleased(MouseEvent e)
 308         {
 309             maybeShowPopup(e);
 310         }
 311
 312         private void maybeShowPopup(MouseEvent e)
 313         {
 314             if (e.isPopupTrigger())
 315             {
 316                 JTree tree = (JTree)e.getComponent();
 317
 318                 TreePath path = tree.getPathForLocation(e.getX(), e.getY());
 319
 320                 if(path != null)
 321                 {
 322                     TreeNode node = (TreeNode)path.getLastPathComponent();
 323                     JPopupMenu popup = node.getPopupMenu();
 324                     if(popup != null)
 325                     {
 326                         popup.show(tree, e.getX(), e.getY());
 327                     }
 328                 }
 329             }
 330         }
 331     }
 332
 333     private Root _root;
 334     private SimpleInternalFrame _leftPane;
 335     private SimpleInternalFrame _propertiesFrame;
 336
 337     //
 338     // back/forward navigation
 339     //
 340     private java.util.LinkedList<TreeNode> _previousNodes = new java.util.LinkedList<TreeNode>();
 341     private java.util.LinkedList<TreeNode> _nextNodes = new java.util.LinkedList<TreeNode>();
 342     private TreeNode _currentNode;
 343
 344     private boolean _selectionListenerEnabled = true;
 345
 346     static private final int HISTORY_MAX_SIZE = 20;
 347 }