eclipse/plugins/org.argeo.slc.client.ui.dist/src/main/java/org/argeo/slc/client/ui/dist/editors/ArtifactDetailsPage.java

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