plugins/org.argeo.slc.akb.ui/src/main/java/org/argeo/slc/akb/ui/views/EnvironmentsTreeView.java

   1 package org.argeo.slc.akb.ui.views;
   2
   3 import java.util.HashMap;
   4 import java.util.Map;
   5
   6 import javax.jcr.Node;
   7 import javax.jcr.Repository;
   8 import javax.jcr.RepositoryException;
   9 import javax.jcr.Session;
  10
  11 import org.argeo.eclipse.ui.utils.CommandUtils;
  12 import org.argeo.jcr.JcrUtils;
  13 import org.argeo.slc.akb.AkbException;
  14 import org.argeo.slc.akb.AkbNames;
  15 import org.argeo.slc.akb.AkbService;
  16 import org.argeo.slc.akb.AkbTypes;
  17 import org.argeo.slc.akb.ui.AkbUiPlugin;
  18 import org.argeo.slc.akb.ui.AkbUiUtils;
  19 import org.argeo.slc.akb.ui.commands.CreateAkbNode;
  20 import org.argeo.slc.akb.ui.commands.DeleteAkbNodes;
  21 import org.argeo.slc.akb.ui.commands.OpenAkbNodeEditor;
  22 import org.argeo.slc.akb.ui.providers.ActiveEnvsTreeContentProvider;
  23 import org.argeo.slc.akb.ui.providers.ActiveTreeItem;
  24 import org.argeo.slc.akb.ui.providers.AkbTreeLabelProvider;
  25 import org.argeo.slc.akb.ui.utils.AkbItemsComparator;
  26 import org.argeo.slc.akb.ui.utils.Refreshable;
  27 import org.eclipse.jface.action.IMenuListener;
  28 import org.eclipse.jface.action.IMenuManager;
  29 import org.eclipse.jface.action.MenuManager;
  30 import org.eclipse.jface.viewers.DoubleClickEvent;
  31 import org.eclipse.jface.viewers.IDoubleClickListener;
  32 import org.eclipse.jface.viewers.IStructuredSelection;
  33 import org.eclipse.jface.viewers.TreeViewer;
  34 import org.eclipse.swt.SWT;
  35 import org.eclipse.swt.layout.GridData;
  36 import org.eclipse.swt.widgets.Composite;
  37 import org.eclipse.swt.widgets.Menu;
  38 import org.eclipse.ui.IWorkbenchWindow;
  39 import org.eclipse.ui.part.ViewPart;
  40
  41 /** AKB Active environment tree view. */
  42 public class EnvironmentsTreeView extends ViewPart implements Refreshable {
  43
  44         public final static String ID = AkbUiPlugin.PLUGIN_ID
  45                         + ".environmentsTreeView";
  46
  47         /* DEPENDENCY INJECTION */
  48         private Session session;
  49         private AkbService akbService;
  50
  51         // This page widgets
  52         private TreeViewer envTreeViewer;
  53
  54         // Usefull business objects
  55         private Node activeEnvsParentNode;
  56
  57         private void initialize() {
  58                 try {
  59                         activeEnvsParentNode = session
  60                                         .getNode(AkbNames.AKB_ENVIRONMENTS_BASE_PATH);
  61                 } catch (RepositoryException e) {
  62                         throw new AkbException("unable to initialize AKB Browser view", e);
  63                 }
  64         }
  65
  66         @Override
  67         public void createPartControl(Composite parent) {
  68                 initialize();
  69                 envTreeViewer = createTreeViewer(parent);
  70                 envTreeViewer.setInput(activeEnvsParentNode);
  71                 envTreeViewer.setComparator(new AkbItemsComparator());
  72         }
  73
  74         // The main tree viewer
  75         protected TreeViewer createTreeViewer(Composite parent) {
  76                 parent.setLayout(AkbUiUtils.gridLayoutNoBorder());
  77                 int style = SWT.BORDER | SWT.MULTI;
  78
  79                 TreeViewer viewer = new TreeViewer(parent, style);
  80                 viewer.getTree().setLayoutData(
  81                                 new GridData(SWT.FILL, SWT.FILL, true, true));
  82
  83                 viewer.setContentProvider(new ActiveEnvsTreeContentProvider());
  84                 viewer.setLabelProvider(new AkbTreeLabelProvider());
  85                 viewer.addDoubleClickListener(new ViewDoubleClickListener());
  86
  87                 getSite().setSelectionProvider(viewer);
  88
  89                 // context menu
  90                 MenuManager menuManager = new MenuManager();
  91                 Menu menu = menuManager.createContextMenu(viewer.getTree());
  92                 menuManager.addMenuListener(new IMenuListener() {
  93                         public void menuAboutToShow(IMenuManager manager) {
  94                                 contextMenuAboutToShow(manager);
  95                         }
  96                 });
  97                 viewer.getTree().setMenu(menu);
  98                 menuManager.setRemoveAllWhenShown(true);
  99                 getSite().registerContextMenu(menuManager, viewer);
 100
 101                 return viewer;
 102         }
 103
 104         // ////////////////////
 105         // / LIFE CYCLE
 106
 107         @Override
 108         public void forceRefresh(Object object) {
 109                 envTreeViewer.setInput(activeEnvsParentNode);
 110         }
 111
 112         @Override
 113         public void setFocus() {
 114         }
 115
 116         @Override
 117         public void dispose() {
 118                 JcrUtils.logoutQuietly(session);
 119                 super.dispose();
 120         }
 121
 122         // ///////////////////////////
 123         // CONTEXT MENU MANAGEMENT
 124         /**
 125          * Defines the commands that will pop up in the context menu.
 126          **/
 127         protected void contextMenuAboutToShow(IMenuManager menuManager) {
 128                 IWorkbenchWindow window = AkbUiPlugin.getDefault().getWorkbench()
 129                                 .getActiveWorkbenchWindow();
 130                 try {
 131                         // Build conditions
 132                         IStructuredSelection selection = (IStructuredSelection) envTreeViewer
 133                                         .getSelection();
 134
 135                         ActiveTreeItem item = (ActiveTreeItem) selection.getFirstElement();
 136
 137                         boolean hasSelection = item != null;
 138                         Node selected = null, currEnv = null;
 139
 140                         if (hasSelection) {
 141                                 selected = item.getNode();
 142                                 currEnv = item.getEnvironment();
 143                         }
 144                         boolean isEnv = hasSelection ? selected
 145                                         .isNodeType(AkbTypes.AKB_ENV) : false;
 146                         boolean isDeletable = hasSelection ? isEnv : false;
 147                         Map<String, String> params = new HashMap<String, String>();
 148
 149                         // Delete Item
 150                         params = new HashMap<String, String>();
 151                         if (hasSelection)
 152                                 params.put(DeleteAkbNodes.PARAM_NODE_JCR_ID,
 153                                                 selected.getIdentifier());
 154                         AkbUiUtils.refreshParameterizedCommand(menuManager, window,
 155                                         "cmd.deleteItem", DeleteAkbNodes.ID,
 156                                         "Delete selected active environment", null, isDeletable,
 157                                         params);
 158
 159                         // create template
 160                         params = new HashMap<String, String>();
 161                         params.put(OpenAkbNodeEditor.PARAM_NODE_TYPE, AkbTypes.AKB_ENV);
 162                         AkbUiUtils.refreshParameterizedCommand(menuManager, window,
 163                                         "cmd.instanciateEnv", CreateAkbNode.ID,
 164                                         "Create new environment instance", null, !hasSelection
 165                                                         || isEnv, params);
 166
 167                 } catch (RepositoryException re) {
 168                         throw new AkbException("Error while refreshing context menu", re);
 169                 }
 170         }
 171
 172         /* INNER CLASSES */
 173         class ViewDoubleClickListener implements IDoubleClickListener {
 174                 public void doubleClick(DoubleClickEvent evt) {
 175                         Object obj = ((IStructuredSelection) evt.getSelection())
 176                                         .getFirstElement();
 177                         try {
 178                                 if (obj instanceof ActiveTreeItem) {
 179                                         ActiveTreeItem currItem = (ActiveTreeItem) obj;
 180                                         Node node = currItem.getNode();
 181                                         Node currEnv = currItem.getEnvironment();
 182                                         Map<String, String> params = new HashMap<String, String>();
 183                                         params.put(OpenAkbNodeEditor.PARAM_NODE_JCR_ID,
 184                                                         node.getIdentifier());
 185                                         params.put(OpenAkbNodeEditor.PARAM_CURR_ENV_JCR_ID,
 186                                                         currEnv.getIdentifier());
 187                                         CommandUtils.callCommand(OpenAkbNodeEditor.ID, params);
 188                                 }
 189                         } catch (RepositoryException e) {
 190                                 throw new AkbException("Cannot open " + obj, e);
 191                         }
 192                 }
 193         }
 194
 195         /* DEPENDENCY INJECTION */
 196         public void setRepository(Repository repository) {
 197                 try {
 198                         session = repository.login();
 199                 } catch (RepositoryException e) {
 200                         throw new AkbException("unable to log in for " + ID + " view");
 201                 }
 202         }
 203
 204         public void setAkbService(AkbService akbService) {
 205                 this.akbService = akbService;
 206
 207         }
 208 }