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