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