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 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.client.ui.dist.utils.GenericDoubleClickListener;
  33 import org.argeo.slc.jcr.SlcTypes;
  34 import org.argeo.slc.repo.RepoConstants;
  35 import org.eclipse.jface.viewers.ColumnLabelProvider;
  36 import org.eclipse.jface.viewers.ISelection;
  37 import org.eclipse.jface.viewers.ISelectionChangedListener;
  38 import org.eclipse.jface.viewers.IStructuredSelection;
  39 import org.eclipse.jface.viewers.SelectionChangedEvent;
  40 import org.eclipse.jface.viewers.TreeViewer;
  41 import org.eclipse.jface.viewers.ViewerCell;
  42 import org.eclipse.swt.SWT;
  43 import org.eclipse.swt.graphics.Image;
  44 import org.eclipse.swt.layout.FillLayout;
  45 import org.eclipse.swt.widgets.Composite;
  46 import org.eclipse.swt.widgets.Tree;
  47 import org.eclipse.swt.widgets.TreeColumn;
  48 import org.eclipse.ui.part.ViewPart;
  49
  50 /**
  51  * Basic View to browse a maven based repository.
  52  *
  53  * By Default size of the various bundles is not computed but it can be
  54  * activated the view command.
  55  */
  56
  57 public class ArtifactsBrowser extends ViewPart implements DistConstants,
  58                 RepoConstants {
  59         // private final static Log log = LogFactory.getLog(ArtifactsBrowser.class);
  60         public final static String ID = DistPlugin.ID + ".artifactsBrowser";
  61
  62         /* DEPENDENCY INJECTION */
  63         private Session jcrSession;
  64
  65         // Business objects
  66         private Node rootNode;
  67
  68         // This page widgets
  69         private TreeViewer artifactTreeViewer;
  70         private boolean isSizeVisible = false;
  71
  72         // To be able to configure columns easily
  73         public static final int COLUMN_TREE = 0;
  74         public static final int COLUMN_DATE = 1;
  75         public static final int COLUMN_SIZE = 2;
  76         private static final int SIZE_COL_WIDTH = 55;
  77
  78         @Override
  79         public void createPartControl(Composite parent) {
  80                 // Enable the different parts to fill the whole page when the tab is
  81                 // maximized
  82                 parent.setLayout(new FillLayout());
  83                 artifactTreeViewer = createArtifactsTreeViewer(parent);
  84
  85                 // context menu : it is completely defined in the plugin.xml file.
  86                 // Nothing in the context menu for the time being
  87                 // MenuManager menuManager = new MenuManager();
  88                 // Menu menu =
  89                 // menuManager.createContextMenu(artifactTreeViewer.getTree());
  90                 // artifactTreeViewer.getTree().setMenu(menu);
  91                 // getSite().registerContextMenu(menuManager, artifactTreeViewer);
  92
  93                 getSite().setSelectionProvider(artifactTreeViewer);
  94                 // packagesViewer.setComparer(new NodeViewerComparer());
  95
  96                 // Model initialisation
  97                 if (jcrSession != null) {
  98                         try {
  99                                 rootNode = jcrSession.getNode(DEFAULT_ARTIFACTS_BASE_PATH);
 100                                 artifactTreeViewer.setInput(rootNode);
 101                         } catch (RepositoryException e) {
 102                                 throw new ArgeoException("Cannot load base artifact nodes", e);
 103                         }
 104                 }
 105         }
 106
 107         protected TreeViewer createArtifactsTreeViewer(Composite parent) {
 108                 int style = SWT.BORDER | SWT.MULTI | SWT.FULL_SELECTION;
 109                 Tree tree = new Tree(parent, style);
 110                 createColumn(tree, "Artifacts", SWT.LEFT, 300);
 111                 createColumn(tree, "Date created", SWT.LEFT, 105);
 112                 createColumn(tree, "Size", SWT.RIGHT, 0);
 113                 tree.setLinesVisible(true);
 114                 tree.setHeaderVisible(true);
 115
 116                 TreeViewer viewer = new TreeViewer(tree);
 117
 118                 viewer.setContentProvider(new ArtifactsTreeContentProvider());
 119                 viewer.setLabelProvider(new ArtifactLabelProvider());
 120                 viewer.addSelectionChangedListener(new ArtifactTreeSelectionListener());
 121                 viewer.addDoubleClickListener(new GenericDoubleClickListener());
 122                 viewer.setInput(rootNode);
 123
 124                 return viewer;
 125         }
 126
 127         private static TreeColumn createColumn(Tree parent, String name, int style,
 128                         int width) {
 129                 TreeColumn result = new TreeColumn(parent, style);
 130                 result.setText(name);
 131                 result.setWidth(width);
 132                 result.setMoveable(true);
 133                 result.setResizable(true);
 134                 return result;
 135         }
 136
 137         protected TreeViewer getArtifactTreeViewer() {
 138                 return artifactTreeViewer;
 139         }
 140
 141         @Override
 142         public void setFocus() {
 143                 // TODO Auto-generated method stub
 144
 145         }
 146
 147         /**
 148          * Refresh the given element of the tree browser. If null is passed as a
 149          * parameter, it refreshes the whole tree
 150          */
 151         public void refresh(Object element) {
 152                 if (element == null) {
 153                         artifactTreeViewer.refresh(rootNode);
 154                 } else
 155                         artifactTreeViewer.refresh(element);
 156         }
 157
 158         /** Returns wether size column is visible or not */
 159         public boolean isSizeVisible() {
 160                 return isSizeVisible;
 161         }
 162
 163         /** Sets the visibility of the size column */
 164         public void setSizeVisible(boolean visible) {
 165                 if (isSizeVisible == visible)
 166                         return; // nothing has changed
 167                 else
 168                         isSizeVisible = visible;
 169
 170                 if (visible) {
 171                         artifactTreeViewer.getTree().getColumn(COLUMN_SIZE)
 172                                         .setWidth(SIZE_COL_WIDTH);
 173                 } else {
 174                         // we just hide the column, we don't refresh the whole tree.
 175                         artifactTreeViewer.getTree().getColumn(COLUMN_SIZE).setWidth(0);
 176                 }
 177         }
 178
 179         private class ArtifactLabelProvider extends ColumnLabelProvider implements
 180                         DistConstants, SlcTypes {
 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 }