plugins/org.argeo.slc.client.ui.dist/src/main/java/org/argeo/slc/client/ui/dist/editors/BundleRawPage.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.util.ArrayList;
  19 import java.util.List;
  20
  21 import javax.jcr.Node;
  22 import javax.jcr.NodeIterator;
  23 import javax.jcr.Property;
  24 import javax.jcr.PropertyIterator;
  25 import javax.jcr.RepositoryException;
  26 import javax.jcr.Value;
  27 import javax.jcr.nodetype.NodeType;
  28
  29 import org.argeo.ArgeoException;
  30 import org.argeo.slc.client.ui.dist.DistImages;
  31 import org.argeo.slc.client.ui.dist.utils.DistUiHelpers;
  32 import org.argeo.slc.jcr.SlcNames;
  33 import org.argeo.slc.jcr.SlcTypes;
  34 import org.eclipse.jface.viewers.ColumnLabelProvider;
  35 import org.eclipse.jface.viewers.ITreeContentProvider;
  36 import org.eclipse.jface.viewers.TreeViewer;
  37 import org.eclipse.jface.viewers.Viewer;
  38 import org.eclipse.jface.viewers.ViewerCell;
  39 import org.eclipse.swt.SWT;
  40 import org.eclipse.swt.layout.GridData;
  41 import org.eclipse.swt.layout.GridLayout;
  42 import org.eclipse.swt.widgets.Composite;
  43 import org.eclipse.swt.widgets.Tree;
  44 import org.eclipse.swt.widgets.TreeColumn;
  45 import org.eclipse.ui.forms.IManagedForm;
  46 import org.eclipse.ui.forms.editor.FormEditor;
  47 import org.eclipse.ui.forms.editor.FormPage;
  48 import org.eclipse.ui.forms.widgets.ScrolledForm;
  49
  50 /**
  51  * Lists all properties of current bundle as a tree
  52  */
  53
  54 public class BundleRawPage extends FormPage implements SlcNames, SlcTypes {
  55         // private final static Log log =
  56         // LogFactory.getLog(ArtifactDetailsPage.class);
  57
  58         // Main business Objects
  59         private Node currBundle;
  60
  61         // This page widgets
  62         private TreeViewer complexTree;
  63
  64         public BundleRawPage(FormEditor editor, String title, Node currentNode) {
  65                 super(editor, "id", title);
  66                 this.currBundle = currentNode;
  67         }
  68
  69         protected void createFormContent(IManagedForm managedForm) {
  70                 ScrolledForm form = managedForm.getForm();
  71                 GridLayout layout = new GridLayout(1, false);
  72                 layout.marginWidth = 5;
  73                 form.getBody().setLayout(layout);
  74                 createViewer(form.getBody());
  75         }
  76
  77         private void createViewer(Composite parent) {
  78
  79                 // Create the viewer
  80                 int style = SWT.BORDER | SWT.MULTI | SWT.FULL_SELECTION;
  81                 Tree tree = new Tree(parent, style);
  82                 GridData gd = new GridData(GridData.FILL_BOTH);
  83                 gd.grabExcessHorizontalSpace = true;
  84                 gd.grabExcessVerticalSpace = true;
  85                 tree.setLayoutData(gd);
  86                 createColumn(tree, "Attribute", SWT.LEFT, 200);
  87                 createColumn(tree, "Value", SWT.LEFT, 200);
  88                 tree.setLinesVisible(true);
  89                 tree.setHeaderVisible(true);
  90                 complexTree = new TreeViewer(tree);
  91
  92                 // Configure
  93                 // complexTree.addDoubleClickListener(new GenericDoubleClickListener());
  94                 complexTree = new TreeViewer(tree);
  95                 complexTree.setContentProvider(new TreeContentProvider());
  96                 complexTree.setLabelProvider(new TreeLabelProvider());
  97
  98                 // Initialize
  99                 complexTree.setInput(currBundle);
 100                 // result.expandAll();
 101                 complexTree.expandToLevel(2);
 102
 103         }
 104
 105         private static TreeColumn createColumn(Tree parent, String name, int style,
 106                         int width) {
 107                 TreeColumn result = new TreeColumn(parent, style);
 108                 result.setText(name);
 109                 result.setWidth(width);
 110                 result.setMoveable(true);
 111                 result.setResizable(true);
 112                 return result;
 113         }
 114
 115         // View specific object
 116         private class ViewSpecificItems {
 117                 private String key;
 118                 private Object value;
 119                 private boolean isFolder;
 120                 private Node curNode;
 121
 122                 public ViewSpecificItems(String key, Object value, boolean isFolder) {
 123                         this.key = key;
 124                         this.value = value;
 125                         this.isFolder = isFolder;
 126                 }
 127
 128                 public String getKey() {
 129                         return key;
 130                 }
 131
 132                 public void setNode(Node node) {
 133                         this.curNode = node;
 134                 }
 135
 136                 public Node getNode() {
 137                         return curNode;
 138                 }
 139
 140                 public Object getValue() {
 141                         return value;
 142                 }
 143
 144                 public boolean isFolder() {
 145                         return isFolder;
 146                 }
 147
 148         }
 149
 150         // providers
 151         private class TreeLabelProvider extends ColumnLabelProvider implements
 152                         SlcTypes, SlcNames {
 153
 154                 public void update(ViewerCell cell) {
 155                         try {
 156
 157                                 int colIndex = cell.getColumnIndex();
 158                                 Object element = cell.getElement();
 159                                 if (element instanceof Property) {
 160                                         Property prop = (Property) element;
 161                                         if (colIndex == 0)
 162                                                 cell.setText(DistUiHelpers.getLabelJcrName(prop
 163                                                                 .getName()));
 164                                         else if (colIndex == 1)
 165                                                 cell.setText(DistUiHelpers.formatValueAsString(prop
 166                                                                 .getValue()));
 167
 168                                 } else if (element instanceof ViewSpecificItems) {
 169                                         if (colIndex == 0)
 170                                                 cell.setText(((ViewSpecificItems) element).getKey());
 171                                         else if (colIndex == 1)
 172                                                 cell.setText(DistUiHelpers
 173                                                                 .formatAsString(((ViewSpecificItems) element)
 174                                                                                 .getValue()));
 175
 176                                 } else if (element instanceof Node) {
 177                                         Node node = (Node) element;
 178                                         if (colIndex == 0) {
 179                                                 if (node.isNodeType(NodeType.NT_FILE)) {
 180                                                         cell.setImage(DistImages.IMG_FILE);
 181                                                         cell.setText(node.getName());
 182                                                 } else if (node.isNodeType(SLC_IMPORTED_PACKAGE))
 183                                                         cell.setText("Import package");
 184                                                 else if (node.isNodeType(SLC_EXPORTED_PACKAGE))
 185                                                         cell.setText("Export package");
 186
 187                                         } else if (colIndex == 1) {
 188                                                 if (node.isNodeType(SLC_ARTIFACT)) {
 189                                                         StringBuffer sb = new StringBuffer("");
 190                                                         if (node.hasProperty(SLC_ARTIFACT_CLASSIFIER)) {
 191                                                                 sb.append(node.getProperty(
 192                                                                                 SLC_ARTIFACT_CLASSIFIER).getString());
 193                                                                 sb.append(" ");
 194                                                         }
 195                                                         if (node.hasProperty(SLC_ARTIFACT_EXTENSION))
 196                                                                 sb.append(node.getProperty(
 197                                                                                 SLC_ARTIFACT_EXTENSION).getString());
 198                                                         cell.setText(sb.toString());
 199                                                 } else if (node.isNodeType(SLC_IMPORTED_PACKAGE)
 200                                                                 || node.isNodeType(SLC_EXPORTED_PACKAGE))
 201                                                         cell.setText(node.getProperty(SLC_NAME).getString());
 202                                         }
 203                                 }
 204                         } catch (RepositoryException e) {
 205                                 throw new ArgeoException(
 206                                                 "unexpected error while getting artifact information",
 207                                                 e);
 208                         }
 209                 }
 210         }
 211
 212         private class TreeContentProvider implements ITreeContentProvider {
 213                 public Object[] getElements(Object parent) {
 214                         List<Object> elements = new ArrayList<Object>();
 215
 216                         try {
 217                                 Node node = (Node) parent;
 218                                 elements = new ArrayList<Object>();
 219
 220                                 // Maven coordinates
 221                                 elements.add(node.getProperty(SLC_GROUP_ID));
 222                                 elements.add(node.getProperty(SLC_ARTIFACT_ID));
 223                                 elements.add(node.getProperty(SLC_ARTIFACT_VERSION));
 224
 225                                 // Meta information
 226                                 // boolean gotSource = false;
 227                                 // // TODO: implement this check
 228                                 // elements.add(new ViewSpecificItems("Sources available",
 229                                 // gotSource));
 230
 231                                 // Jars
 232                                 NodeIterator ni = node.getNodes();
 233                                 while (ni.hasNext()) {
 234                                         Node child = ni.nextNode();
 235                                         if (child.isNodeType(SLC_ARTIFACT)) {
 236                                                 // we skip sha1 files for the time being.
 237                                                 elements.add(child);
 238                                         }
 239                                 }
 240
 241                                 // Properties
 242                                 PropertyIterator pi = node.getProperties();
 243                                 while (pi.hasNext()) {
 244                                         Property curProp = pi.nextProperty();
 245                                         if (!curProp.getName().startsWith("jcr:")
 246                                                         && !curProp.isMultiple())
 247                                                 elements.add(curProp);
 248                                 }
 249
 250                         } catch (RepositoryException e) {
 251                                 throw new ArgeoException(
 252                                                 "Unexpected exception while listing node properties", e);
 253                         }
 254                         return elements.toArray();
 255                 }
 256
 257                 public Object getParent(Object child) {
 258                         return null;
 259                 }
 260
 261                 public Object[] getChildren(Object parent) {
 262                         Object[] result = null;
 263                         try {
 264                                 if (parent instanceof Property) {
 265                                         Property prop = (Property) parent;
 266                                         if (prop.isMultiple()) {
 267                                                 Value[] values = prop.getValues();
 268                                                 return values;
 269                                         }
 270                                 } else if (parent instanceof Node) {
 271                                         Node node = (Node) parent;
 272                                         if (node.hasNodes()) {
 273                                                 List<Object> elements = new ArrayList<Object>();
 274                                                 PropertyIterator pi = node.getProperties();
 275                                                 while (pi.hasNext()) {
 276                                                         Property curProp = pi.nextProperty();
 277                                                         if (!curProp.getName().startsWith("jcr:")
 278                                                                         && !curProp.isMultiple())
 279                                                                 elements.add(curProp);
 280                                                 }
 281
 282                                                 NodeIterator ni = node.getNodes();
 283                                                 while (ni.hasNext()) {
 284                                                         Node curNode = ni.nextNode();
 285                                                         if (curNode.isNodeType(SLC_IMPORTED_PACKAGE)
 286                                                                         || curNode.isNodeType(SLC_EXPORTED_PACKAGE)) {
 287                                                                 ViewSpecificItems vsi = new ViewSpecificItems(
 288                                                                                 "Bundle dependencies", "", true);
 289                                                                 vsi.setNode(node);
 290                                                                 elements.add(vsi);
 291                                                                 break;
 292                                                         }
 293                                                 }
 294                                                 return elements.toArray();
 295                                         }
 296                                 } else if (parent instanceof ViewSpecificItems
 297                                                 && ((ViewSpecificItems) parent).isFolder()) {
 298                                         NodeIterator ni = ((ViewSpecificItems) parent).getNode()
 299                                                         .getNodes();
 300                                         List<Node> elements = new ArrayList<Node>();
 301                                         while (ni.hasNext()) {
 302                                                 Node curNode = ni.nextNode();
 303                                                 if (curNode.isNodeType(SLC_IMPORTED_PACKAGE)
 304                                                                 || curNode.isNodeType(SLC_EXPORTED_PACKAGE)) {
 305                                                         elements.add(curNode);
 306                                                 }
 307                                         }
 308                                         return elements.toArray();
 309                                 }
 310                         } catch (RepositoryException e) {
 311                                 throw new ArgeoException(
 312                                                 "Unexpected error getting multiple values property.", e);
 313                         }
 314                         return result;
 315                 }
 316
 317                 public boolean hasChildren(Object parent) {
 318                         try {
 319                                 if (parent instanceof Property
 320                                                 && ((Property) parent).isMultiple()) {
 321                                         return true;
 322                                 } else if (parent instanceof Node && ((Node) parent).hasNodes()
 323                                                 && ((Node) parent).isNodeType(SLC_BUNDLE_ARTIFACT)) {
 324                                         return true;
 325                                 } else if (parent instanceof ViewSpecificItems
 326                                                 && ((ViewSpecificItems) parent).isFolder()) {
 327                                         return true;
 328                                 }
 329                         } catch (RepositoryException e) {
 330                                 throw new ArgeoException(
 331                                                 "Unexpected exception while checking if property is multiple",
 332                                                 e);
 333                         }
 334                         return false;
 335                 }
 336
 337                 public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
 338                 }
 339
 340                 public void dispose() {
 341                 }
 342         }
 343 }