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