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