DistributionsView.java

   1 /*
   2  * Copyright (C) 2007-2012 Argeo GmbH
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *         http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package org.argeo.slc.client.ui.dist.views;
  17
  18 import java.util.HashMap;
  19 import java.util.Map;
  20
  21 import javax.jcr.Repository;
  22 import javax.jcr.RepositoryException;
  23
  24 import org.argeo.eclipse.ui.TreeParent;
  25 import org.argeo.eclipse.ui.utils.CommandUtils;
  26 import org.argeo.jcr.ArgeoNames;
  27 import org.argeo.slc.SlcException;
  28 import org.argeo.slc.client.ui.dist.DistPlugin;
  29 import org.argeo.slc.client.ui.dist.commands.CopyLocalJavaWorkspace;
  30 import org.argeo.slc.client.ui.dist.commands.CopyWorkspace;
  31 import org.argeo.slc.client.ui.dist.commands.CreateLocalJavaWorkspace;
  32 import org.argeo.slc.client.ui.dist.commands.CreateWorkspace;
  33 import org.argeo.slc.client.ui.dist.commands.DeleteWorkspace;
  34 import org.argeo.slc.client.ui.dist.commands.DisplayRepoInformation;
  35 import org.argeo.slc.client.ui.dist.commands.Fetch;
  36 import org.argeo.slc.client.ui.dist.commands.NormalizeDistribution;
  37 import org.argeo.slc.client.ui.dist.commands.NormalizeWorkspace;
  38 import org.argeo.slc.client.ui.dist.commands.OpenGenerateBinariesWizard;
  39 import org.argeo.slc.client.ui.dist.commands.PublishWorkspace;
  40 import org.argeo.slc.client.ui.dist.commands.RegisterRepository;
  41 import org.argeo.slc.client.ui.dist.commands.RunInOsgi;
  42 import org.argeo.slc.client.ui.dist.commands.UnregisterRemoteRepo;
  43 import org.argeo.slc.client.ui.dist.controllers.DistTreeComparator;
  44 import org.argeo.slc.client.ui.dist.controllers.DistTreeComparer;
  45 import org.argeo.slc.client.ui.dist.controllers.DistTreeContentProvider;
  46 import org.argeo.slc.client.ui.dist.controllers.DistTreeDoubleClickListener;
  47 import org.argeo.slc.client.ui.dist.controllers.DistTreeLabelProvider;
  48 import org.argeo.slc.client.ui.dist.model.DistParentElem;
  49 import org.argeo.slc.client.ui.dist.model.ModularDistBaseElem;
  50 import org.argeo.slc.client.ui.dist.model.RepoElem;
  51 import org.argeo.slc.client.ui.dist.model.WkspGroupElem;
  52 import org.argeo.slc.client.ui.dist.model.WorkspaceElem;
  53 import org.argeo.slc.jcr.SlcNames;
  54 import org.eclipse.jface.action.IContributionItem;
  55 import org.eclipse.jface.action.IMenuListener;
  56 import org.eclipse.jface.action.IMenuManager;
  57 import org.eclipse.jface.action.MenuManager;
  58 import org.eclipse.jface.viewers.IStructuredSelection;
  59 import org.eclipse.jface.viewers.TreeViewer;
  60 import org.eclipse.jface.viewers.TreeViewerColumn;
  61 import org.eclipse.jface.viewers.ViewerComparator;
  62 import org.eclipse.swt.SWT;
  63 import org.eclipse.swt.widgets.Composite;
  64 import org.eclipse.swt.widgets.Menu;
  65 import org.eclipse.swt.widgets.Tree;
  66 import org.eclipse.ui.IWorkbenchWindow;
  67 import org.eclipse.ui.part.ViewPart;
  68
  69 /**
  70  * Browse, manipulate and manage distributions across multiple repositories
  71  * (like fetch, merge, publish, etc.).
  72  */
  73 public class DistributionsView extends ViewPart implements SlcNames, ArgeoNames {
  74         // private final static Log log =
  75         // LogFactory.getLog(DistributionsView.class);
  76
  77         public final static String ID = DistPlugin.ID + ".distributionsView";
  78
  79         /* DEPENDENCY INJECTION */
  80         private Repository nodeRepository;
  81         private DistTreeContentProvider treeContentProvider;
  82
  83         private TreeViewer viewer;
  84
  85         @Override
  86         public void createPartControl(Composite parent) {
  87                 // Define the TableViewer
  88                 viewer = new TreeViewer(parent, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL
  89                                 | SWT.FULL_SELECTION | SWT.BORDER);
  90
  91                 TreeViewerColumn col = new TreeViewerColumn(viewer, SWT.NONE);
  92                 col.getColumn().setWidth(400);
  93                 col.setLabelProvider(new DistTreeLabelProvider());
  94
  95                 final Tree tree = viewer.getTree();
  96                 tree.setHeaderVisible(false);
  97                 tree.setLinesVisible(false);
  98
  99                 // viewer.setContentProvider(new DistTreeContentProvider());
 100                 viewer.setContentProvider(treeContentProvider);
 101                 viewer.addDoubleClickListener(new DistTreeDoubleClickListener(viewer));
 102                 viewer.setComparer(new DistTreeComparer());
 103
 104                 viewer.setComparator(new DistTreeComparator());
 105
 106                 @SuppressWarnings("unused")
 107                 ViewerComparator vc = viewer.getComparator();
 108
 109                 // Enable retrieving current tree selected items from outside the view
 110                 getSite().setSelectionProvider(viewer);
 111
 112                 MenuManager menuManager = new MenuManager();
 113                 Menu menu = menuManager.createContextMenu(viewer.getTree());
 114                 menuManager.addMenuListener(new IMenuListener() {
 115                         public void menuAboutToShow(IMenuManager manager) {
 116                                 contextMenuAboutToShow(manager);
 117                         }
 118                 });
 119                 viewer.getTree().setMenu(menu);
 120                 getSite().registerContextMenu(menuManager, viewer);
 121
 122                 // Initialize
 123                 refresh();
 124         }
 125
 126         /** Programatically configure the context menu */
 127         protected void contextMenuAboutToShow(IMenuManager menuManager) {
 128                 IWorkbenchWindow window = DistPlugin.getDefault().getWorkbench()
 129                                 .getActiveWorkbenchWindow();
 130
 131                 try {
 132                         // Most of the implemented commands support only one selected
 133                         // element
 134                         boolean singleElement = ((IStructuredSelection) viewer
 135                                         .getSelection()).size() == 1;
 136                         // Get Current selected item :
 137                         Object firstElement = ((IStructuredSelection) viewer.getSelection())
 138                                         .getFirstElement();
 139
 140                         if (firstElement instanceof TreeParent
 141                                         || firstElement instanceof DistParentElem) {
 142
 143                                 String targetRepoPath = null, workspaceName = null, workspacePrefix = null;
 144                                 // String targetRepoUri = null;
 145                                 // Build conditions depending on element type
 146                                 boolean isDistribElem = false, isModularDistBaseElem = false, isRepoElem = false, isDistribGroupElem = false;
 147                                 boolean isLocal = false, isReadOnly = true;
 148
 149                                 RepoElem re = null;
 150
 151                                 if (firstElement instanceof WorkspaceElem) {
 152                                         WorkspaceElem de = (WorkspaceElem) firstElement;
 153                                         re = (RepoElem) de.getParent().getParent();
 154                                         isDistribElem = true;
 155                                         isReadOnly = de.isReadOnly();
 156                                         workspaceName = de.getWorkspaceName();
 157                                         isLocal = de.inHome();
 158                                 } else if (firstElement instanceof RepoElem) {
 159                                         re = (RepoElem) firstElement;
 160                                         isRepoElem = true;
 161                                         isLocal = re.inHome();
 162                                         isReadOnly = re.isReadOnly();
 163                                 } else if (firstElement instanceof ModularDistBaseElem) {
 164                                         ModularDistBaseElem mdbe = (ModularDistBaseElem) firstElement;
 165                                         re = (RepoElem) mdbe.getParent().getParent().getParent();
 166                                         isModularDistBaseElem = true;
 167                                         isLocal = re.inHome();
 168                                         isReadOnly = re.isReadOnly();
 169                                 } else if (firstElement instanceof WkspGroupElem) {
 170                                         WkspGroupElem wge = (WkspGroupElem) firstElement;
 171                                         isReadOnly = wge.isReadOnly();
 172                                         isDistribGroupElem = true;
 173                                         re = (RepoElem) wge.getParent();
 174                                         workspacePrefix = wge.getName();
 175                                 }
 176
 177                                 // TODO add case for goups
 178
 179                                 if (re != null) {
 180                                         // targetRepoUri = re.getUri();
 181                                         targetRepoPath = re.getRepoNode().getPath();
 182                                 }
 183
 184                                 // Display repo info
 185                                 CommandUtils.refreshCommand(menuManager, window,
 186                                                 DisplayRepoInformation.ID,
 187                                                 DisplayRepoInformation.DEFAULT_LABEL,
 188                                                 DisplayRepoInformation.DEFAULT_ICON, isRepoElem
 189                                                                 && singleElement);
 190
 191                                 // create workspace
 192                                 Map<String, String> params = new HashMap<String, String>();
 193                                 params.put(CreateWorkspace.PARAM_TARGET_REPO_PATH,
 194                                                 targetRepoPath);
 195                                 params.put(CreateWorkspace.PARAM_WORKSPACE_PREFIX,
 196                                                 workspacePrefix);
 197                                 CommandUtils.refreshParametrizedCommand(menuManager, window,
 198                                                 CreateWorkspace.ID, CreateWorkspace.DEFAULT_LABEL,
 199                                                 CreateWorkspace.DEFAULT_ICON,
 200                                                 (isRepoElem || isDistribGroupElem) && singleElement
 201                                                                 && !isReadOnly  && !isLocal, params);
 202
 203                                 // TODO Manage the case where it is not a java workspace
 204                                 params = new HashMap<String, String>();
 205                                 params.put(CreateLocalJavaWorkspace.PARAM_WORKSPACE_PREFIX,
 206                                                 workspacePrefix);
 207                                 CommandUtils.refreshParametrizedCommand(menuManager, window,
 208                                                 CreateLocalJavaWorkspace.ID, CreateLocalJavaWorkspace.DEFAULT_LABEL,
 209                                                 CreateLocalJavaWorkspace.DEFAULT_ICON,
 210                                                 (isRepoElem || isDistribGroupElem) && singleElement
 211                                                                 && !isReadOnly && isLocal, params);
 212
 213                                 // Register a remote repository
 214                                 CommandUtils.refreshCommand(menuManager, window,
 215                                                 RegisterRepository.ID,
 216                                                 RegisterRepository.DEFAULT_LABEL,
 217                                                 RegisterRepository.DEFAULT_ICON, isRepoElem
 218                                                                 && singleElement);
 219
 220                                 // Unregister a remote repository
 221                                 params = new HashMap<String, String>();
 222                                 params.put(UnregisterRemoteRepo.PARAM_REPO_PATH, targetRepoPath);
 223                                 CommandUtils.refreshParametrizedCommand(menuManager, window,
 224                                                 UnregisterRemoteRepo.ID,
 225                                                 UnregisterRemoteRepo.DEFAULT_LABEL,
 226                                                 UnregisterRemoteRepo.DEFAULT_ICON, isRepoElem
 227                                                                 && !isLocal && singleElement, params);
 228
 229                                 // Fetch repository
 230                                 params = new HashMap<String, String>();
 231                                 params.put(Fetch.PARAM_TARGET_REPO_PATH, targetRepoPath);
 232                                 CommandUtils.refreshParametrizedCommand(menuManager, window,
 233                                                 Fetch.ID, Fetch.DEFAULT_LABEL, Fetch.DEFAULT_ICON,
 234                                                 isRepoElem && isLocal && singleElement && !isReadOnly,
 235                                                 params);
 236
 237                                 // Normalize workspace
 238                                 params = new HashMap<String, String>();
 239                                 params.put(NormalizeWorkspace.PARAM_TARGET_REPO_PATH,
 240                                                 targetRepoPath);
 241                                 params.put(NormalizeWorkspace.PARAM_WORKSPACE_NAME,
 242                                                 workspaceName);
 243
 244                                 CommandUtils.refreshParametrizedCommand(menuManager, window,
 245                                                 NormalizeWorkspace.ID, "Normalize...",
 246                                                 NormalizeWorkspace.DEFAULT_ICON, isDistribElem
 247                                                                 && singleElement && !isReadOnly, params);
 248
 249                                 // Copy workspace
 250                                 params = new HashMap<String, String>();
 251                                 params.put(CopyWorkspace.PARAM_TARGET_REPO_PATH, targetRepoPath);
 252                                 params.put(CopyWorkspace.PARAM_SOURCE_WORKSPACE_NAME,
 253                                                 workspaceName);
 254                                 CommandUtils.refreshParametrizedCommand(menuManager, window,
 255                                                 CopyWorkspace.ID, CopyWorkspace.DEFAULT_LABEL,
 256                                                 CopyWorkspace.DEFAULT_ICON, isDistribElem
 257                                                                 && singleElement && !isLocal, params);
 258
 259                                 params = new HashMap<String, String>();
 260                                 params.put(CopyLocalJavaWorkspace.PARAM_SOURCE_WORKSPACE_NAME,
 261                                                 workspaceName);
 262                                 CommandUtils.refreshParametrizedCommand(menuManager, window,
 263                                                 CopyLocalJavaWorkspace.ID, CopyLocalJavaWorkspace.DEFAULT_LABEL,
 264                                                 CopyLocalJavaWorkspace.DEFAULT_ICON, isDistribElem
 265                                                                 && singleElement&& isLocal, params);
 266
 267                                 // Clear Workspace
 268                                 params = new HashMap<String, String>();
 269                                 params.put(DeleteWorkspace.PARAM_TARGET_REPO_PATH,
 270                                                 targetRepoPath);
 271                                 params.put(DeleteWorkspace.PARAM_WORKSPACE_NAME, workspaceName);
 272                                 CommandUtils.refreshParametrizedCommand(menuManager, window,
 273                                                 DeleteWorkspace.ID, DeleteWorkspace.DEFAULT_LABEL,
 274                                                 DeleteWorkspace.DEFAULT_ICON, isDistribElem
 275                                                                 && singleElement && !isReadOnly, params);
 276
 277                                 // Advanced submenu
 278                                 MenuManager submenu = new MenuManager("Advanced", DistPlugin.ID
 279                                                 + ".advancedSubmenu");
 280                                 IContributionItem ici = menuManager.find(DistPlugin.ID
 281                                                 + ".advancedSubmenu");
 282                                 if (ici != null)
 283                                         menuManager.remove(ici);
 284
 285                                 // Publish workspace
 286                                 params = new HashMap<String, String>();
 287                                 params.put(PublishWorkspace.PARAM_TARGET_REPO_PATH,
 288                                                 targetRepoPath);
 289                                 params.put(PublishWorkspace.PARAM_WORKSPACE_NAME, workspaceName);
 290                                 CommandUtils.refreshParametrizedCommand(submenu, window,
 291                                                 PublishWorkspace.ID, PublishWorkspace.DEFAULT_LABEL,
 292                                                 PublishWorkspace.DEFAULT_ICON, isDistribElem
 293                                                                 && singleElement && !isReadOnly, params);
 294
 295                                 // Normalize distribution (Legacy)
 296                                 params = new HashMap<String, String>();
 297                                 params.put(NormalizeDistribution.PARAM_TARGET_REPO_PATH,
 298                                                 targetRepoPath);
 299                                 params.put(NormalizeDistribution.PARAM_WORKSPACE_NAME,
 300                                                 workspaceName);
 301                                 CommandUtils.refreshParametrizedCommand(submenu, window,
 302                                                 NormalizeDistribution.ID,
 303                                                 NormalizeDistribution.DEFAULT_LABEL,
 304                                                 NormalizeDistribution.DEFAULT_ICON, isDistribElem
 305                                                                 && singleElement && !isReadOnly, params);
 306
 307                                 // Run in OSGi
 308                                 params = new HashMap<String, String>();
 309                                 params.put(RunInOsgi.PARAM_WORKSPACE_NAME, workspaceName);
 310                                 CommandUtils.refreshParametrizedCommand(submenu, window,
 311                                                 RunInOsgi.ID, RunInOsgi.DEFAULT_LABEL,
 312                                                 RunInOsgi.DEFAULT_ICON, isDistribElem && singleElement
 313                                                                 && isLocal, params);// Run in OSGi
 314
 315                                 CommandUtils.refreshCommand(submenu, window,
 316                                                 OpenGenerateBinariesWizard.ID,
 317                                                 OpenGenerateBinariesWizard.DEFAULT_LABEL,
 318                                                 OpenGenerateBinariesWizard.DEFAULT_ICON,
 319                                                 isModularDistBaseElem && !isReadOnly);
 320
 321                                 if (submenu.getSize() > 0)
 322                                         menuManager.add(submenu);
 323
 324                                 // // Manage workspace authorizations
 325                                 // params = new HashMap<String, String>();
 326                                 // params.put(ManageWorkspaceAuth.PARAM_WORKSPACE_NAME, wsName);
 327                                 // CommandHelpers.refreshParameterizedCommand(menuManager,
 328                                 // window,
 329                                 // ManageWorkspaceAuth.ID, ManageWorkspaceAuth.DEFAULT_LABEL,
 330                                 // ManageWorkspaceAuth.DEFAULT_ICON_PATH, isDistribElem
 331                                 // && singleElement && !isReadOnly, params);
 332                         }
 333                 } catch (RepositoryException e) {
 334                         throw new SlcException("unexpected errror while "
 335                                         + "building context menu", e);
 336                 }
 337         }
 338
 339         @Override
 340         public void setFocus() {
 341                 viewer.getTree().setFocus();
 342         }
 343
 344         /**
 345          * Force refresh of the whole view
 346          */
 347         public void refresh() {
 348                 viewer.setInput(nodeRepository);
 349                 viewer.expandToLevel(2);
 350         }
 351
 352         /*
 353          * DEPENDENCY INJECTION
 354          */
 355         public void setNodeRepository(Repository repository) {
 356                 this.nodeRepository = repository;
 357         }
 358
 359         public void setTreeContentProvider(
 360                         DistTreeContentProvider treeContentProvider) {
 361                 this.treeContentProvider = treeContentProvider;
 362         }
 363 }