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