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