eclipse/plugins/org.argeo.slc.client.ui.dist/src/main/java/org/argeo/slc/client/ui/dist/views/ArtifactsBrowser.java

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