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