org.argeo.slc.client.ui.dist/src/org/argeo/slc/client/ui/dist/editors/BundleDependencyPage.java

   1 package org.argeo.slc.client.ui.dist.editors;
   2
   3 import java.util.List;
   4
   5 import javax.jcr.Node;
   6 import javax.jcr.NodeIterator;
   7 import javax.jcr.RepositoryException;
   8
   9 import org.argeo.eclipse.ui.dialogs.ErrorFeedback;
  10 import org.argeo.jcr.JcrUtils;
  11 import org.argeo.slc.SlcException;
  12 import org.argeo.slc.SlcNames;
  13 import org.argeo.slc.SlcTypes;
  14 import org.argeo.slc.client.ui.dist.DistConstants;
  15 import org.argeo.slc.client.ui.dist.DistImages;
  16 import org.eclipse.jface.viewers.ColumnLabelProvider;
  17 import org.eclipse.jface.viewers.IStructuredContentProvider;
  18 import org.eclipse.jface.viewers.ITreeContentProvider;
  19 import org.eclipse.jface.viewers.TableViewer;
  20 import org.eclipse.jface.viewers.TableViewerColumn;
  21 import org.eclipse.jface.viewers.TreeViewer;
  22 import org.eclipse.jface.viewers.TreeViewerColumn;
  23 import org.eclipse.jface.viewers.Viewer;
  24 import org.eclipse.swt.SWT;
  25 import org.eclipse.swt.graphics.Image;
  26 import org.eclipse.swt.layout.GridData;
  27 import org.eclipse.swt.layout.GridLayout;
  28 import org.eclipse.swt.widgets.Composite;
  29 import org.eclipse.swt.widgets.Table;
  30 import org.eclipse.swt.widgets.Tree;
  31 import org.eclipse.ui.forms.IManagedForm;
  32 import org.eclipse.ui.forms.editor.FormEditor;
  33 import org.eclipse.ui.forms.editor.FormPage;
  34 import org.eclipse.ui.forms.widgets.FormToolkit;
  35 import org.eclipse.ui.forms.widgets.ScrolledForm;
  36 import org.eclipse.ui.forms.widgets.Section;
  37
  38 /**
  39  * Present main information of a given OSGI bundle
  40  */
  41 public class BundleDependencyPage extends FormPage implements SlcNames {
  42         // private final static Log log =
  43         // LogFactory.getLog(ArtifactDetailsPage.class);
  44
  45         // Main business Objects
  46         private Node currBundle;
  47
  48         // This page widgets
  49         private FormToolkit toolkit;
  50
  51         public BundleDependencyPage(FormEditor editor, String title,
  52                         Node currentNode) {
  53                 super(editor, "id", title);
  54                 this.currBundle = currentNode;
  55         }
  56
  57         protected void createFormContent(IManagedForm managedForm) {
  58                 ScrolledForm form = managedForm.getForm();
  59                 toolkit = managedForm.getToolkit();
  60                 try {
  61                         if (currBundle.hasProperty(DistConstants.SLC_BUNDLE_NAME))
  62                                 form.setText(currBundle.getProperty(
  63                                                 DistConstants.SLC_BUNDLE_NAME).getString());
  64                         Composite body = form.getBody();
  65                         GridLayout layout = new GridLayout(1, false);
  66                         layout.horizontalSpacing = layout.marginWidth = 0;
  67                         layout.verticalSpacing = layout.marginHeight = 0;
  68                         body.setLayout(layout);
  69
  70                         Composite part = toolkit.createComposite(body);
  71                         createExportPackageSection(part);
  72                         GridData gd = new GridData(SWT.FILL, SWT.TOP, true, false);
  73                         gd.heightHint = 180;
  74                         part.setLayoutData(gd);
  75
  76                         part = toolkit.createComposite(body);
  77                         createImportPackageSection(part);
  78                         gd = new GridData(SWT.FILL, SWT.FILL, true, true);
  79                         // gd.heightHint = 200;
  80                         part.setLayoutData(gd);
  81
  82                         part = toolkit.createComposite(body);
  83                         createReqBundleSection(part);
  84                         gd = new GridData(SWT.FILL, SWT.FILL, true, true);
  85                         part.setLayoutData(gd);
  86
  87                         managedForm.reflow(true);
  88
  89                 } catch (RepositoryException e) {
  90                         throw new SlcException("unexpected error "
  91                                         + "while creating bundle details page");
  92                 }
  93         }
  94
  95         // Workaround to add an artificial level to the export package browser
  96         private class LevelElem {
  97                 private String label;
  98                 private Object parent;
  99
 100                 public LevelElem(String label, Object parent) {
 101                         this.label = label;
 102                         this.parent = parent;
 103                 }
 104
 105                 public String toString() {
 106                         return label;
 107                 }
 108
 109                 public Object getParent() {
 110                         return parent;
 111                 }
 112         }
 113
 114         /** Export Package Section */
 115         private void createExportPackageSection(Composite parent)
 116                         throws RepositoryException {
 117                 parent.setLayout(new GridLayout());
 118
 119                 // Define the TableViewer
 120
 121                 Section section = addSection(parent, "Export packages");
 122                 section.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
 123
 124                 TreeViewer viewer = new TreeViewer(section, SWT.H_SCROLL | SWT.V_SCROLL
 125                                 | SWT.BORDER);
 126                 final Tree tree = viewer.getTree();
 127                 tree.setHeaderVisible(false);
 128                 tree.setLinesVisible(true);
 129                 tree.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
 130
 131                 TreeViewerColumn col = new TreeViewerColumn(viewer, SWT.FILL);
 132                 col.getColumn().setWidth(400);
 133
 134                 col.setLabelProvider(new ColumnLabelProvider() {
 135                         private static final long serialVersionUID = 1376400790495130862L;
 136
 137                         @Override
 138                         public String getText(Object element) {
 139                                 if (element instanceof Node)
 140                                         return JcrUtils.get((Node) element, SlcNames.SLC_NAME);
 141                                 else
 142                                         return element.toString();
 143                         }
 144
 145                         @Override
 146                         public Image getImage(Object element) {
 147                                 if (element instanceof Node) {
 148                                         try {
 149                                                 Node node = (Node) element;
 150                                                 if (node.isNodeType(SlcTypes.SLC_EXPORTED_PACKAGE))
 151                                                         return DistImages.IMG_PACKAGE;
 152                                         } catch (RepositoryException e) {
 153                                                 throw new SlcException("Error retriving "
 154                                                                 + "image for the labelProvider", e);
 155                                         }
 156                                 }
 157                                 return null;
 158                         }
 159                 });
 160
 161                 viewer.setContentProvider(new ITreeContentProvider() {
 162                         private static final long serialVersionUID = 1898086304761992568L;
 163
 164                         public void dispose() {
 165                         }
 166
 167                         public void inputChanged(Viewer viewer, Object oldInput,
 168                                         Object newInput) {
 169                         }
 170
 171                         public Object[] getElements(Object inputElement) {
 172                                 try {
 173                                         List<Node> nodes = JcrUtils.nodeIteratorToList(listNodes(
 174                                                         currBundle, SlcTypes.SLC_EXPORTED_PACKAGE,
 175                                                         SlcNames.SLC_NAME));
 176                                         return nodes.toArray();
 177                                 } catch (RepositoryException e) {
 178                                         throw new SlcException("Cannot list children Nodes", e);
 179                                 }
 180                         }
 181
 182                         public Object[] getChildren(Object parentElement) {
 183                                 // Only 2 levels for the time being
 184                                 try {
 185                                         if (parentElement instanceof LevelElem) {
 186                                                 Node node = (Node) ((LevelElem) parentElement)
 187                                                                 .getParent();
 188                                                 List<Node> nodes = JcrUtils
 189                                                                 .nodeIteratorToList(listNodes(node,
 190                                                                                 SlcTypes.SLC_JAVA_PACKAGE,
 191                                                                                 SlcNames.SLC_NAME));
 192                                                 return nodes.toArray();
 193                                         } else if (parentElement instanceof Node) {
 194                                                 Node pNode = (Node) parentElement;
 195                                                 if (pNode.isNodeType(SlcTypes.SLC_EXPORTED_PACKAGE)) {
 196                                                         if (listNodes(pNode, SlcTypes.SLC_JAVA_PACKAGE,
 197                                                                         SlcNames.SLC_NAME).getSize() > 0) {
 198                                                                 Object[] result = { new LevelElem("uses", pNode) };
 199                                                                 return result;
 200                                                         }
 201                                                 }
 202                                         }
 203                                         return null;
 204                                 } catch (RepositoryException e) {
 205                                         throw new SlcException("Cannot list children Nodes", e);
 206                                 }
 207                         }
 208
 209                         public Object getParent(Object element) {
 210                                 // useless
 211                                 return null;
 212                         }
 213
 214                         public boolean hasChildren(Object element) {
 215                                 try {
 216                                         if (element instanceof LevelElem)
 217                                                 return true;
 218                                         else {
 219                                                 Node pNode = (Node) element;
 220                                                 if (pNode.isNodeType(SlcTypes.SLC_EXPORTED_PACKAGE)) {
 221                                                         return listNodes(pNode, SlcTypes.SLC_JAVA_PACKAGE,
 222                                                                         SlcNames.SLC_NAME).getSize() > 0;
 223                                                 }
 224                                         }
 225                                         return false;
 226                                 } catch (RepositoryException e) {
 227                                         throw new SlcException("Cannot check children Nodes", e);
 228                                 }
 229                         }
 230                 });
 231
 232                 section.setClient(tree);
 233                 viewer.setInput("Initialize");
 234                 // work around a display problem : the tree table has only a few lines
 235                 // when the tree is not expended
 236                 // viewer.expandToLevel(2);
 237         }
 238
 239         /** Import Package Section */
 240         private void createImportPackageSection(Composite parent)
 241                         throws RepositoryException {
 242                 parent.setLayout(new GridLayout());
 243
 244                 // Define the TableViewer
 245                 // toolkit.createLabel(parent, "Import packages", SWT.NONE).setFont(
 246                 // EclipseUiUtils.getBoldFont(parent));
 247
 248                 Section section = addSection(parent, "Import packages");
 249                 section.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
 250                 TableViewer viewer = new TableViewer(section, SWT.H_SCROLL
 251                                 | SWT.V_SCROLL | SWT.BORDER);
 252
 253                 final Table table = viewer.getTable();
 254                 table.setHeaderVisible(true);
 255                 table.setLinesVisible(true);
 256                 table.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
 257
 258                 // Name
 259                 TableViewerColumn col = new TableViewerColumn(viewer, SWT.NONE);
 260                 col.getColumn().setWidth(350);
 261                 col.getColumn().setText("Name");
 262                 col.setLabelProvider(new ColumnLabelProvider() {
 263                         private static final long serialVersionUID = -7836022945221936898L;
 264
 265                         @Override
 266                         public String getText(Object element) {
 267                                 return JcrUtils.get((Node) element, SLC_NAME);
 268                         }
 269
 270                         public Image getImage(Object element) {
 271                                 return DistImages.IMG_PACKAGE;
 272                         }
 273
 274                 });
 275
 276                 // Version
 277                 col = new TableViewerColumn(viewer, SWT.NONE);
 278                 col.getColumn().setWidth(100);
 279                 col.getColumn().setText("Version");
 280                 col.setLabelProvider(new ColumnLabelProvider() {
 281                         private static final long serialVersionUID = -8277731617775091641L;
 282
 283                         @Override
 284                         public String getText(Object element) {
 285                                 return JcrUtils.get((Node) element, SLC_VERSION);
 286                         }
 287                 });
 288
 289                 // Optional
 290                 col = new TableViewerColumn(viewer, SWT.NONE);
 291                 col.getColumn().setWidth(100);
 292                 col.getColumn().setText("Optional");
 293                 col.setLabelProvider(new ColumnLabelProvider() {
 294                         private static final long serialVersionUID = -2388533169594840688L;
 295
 296                         @Override
 297                         public String getText(Object element) {
 298                                 return JcrUtils.get((Node) element, SLC_OPTIONAL);
 299                         }
 300                 });
 301
 302                 viewer.setContentProvider(new TableContentProvider(
 303                                 SlcTypes.SLC_IMPORTED_PACKAGE, SLC_NAME));
 304                 section.setClient(table);
 305                 viewer.setInput("Initialize");
 306         }
 307
 308         /** Required Bundle Section */
 309         private void createReqBundleSection(Composite parent)
 310                         throws RepositoryException {
 311                 parent.setLayout(new GridLayout());
 312
 313                 // Define the TableViewer
 314                 Section section = addSection(parent, "Required bundles");
 315                 section.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
 316
 317                 // toolkit.createLabel(parent, "Required bundles", SWT.NONE).setFont(
 318                 // EclipseUiUtils.getBoldFont(parent));
 319                 TableViewer viewer = new TableViewer(section, SWT.H_SCROLL
 320                                 | SWT.V_SCROLL | SWT.BORDER);
 321
 322                 final Table table = viewer.getTable();
 323                 table.setHeaderVisible(true);
 324                 table.setLinesVisible(true);
 325                 table.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
 326
 327                 // Name
 328                 TableViewerColumn col = new TableViewerColumn(viewer, SWT.NONE);
 329                 col.getColumn().setWidth(300);
 330                 col.getColumn().setText("Name");
 331                 col.setLabelProvider(new ColumnLabelProvider() {
 332                         private static final long serialVersionUID = 4423640365819800247L;
 333
 334                         @Override
 335                         public String getText(Object element) {
 336                                 return JcrUtils.get((Node) element, SLC_SYMBOLIC_NAME);
 337                         }
 338
 339                         @Override
 340                         public Image getImage(Object element) {
 341                                 return DistImages.IMG_BUNDLE;
 342                         }
 343                 });
 344
 345                 // Version
 346                 col = new TableViewerColumn(viewer, SWT.NONE);
 347                 col.getColumn().setWidth(140);
 348                 col.getColumn().setText("Version");
 349                 col.setLabelProvider(new ColumnLabelProvider() {
 350                         private static final long serialVersionUID = 1898477425996646270L;
 351
 352                         @Override
 353                         public String getText(Object element) {
 354                                 return JcrUtils.get((Node) element, SLC_BUNDLE_VERSION);
 355                         }
 356                 });
 357
 358                 // Optional
 359                 col = new TableViewerColumn(viewer, SWT.NONE);
 360                 col.getColumn().setWidth(100);
 361                 col.getColumn().setText("Optional");
 362                 col.setLabelProvider(new ColumnLabelProvider() {
 363                         private static final long serialVersionUID = -7029999152302445581L;
 364
 365                         @Override
 366                         public String getText(Object element) {
 367                                 return JcrUtils.get((Node) element, SLC_OPTIONAL);
 368                         }
 369                 });
 370
 371                 viewer.setContentProvider(new TableContentProvider(
 372                                 SlcTypes.SLC_REQUIRED_BUNDLE, SLC_SYMBOLIC_NAME));
 373                 section.setClient(table);
 374                 viewer.setInput("Initialize");
 375         }
 376
 377         /**
 378          * Build repository request
 379          *
 380          * FIXME Workaround for remote repository, the path to bundleartifact (for
 381          * instance
 382          * .../org/argeo/slc/org.argeo.slc.client.ui.dist/1.1.12/org.argeo.slc
 383          * .client.ui.dist-1.1.12/ ) is not valid for method factory.childNode(); it
 384          * fails parsing the "1.1.12" part, trying to cast it as a BigDecimal
 385          *
 386          * */
 387         private NodeIterator listNodes(Node parent, String nodeType, String orderBy)
 388                         throws RepositoryException {
 389                 // QueryManager queryManager = currBundle.getSession().getWorkspace()
 390                 // .getQueryManager();
 391                 // QueryObjectModelFactory factory = queryManager.getQOMFactory();
 392                 //
 393                 // final String nodeSelector = "nodes";
 394                 // Selector source = factory.selector(nodeType, nodeSelector);
 395                 //
 396                 // Constraint childOf = factory.childNode(nodeSelector,
 397                 // parent.getPath());
 398                 //
 399                 // Ordering order =
 400                 // factory.ascending(factory.propertyValue(nodeSelector,
 401                 // orderBy));
 402                 // Ordering[] orderings = { order };
 403                 //
 404                 // QueryObjectModel query = factory.createQuery(source, childOf,
 405                 // orderings, null);
 406                 //
 407                 // QueryResult result = query.execute();
 408
 409                 String pattern = null;
 410                 if (SlcTypes.SLC_EXPORTED_PACKAGE.equals(nodeType))
 411                         pattern = "slc:Export-Package*";
 412                 else if (SlcTypes.SLC_JAVA_PACKAGE.equals(nodeType))
 413                         pattern = "slc:uses*";
 414                 else if (SlcTypes.SLC_IMPORTED_PACKAGE.equals(nodeType))
 415                         pattern = "slc:Import-Package*";
 416                 else if (SlcTypes.SLC_REQUIRED_BUNDLE.equals(nodeType))
 417                         pattern = "slc:Require-Bundle*";
 418
 419                 return parent.getNodes(pattern);
 420         }
 421
 422         private class TableContentProvider implements IStructuredContentProvider {
 423                 private static final long serialVersionUID = 4133284637336320455L;
 424                 private String nodeType;
 425                 private String orderBy;
 426
 427                 TableContentProvider(String nodeType, String orderBy) {
 428                         this.nodeType = nodeType;
 429                         this.orderBy = orderBy;
 430                 }
 431
 432                 public void dispose() {
 433                 }
 434
 435                 public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
 436                 }
 437
 438                 public Object[] getElements(Object arg0) {
 439                         try {
 440                                 List<Node> nodes = JcrUtils.nodeIteratorToList(listNodes(
 441                                                 currBundle, nodeType, orderBy));
 442                                 return nodes.toArray();
 443                         } catch (RepositoryException e) {
 444                                 ErrorFeedback.show("Cannot list children Nodes", e);
 445                                 return null;
 446                         }
 447                 }
 448         }
 449
 450         /* HELPERS */
 451         private Section addSection(Composite parent, String title) {
 452                 Section section = toolkit.createSection(parent, Section.TITLE_BAR);
 453                 section.setText(title);
 454                 section.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
 455                 return section;
 456         }
 457
 458 }