plugins/org.argeo.slc.client.ui.dist/src/main/java/org/argeo/slc/client/ui/dist/editors/ArtifactsBrowserPage.java

   1 /*
   2  * Copyright (C) 2007-2012 Mathieu Baudier
   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.editors;
  17
  18 import java.text.DateFormat;
  19 import java.text.SimpleDateFormat;
  20
  21 import javax.jcr.Node;
  22 import javax.jcr.Property;
  23 import javax.jcr.PropertyType;
  24 import javax.jcr.RepositoryException;
  25 import javax.jcr.Session;
  26 import javax.jcr.Value;
  27
  28 import org.apache.commons.logging.Log;
  29 import org.apache.commons.logging.LogFactory;
  30 import org.argeo.ArgeoException;
  31 import org.argeo.jcr.JcrUtils;
  32 import org.argeo.slc.client.ui.dist.DistConstants;
  33 import org.argeo.slc.client.ui.dist.DistImages;
  34 import org.argeo.slc.client.ui.dist.providers.ArtifactsTreeContentProvider;
  35 import org.argeo.slc.client.ui.dist.utils.GenericDoubleClickListener;
  36 import org.argeo.slc.jcr.SlcTypes;
  37 import org.argeo.slc.repo.RepoConstants;
  38 import org.eclipse.jface.viewers.ColumnLabelProvider;
  39 import org.eclipse.jface.viewers.ISelection;
  40 import org.eclipse.jface.viewers.ISelectionChangedListener;
  41 import org.eclipse.jface.viewers.IStructuredSelection;
  42 import org.eclipse.jface.viewers.SelectionChangedEvent;
  43 import org.eclipse.jface.viewers.TreeViewer;
  44 import org.eclipse.jface.viewers.ViewerCell;
  45 import org.eclipse.swt.SWT;
  46 import org.eclipse.swt.graphics.Image;
  47 import org.eclipse.swt.layout.FillLayout;
  48 import org.eclipse.swt.widgets.Composite;
  49 import org.eclipse.swt.widgets.Tree;
  50 import org.eclipse.swt.widgets.TreeColumn;
  51 import org.eclipse.ui.forms.IManagedForm;
  52 import org.eclipse.ui.forms.editor.FormEditor;
  53 import org.eclipse.ui.forms.editor.FormPage;
  54 import org.eclipse.ui.forms.widgets.ScrolledForm;
  55
  56 /**
  57  * Basic View to browse a maven based repository.
  58  *
  59  * By Default size of the various bundles is not computed but it can be
  60  * activated the view command.
  61  */
  62 public class ArtifactsBrowserPage extends FormPage implements DistConstants,
  63                 RepoConstants {
  64         final static String PAGE_ID = "artifactsBrowserPage";
  65         private final static Log log = LogFactory
  66                         .getLog(ArtifactsBrowserPage.class);
  67
  68         /* DEPENDENCY INJECTION */
  69         private Session jcrSession;
  70
  71         // Business objects
  72         private Node rootNode;
  73
  74         // This page widgets
  75         private TreeViewer artifactTreeViewer;
  76         private boolean isSizeVisible = false;
  77
  78         // To be able to configure columns easily
  79         public static final int COLUMN_TREE = 0;
  80         public static final int COLUMN_DATE = 1;
  81         public static final int COLUMN_SIZE = 2;
  82         private static final int SIZE_COL_WIDTH = 55;
  83
  84         public ArtifactsBrowserPage(FormEditor editor, String title, Session session) {
  85                 super(editor, PAGE_ID, title);
  86                 this.jcrSession = session;
  87         }
  88
  89         @Override
  90         protected void createFormContent(IManagedForm managedForm) {
  91                 ScrolledForm form = managedForm.getForm();
  92                 Composite parent = form.getBody();
  93                 // Enable the different parts to fill the whole page when the tab is
  94                 // maximized
  95                 parent.setLayout(new FillLayout());
  96                 artifactTreeViewer = createArtifactsTreeViewer(parent);
  97
  98                 // context menu : it is completely defined in the plugin.xml file.
  99                 // Nothing in the context menu for the time being
 100                 // MenuManager menuManager = new MenuManager();
 101                 // Menu menu =
 102                 // menuManager.createContextMenu(artifactTreeViewer.getTree());
 103                 // artifactTreeViewer.getTree().setMenu(menu);
 104                 // getSite().registerContextMenu(menuManager, artifactTreeViewer);
 105
 106                 getEditor().getSite().setSelectionProvider(artifactTreeViewer);
 107
 108                 // packagesViewer.setComparer(new NodeViewerComparer());
 109
 110                 // Model initialisation
 111                 if (jcrSession != null) {
 112                         try {
 113                                 DistributionEditorInput dei = (DistributionEditorInput) getEditorInput();
 114                                 if (dei.getArtifactsBase().equals(DEFAULT_ARTIFACTS_BASE_PATH)) {
 115                                         rootNode = jcrSession.getRootNode();
 116                                 } else {
 117                                         rootNode = jcrSession.getNode(dei.getArtifactsBase());
 118                                 }
 119                                 artifactTreeViewer.setInput(rootNode);
 120                         } catch (RepositoryException e) {
 121                                 throw new ArgeoException("Cannot load base artifact nodes", e);
 122                         }
 123                 }
 124         }
 125
 126         protected TreeViewer createArtifactsTreeViewer(Composite parent) {
 127                 int style = SWT.BORDER | SWT.MULTI | SWT.FULL_SELECTION;
 128                 Tree tree = new Tree(parent, style);
 129                 createColumn(tree, "Artifacts", SWT.LEFT, 300);
 130                 createColumn(tree, "Date created", SWT.LEFT, 105);
 131                 createColumn(tree, "Size", SWT.RIGHT, 0);
 132                 tree.setLinesVisible(true);
 133                 tree.setHeaderVisible(true);
 134
 135                 TreeViewer viewer = new TreeViewer(tree);
 136
 137                 viewer.setContentProvider(new ArtifactsTreeContentProvider());
 138                 viewer.setLabelProvider(new ArtifactLabelProvider());
 139                 viewer.addSelectionChangedListener(new ArtifactTreeSelectionListener());
 140                 viewer.addDoubleClickListener(new GenericDoubleClickListener(viewer));
 141                 viewer.setInput(rootNode);
 142
 143                 return viewer;
 144         }
 145
 146         private static TreeColumn createColumn(Tree parent, String name, int style,
 147                         int width) {
 148                 TreeColumn result = new TreeColumn(parent, style);
 149                 result.setText(name);
 150                 result.setWidth(width);
 151                 result.setMoveable(true);
 152                 result.setResizable(true);
 153                 return result;
 154         }
 155
 156         protected TreeViewer getArtifactTreeViewer() {
 157                 return artifactTreeViewer;
 158         }
 159
 160         /**
 161          * Refresh the given element of the tree browser. If null is passed as a
 162          * parameter, it refreshes the whole tree
 163          */
 164         public void refresh(Object element) {
 165                 if (element == null) {
 166                         artifactTreeViewer.refresh(rootNode);
 167                 } else
 168                         artifactTreeViewer.refresh(element);
 169         }
 170
 171         /** Returns wether size column is visible or not */
 172         public boolean isSizeVisible() {
 173                 return isSizeVisible;
 174         }
 175
 176         /** Sets the visibility of the size column */
 177         public void setSizeVisible(boolean visible) {
 178                 if (isSizeVisible == visible)
 179                         return; // nothing has changed
 180                 else
 181                         isSizeVisible = visible;
 182
 183                 if (visible) {
 184                         artifactTreeViewer.getTree().getColumn(COLUMN_SIZE)
 185                                         .setWidth(SIZE_COL_WIDTH);
 186                 } else {
 187                         // we just hide the column, we don't refresh the whole tree.
 188                         artifactTreeViewer.getTree().getColumn(COLUMN_SIZE).setWidth(0);
 189                 }
 190         }
 191
 192         private class ArtifactLabelProvider extends ColumnLabelProvider implements
 193                         DistConstants, SlcTypes {
 194
 195                 // Utils
 196                 protected DateFormat timeFormatter = new SimpleDateFormat(
 197                                 DATE_TIME_FORMAT);
 198
 199                 public void update(ViewerCell cell) {
 200                         int colIndex = cell.getColumnIndex();
 201                         Object element = cell.getElement();
 202                         cell.setText(getColumnText(element, colIndex));
 203
 204                         if (element instanceof Node && colIndex == 0) {
 205                                 Node node = (Node) element;
 206                                 try {
 207                                         if (node.isNodeType(SLC_ARTIFACT_BASE))
 208                                                 cell.setImage(DistImages.IMG_ARTIFACT_BASE);
 209                                         else if (node.isNodeType(SLC_ARTIFACT_VERSION_BASE))
 210                                                 cell.setImage(DistImages.IMG_ARTIFACT_VERSION_BASE);
 211                                 } catch (RepositoryException e) {
 212                                         // Silent
 213                                 }
 214                         }
 215                 }
 216
 217                 @Override
 218                 public Image getImage(Object element) {
 219
 220                         if (element instanceof Node) {
 221                                 Node node = (Node) element;
 222                                 try {
 223                                         if (node.isNodeType(SLC_ARTIFACT_BASE)) {
 224                                                 return DistImages.IMG_ARTIFACT_BASE;
 225                                         } else if (node.isNodeType(SLC_ARTIFACT_VERSION_BASE)) {
 226                                                 return DistImages.IMG_ARTIFACT_VERSION_BASE;
 227                                         }
 228                                 } catch (RepositoryException e) {
 229                                         // Silent
 230                                 }
 231                         }
 232                         return null;
 233                 }
 234
 235                 public String getColumnText(Object element, int columnIndex) {
 236                         try {
 237                                 if (element instanceof Node) {
 238                                         Node node = (Node) element;
 239                                         switch (columnIndex) {
 240                                         case COLUMN_TREE:
 241                                                 return node.getName();
 242                                         case COLUMN_SIZE:
 243                                                 if (isSizeVisible) {
 244                                                         long size = JcrUtils.getNodeApproxSize(node) / 1024;
 245                                                         if (size > 1024)
 246                                                                 return size / 1024 + " MB";
 247                                                         else
 248                                                                 return size + " KB";
 249                                                 } else
 250                                                         return "";
 251                                         case COLUMN_DATE:
 252                                                 if (node.hasProperty(Property.JCR_CREATED))
 253                                                         return timeFormatter.format(node
 254                                                                         .getProperty(Property.JCR_CREATED)
 255                                                                         .getDate().getTime());
 256                                                 else
 257                                                         return null;
 258                                         }
 259                                 }
 260                         } catch (RepositoryException re) {
 261                                 throw new ArgeoException(
 262                                                 "Unexepected error while getting property values", re);
 263                         }
 264                         return null;
 265                 }
 266
 267                 private String formatValueAsString(Value value) {
 268                         // TODO enhance this method
 269                         try {
 270                                 String strValue;
 271
 272                                 if (value.getType() == PropertyType.BINARY)
 273                                         strValue = "<binary>";
 274                                 else if (value.getType() == PropertyType.DATE)
 275                                         strValue = timeFormatter.format(value.getDate().getTime());
 276                                 else
 277                                         strValue = value.getString();
 278                                 return strValue;
 279                         } catch (RepositoryException e) {
 280                                 throw new ArgeoException(
 281                                                 "unexpected error while formatting value", e);
 282                         }
 283                 }
 284         }
 285
 286         private class ArtifactTreeSelectionListener implements
 287                         ISelectionChangedListener {
 288
 289                 public void selectionChanged(SelectionChangedEvent event) {
 290                         ISelection selection = event.getSelection();
 291                         if (selection != null && selection instanceof IStructuredSelection) {
 292                                 IStructuredSelection iss = (IStructuredSelection) selection;
 293                                 if (iss.size() == 1) {
 294                                         artifactTreeViewer.refresh(iss.getFirstElement());
 295                                 }
 296                         }
 297
 298                 }
 299
 300         }
 301 }