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