eclipse/plugins/org.argeo.slc.client.ui.dist/src/main/java/org/argeo/slc/client/ui/dist/editors/DistributionOverviewPage.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.PropertyType;
   9 import javax.jcr.RepositoryException;
  10 import javax.jcr.Session;
  11 import javax.jcr.query.QueryManager;
  12 import javax.jcr.query.QueryResult;
  13 import javax.jcr.query.qom.Ordering;
  14 import javax.jcr.query.qom.QueryObjectModel;
  15 import javax.jcr.query.qom.QueryObjectModelFactory;
  16 import javax.jcr.query.qom.Selector;
  17
  18 import org.argeo.eclipse.ui.ErrorFeedback;
  19 import org.argeo.jcr.JcrUtils;
  20 import org.argeo.slc.client.ui.dist.DistPlugin;
  21 import org.argeo.slc.client.ui.dist.commands.DeleteArtifacts;
  22 import org.argeo.slc.client.ui.dist.utils.CommandHelpers;
  23 import org.argeo.slc.client.ui.dist.utils.NodeViewerComparator;
  24 import org.argeo.slc.jcr.SlcNames;
  25 import org.argeo.slc.jcr.SlcTypes;
  26 import org.eclipse.jface.action.IMenuListener;
  27 import org.eclipse.jface.action.IMenuManager;
  28 import org.eclipse.jface.action.MenuManager;
  29 import org.eclipse.jface.viewers.ColumnLabelProvider;
  30 import org.eclipse.jface.viewers.IStructuredContentProvider;
  31 import org.eclipse.jface.viewers.TableViewer;
  32 import org.eclipse.jface.viewers.TableViewerColumn;
  33 import org.eclipse.jface.viewers.Viewer;
  34 import org.eclipse.swt.SWT;
  35 import org.eclipse.swt.events.SelectionAdapter;
  36 import org.eclipse.swt.events.SelectionEvent;
  37 import org.eclipse.swt.layout.GridData;
  38 import org.eclipse.swt.layout.GridLayout;
  39 import org.eclipse.swt.widgets.Menu;
  40 import org.eclipse.swt.widgets.Table;
  41 import org.eclipse.ui.IWorkbenchWindow;
  42 import org.eclipse.ui.forms.IManagedForm;
  43 import org.eclipse.ui.forms.editor.FormEditor;
  44 import org.eclipse.ui.forms.editor.FormPage;
  45 import org.eclipse.ui.forms.widgets.ScrolledForm;
  46 import org.osgi.framework.Constants;
  47
  48 /** Table giving an overview of an OSGi distribution */
  49 public class DistributionOverviewPage extends FormPage implements SlcNames {
  50         private TableViewer viewer;
  51         private Session session;
  52
  53         private NodeViewerComparator comparator;
  54
  55         public DistributionOverviewPage(FormEditor formEditor, String title,
  56                         Session session) {
  57                 super(formEditor, "distributionPage", title);
  58                 this.session = session;
  59         }
  60
  61         @Override
  62         protected void createFormContent(IManagedForm managedForm) {
  63                 ScrolledForm form = managedForm.getForm();
  64                 GridLayout layout = new GridLayout(1, false);
  65                 form.getBody().setLayout(layout);
  66
  67                 // helpers to enable sorting by column
  68                 List<String> propertiesList = new ArrayList<String>();
  69                 List<Integer> propertyTypesList = new ArrayList<Integer>();
  70
  71                 // Define the TableViewer
  72                 viewer = new TableViewer(form.getBody(), SWT.MULTI | SWT.H_SCROLL
  73                                 | SWT.V_SCROLL | SWT.FULL_SELECTION | SWT.BORDER);
  74
  75                 TableViewerColumn col = new TableViewerColumn(viewer,  SWT.V_SCROLL);
  76                 col.getColumn().setWidth(300);
  77                 col.getColumn().setText("Symbolic name");
  78                 col.setLabelProvider(new ColumnLabelProvider() {
  79                         @Override
  80                         public String getText(Object element) {
  81                                 return JcrUtils.get((Node) element, SLC_SYMBOLIC_NAME);
  82                         }
  83                 });
  84                 col.getColumn().addSelectionListener(getSelectionAdapter(0));
  85                 propertiesList.add(SLC_SYMBOLIC_NAME);
  86                 propertyTypesList.add(PropertyType.STRING);
  87
  88                 col = new TableViewerColumn(viewer, SWT.NONE);
  89                 col.getColumn().setWidth(100);
  90                 col.getColumn().setText("Version");
  91                 col.setLabelProvider(new ColumnLabelProvider() {
  92                         @Override
  93                         public String getText(Object element) {
  94                                 return JcrUtils.get((Node) element, SLC_BUNDLE_VERSION);
  95                         }
  96                 });
  97                 col.getColumn().addSelectionListener(getSelectionAdapter(1));
  98                 propertiesList.add(SLC_BUNDLE_VERSION);
  99                 propertyTypesList.add(PropertyType.STRING);
 100
 101                 col = new TableViewerColumn(viewer, SWT.NONE);
 102                 col.getColumn().setWidth(150);
 103                 col.getColumn().setText("Group ID");
 104                 col.setLabelProvider(new ColumnLabelProvider() {
 105                         @Override
 106                         public String getText(Object element) {
 107                                 return JcrUtils.get((Node) element, SLC_GROUP_ID);
 108                         }
 109                 });
 110                 col.getColumn().addSelectionListener(getSelectionAdapter(2));
 111                 propertiesList.add(SLC_GROUP_ID);
 112                 propertyTypesList.add(PropertyType.STRING);
 113
 114                 col = new TableViewerColumn(viewer, SWT.NONE);
 115                 col.getColumn().setWidth(300);
 116                 col.getColumn().setText("Name");
 117                 col.setLabelProvider(new ColumnLabelProvider() {
 118                         @Override
 119                         public String getText(Object element) {
 120                                 return JcrUtils.get((Node) element, SLC_
 121                                                 + Constants.BUNDLE_NAME);
 122                         }
 123                 });
 124                 col.getColumn().addSelectionListener(getSelectionAdapter(3));
 125                 propertiesList.add(SLC_ + Constants.BUNDLE_NAME);
 126                 propertyTypesList.add(PropertyType.STRING);
 127
 128                 final Table table = viewer.getTable();
 129                 table.setHeaderVisible(true);
 130                 table.setLinesVisible(true);
 131                 table.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
 132
 133                 viewer.setContentProvider(new DistributionsContentProvider());
 134                 getSite().setSelectionProvider(viewer);
 135
 136                 viewer.setInput(session);
 137                 comparator = new NodeViewerComparator(1,
 138                                 NodeViewerComparator.DESCENDING, propertiesList,
 139                                 propertyTypesList);
 140                 viewer.setComparator(comparator);
 141
 142                 MenuManager menuManager = new MenuManager();
 143                 Menu menu = menuManager.createContextMenu(viewer.getTable());
 144                 menuManager.addMenuListener(new IMenuListener() {
 145                         public void menuAboutToShow(IMenuManager manager) {
 146                                 contextMenuAboutToShow(manager);
 147                         }
 148                 });
 149                 viewer.getTable().setMenu(menu);
 150                 getSite().registerContextMenu(menuManager, viewer);
 151
 152         }
 153
 154         @Override
 155         public void setFocus() {
 156                 viewer.getTable().setFocus();
 157         }
 158
 159         /** force refresh of the artifact list */
 160         public void refresh() {
 161                 viewer.refresh();
 162         }
 163
 164         /** Programatically configure the context menu */
 165         protected void contextMenuAboutToShow(IMenuManager menuManager) {
 166                 IWorkbenchWindow window = DistPlugin.getDefault().getWorkbench()
 167                                 .getActiveWorkbenchWindow();
 168
 169                 // Build conditions depending on element type (repo or workspace)
 170
 171                 // Delete selected artifacts
 172                 CommandHelpers.refreshCommand(menuManager, window, DeleteArtifacts.ID,
 173                                 DeleteArtifacts.DEFAULT_LABEL,
 174                                 DeleteArtifacts.DEFAULT_ICON_PATH, true);
 175
 176         }
 177
 178         static NodeIterator listBundleArtifacts(Session session)
 179                         throws RepositoryException {
 180                 QueryManager queryManager = session.getWorkspace().getQueryManager();
 181                 QueryObjectModelFactory factory = queryManager.getQOMFactory();
 182
 183                 final String bundleArtifactsSelector = "bundleArtifacts";
 184                 Selector source = factory.selector(SlcTypes.SLC_BUNDLE_ARTIFACT,
 185                                 bundleArtifactsSelector);
 186
 187                 Ordering order = factory.ascending(factory.propertyValue(
 188                                 bundleArtifactsSelector, SlcNames.SLC_SYMBOLIC_NAME));
 189                 Ordering[] orderings = { order };
 190
 191                 QueryObjectModel query = factory.createQuery(source, null, orderings,
 192                                 null);
 193
 194                 QueryResult result = query.execute();
 195                 return result.getNodes();
 196         }
 197
 198         private SelectionAdapter getSelectionAdapter(final int index) {
 199                 SelectionAdapter selectionAdapter = new SelectionAdapter() {
 200                         @Override
 201                         public void widgetSelected(SelectionEvent e) {
 202                                 Table table = viewer.getTable();
 203                                 comparator.setColumn(index);
 204                                 int dir = table.getSortDirection();
 205                                 if (table.getSortColumn() == table.getColumn(index)) {
 206                                         dir = dir == SWT.UP ? SWT.DOWN : SWT.UP;
 207                                 } else {
 208                                         dir = SWT.DOWN;
 209                                 }
 210                                 table.setSortDirection(dir);
 211                                 table.setSortColumn(table.getColumn(index));
 212                                 viewer.refresh();
 213                         }
 214                 };
 215                 return selectionAdapter;
 216         }
 217
 218         private static class DistributionsContentProvider implements
 219                         IStructuredContentProvider {
 220                 private Session session;
 221
 222                 public void dispose() {
 223                 }
 224
 225                 public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
 226                         session = (Session) newInput;
 227                 }
 228
 229                 public Object[] getElements(Object arg0) {
 230                         try {
 231                                 List<Node> nodes = JcrUtils
 232                                                 .nodeIteratorToList(listBundleArtifacts(session));
 233                                 return nodes.toArray();
 234                         } catch (RepositoryException e) {
 235                                 ErrorFeedback.show("Cannot list bundles", e);
 236                                 return null;
 237                         }
 238                 }
 239         }
 240         //
 241         // private class BoundedLayout extends Layout {
 242         // protected Layout delegateLayout;
 243         //
 244         // protected Method computeSizeMethod;
 245         // protected Method layoutMethod;
 246         //
 247         // protected boolean widthBound;
 248         //
 249         // public BoundedLayout(Layout delegateLayout, boolean widthBound) {
 250         // setDelegateLayout(delegateLayout);
 251         // this.widthBound = widthBound;
 252         // }
 253         //
 254         // public Layout getDelegateLayout() {
 255         // return delegateLayout;
 256         // }
 257         //
 258         // public void setDelegateLayout(Layout delegateLayout) {
 259         // this.delegateLayout = delegateLayout;
 260         //
 261         // try {
 262         // computeSizeMethod = delegateLayout.getClass()
 263         // .getDeclaredMethod("computeSize", Composite.class,
 264         // int.class, int.class, boolean.class);
 265         // computeSizeMethod.setAccessible(true);
 266         //
 267         // layoutMethod = delegateLayout.getClass().getDeclaredMethod(
 268         // "layout", Composite.class, boolean.class);
 269         // layoutMethod.setAccessible(true);
 270         // } catch (Exception e) {
 271         // throw new RuntimeException(e);
 272         // }
 273         // }
 274         //
 275         // @Override
 276         // protected Point computeSize(Composite composite, int wHint, int hHint,
 277         // boolean flushCache) {
 278         // // get comp size to make sure we don't let any children exceed it
 279         // Point compSize = composite.getSize();
 280         //
 281         // try {
 282         // Point layoutComputedSize = (Point) computeSizeMethod.invoke(
 283         // delegateLayout, composite, wHint, hHint, flushCache);
 284         //
 285         // if (widthBound) {
 286         // layoutComputedSize.x = Math.min(compSize.x,
 287         // layoutComputedSize.x);
 288         // } else {
 289         // layoutComputedSize.y = Math.min(compSize.y,
 290         // layoutComputedSize.y);
 291         // }
 292         //
 293         // return layoutComputedSize;
 294         // } catch (Exception e) {
 295         // throw new RuntimeException(e);
 296         // }
 297         // }
 298         //
 299         // @Override
 300         // protected void layout(Composite composite, boolean flushCache) {
 301         // try {
 302         // layoutMethod.invoke(delegateLayout, composite, flushCache);
 303         // } catch (Exception e) {
 304         // throw new RuntimeException(e);
 305         // }
 306         // }
 307         // }
 308 }