plugins/org.argeo.slc.akb.ui/src/main/java/org/argeo/slc/akb/ui/composites/AkbItemsTableComposite.java

   1 package org.argeo.slc.akb.ui.composites;
   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.PropertyType;
  10 import javax.jcr.RepositoryException;
  11 import javax.jcr.Session;
  12 import javax.jcr.nodetype.NodeType;
  13 import javax.jcr.query.QueryManager;
  14 import javax.jcr.query.QueryResult;
  15 import javax.jcr.query.qom.Constraint;
  16 import javax.jcr.query.qom.Ordering;
  17 import javax.jcr.query.qom.QueryObjectModel;
  18 import javax.jcr.query.qom.QueryObjectModelFactory;
  19 import javax.jcr.query.qom.Selector;
  20 import javax.jcr.query.qom.StaticOperand;
  21
  22 import org.argeo.eclipse.ui.EclipseUiUtils;
  23 import org.argeo.eclipse.ui.jcr.JcrUiUtils;
  24 import org.argeo.eclipse.ui.jcr.lists.ColumnDefinition;
  25 import org.argeo.eclipse.ui.jcr.lists.NodeViewerComparator;
  26 import org.argeo.eclipse.ui.jcr.lists.SimpleJcrNodeLabelProvider;
  27 import org.argeo.eclipse.ui.specific.EclipseUiSpecificUtils;
  28 import org.argeo.eclipse.ui.utils.ViewerUtils;
  29 import org.argeo.jcr.ArgeoNames;
  30 import org.argeo.jcr.JcrUtils;
  31 import org.argeo.slc.akb.AkbException;
  32 import org.argeo.slc.akb.AkbNames;
  33 import org.argeo.slc.akb.ui.providers.AkbImageProvider;
  34 import org.eclipse.jface.viewers.CheckboxTableViewer;
  35 import org.eclipse.jface.viewers.ColumnLabelProvider;
  36 import org.eclipse.jface.viewers.IStructuredContentProvider;
  37 import org.eclipse.jface.viewers.TableViewer;
  38 import org.eclipse.jface.viewers.TableViewerColumn;
  39 import org.eclipse.jface.viewers.Viewer;
  40 import org.eclipse.swt.SWT;
  41 import org.eclipse.swt.events.ModifyEvent;
  42 import org.eclipse.swt.events.ModifyListener;
  43 import org.eclipse.swt.events.SelectionAdapter;
  44 import org.eclipse.swt.events.SelectionEvent;
  45 import org.eclipse.swt.graphics.Font;
  46 import org.eclipse.swt.graphics.Image;
  47 import org.eclipse.swt.layout.GridData;
  48 import org.eclipse.swt.layout.GridLayout;
  49 import org.eclipse.swt.widgets.Composite;
  50 import org.eclipse.swt.widgets.Table;
  51 import org.eclipse.swt.widgets.Text;
  52
  53 public class AkbItemsTableComposite extends Composite implements ArgeoNames {
  54         // private final static Log log =
  55         // LogFactory.getLog(UserTableComposite.class);
  56
  57         private TableViewer usersViewer;
  58         private Text filterTxt;
  59         private final static String FILTER_HELP_MSG = "Type filter criterion "
  60                         + "separated by a space";
  61         private Session session;
  62
  63         private Font italic;
  64         private Font bold;
  65
  66         private boolean hasFilter;
  67         private boolean hasSelectionColumn;
  68
  69         // private List<Node> selectedItems = new ArrayList<Node>();
  70
  71         /**
  72          * Overwrite to display other columns
  73          */
  74         public List<ColumnDefinition> getColumnsDef() {
  75                 List<ColumnDefinition> columnDefs = new ArrayList<ColumnDefinition>();
  76                 // Name
  77                 columnDefs.add(new ColumnDefinition(null, Property.JCR_TITLE,
  78                                 PropertyType.STRING, "Name", 150));
  79
  80                 return columnDefs;
  81         }
  82
  83         public AkbItemsTableComposite(Composite parent, int style, Session session) {
  84                 super(parent, style);
  85                 this.session = session;
  86         }
  87
  88         /**
  89          *
  90          * @param addFilter
  91          *            choose to add a field to filter results or not
  92          * @param addSelection
  93          *            choose to add a column to select some of the displayed results
  94          *            or not
  95          */
  96         public void populate(boolean addFilter, boolean addSelection) {
  97                 // initialization
  98                 Composite parent = this;
  99                 italic = EclipseUiUtils.getItalicFont(parent);
 100                 bold = EclipseUiUtils.getBoldFont(parent);
 101                 hasFilter = addFilter;
 102                 hasSelectionColumn = addSelection;
 103
 104                 // Main Layout
 105                 this.setLayout(new GridLayout(1, false));
 106                 if (hasFilter)
 107                         createFilterPart(parent);
 108                 usersViewer = createTableViewer(parent);
 109                 EclipseUiSpecificUtils.enableToolTipSupport(usersViewer);
 110                 usersViewer.setContentProvider(new UsersContentProvider());
 111                 refreshFilteredList();
 112         }
 113
 114         /** Returns the User table viewer, typically to add doubleclick listener */
 115         public TableViewer getTableViewer() {
 116                 return usersViewer;
 117         }
 118
 119         private TableViewer createTableViewer(final Composite parent) {
 120                 int style = SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL;
 121                 if (hasSelectionColumn)
 122                         style = style | SWT.CHECK;
 123
 124                 Table table = new Table(parent, style);
 125                 table.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
 126
 127                 TableViewer viewer;
 128                 if (hasSelectionColumn)
 129                         viewer = new CheckboxTableViewer(table);
 130                 else
 131                         viewer = new TableViewer(table);
 132                 table.setLinesVisible(true);
 133                 table.setHeaderVisible(true);
 134
 135                 // pass a mapping between col index and property name to the comparator.
 136                 // List<String> propertiesList = new ArrayList<String>();
 137
 138                 TableViewerColumn column;
 139                 int offset = 0;
 140                 // if (hasSelectionColumn) {
 141                 if (hasSelectionColumn) {
 142                         offset++;
 143                         column = ViewerUtils.createTableViewerColumn(viewer, "", SWT.NONE,
 144                                         25);
 145                         // column.setEditingSupport(new SelectedEditingSupport(viewer));
 146                         column.setLabelProvider(new ColumnLabelProvider() {
 147                                 @Override
 148                                 public String getText(Object element) {
 149                                         return null;
 150                                 }
 151                         });
 152                         SelectionAdapter selectionAdapter = new SelectionAdapter() {
 153                                 boolean allSelected = false;
 154
 155                                 @Override
 156                                 public void widgetSelected(SelectionEvent e) {
 157                                         allSelected = !allSelected;
 158                                         ((CheckboxTableViewer) usersViewer)
 159                                                         .setAllChecked(allSelected);
 160                                 }
 161                         };
 162                         column.getColumn().addSelectionListener(selectionAdapter);
 163                 }
 164
 165                 // Image column
 166                 offset++;
 167                 column = ViewerUtils.createTableViewerColumn(viewer, "", SWT.NONE, 25);
 168                 // column.setEditingSupport(new SelectedEditingSupport(viewer));
 169                 column.setLabelProvider(new ColumnLabelProvider() {
 170                         private AkbImageProvider imageProvider = new AkbImageProvider();
 171
 172                         @Override
 173                         public String getText(Object element) {
 174                                 return null;
 175                         }
 176
 177                         @Override
 178                         public Image getImage(Object element) {
 179                                 return imageProvider.getImage(element);
 180                         }
 181
 182                 });
 183
 184                 // Create other columns
 185                 List<ColumnDefinition> colDefs = getColumnsDef();
 186
 187                 NodeViewerComparator comparator = new NodeViewerComparator();
 188                 int i = offset;
 189                 for (ColumnDefinition colDef : colDefs) {
 190                         column = ViewerUtils.createTableViewerColumn(viewer,
 191                                         colDef.getHeaderLabel(), SWT.NONE, colDef.getColumnSize());
 192                         column.setLabelProvider(new CLProvider(colDef.getPropertyName()));
 193                         column.getColumn().addSelectionListener(
 194                                         JcrUiUtils.getNodeSelectionAdapter(i,
 195                                                         colDef.getPropertyType(), colDef.getPropertyName(),
 196                                                         comparator, viewer));
 197                         i++;
 198                 }
 199
 200                 // IMPORTANT: initialize comparator before setting it
 201                 ColumnDefinition firstCol = colDefs.get(0);
 202                 comparator.setColumn(firstCol.getPropertyType(),
 203                                 firstCol.getPropertyName());
 204                 viewer.setComparator(comparator);
 205
 206                 return viewer;
 207         }
 208
 209         private class CLProvider extends SimpleJcrNodeLabelProvider {
 210
 211                 public CLProvider(String propertyName) {
 212                         super(propertyName);
 213                 }
 214
 215                 public String getToolTipText(Object element) {
 216                         return getText(element);
 217                 }
 218
 219                 @Override
 220                 public Font getFont(Object elem) {
 221                         return null;
 222                         // // self
 223                         // String username = getProperty(elem, ARGEO_USER_ID);
 224                         // if (username.equals(session.getUserID()))
 225                         // return bold;
 226                         //
 227                         // // disabled
 228                         // try {
 229                         // Node userProfile = (Node) elem;
 230                         // // Node userProfile = userHome.getNode(ARGEO_PROFILE);
 231                         // if (!userProfile.getProperty(ARGEO_ENABLED).getBoolean())
 232                         // return italic;
 233                         // else
 234                         // return null;
 235                         // } catch (RepositoryException e) {
 236                         // throw new AkbException("Cannot get font for " + username, e);
 237                         // }
 238                 }
 239         }
 240
 241         @Override
 242         public boolean setFocus() {
 243                 usersViewer.getTable().setFocus();
 244                 return true;
 245         }
 246
 247         @Override
 248         public void dispose() {
 249                 super.dispose();
 250         }
 251
 252         public void refresh() {
 253                 refreshFilteredList();
 254         }
 255
 256         private String getProperty(Object element, String name) {
 257                 try {
 258                         Node node = (Node) element;
 259                         return node.hasProperty(name) ? node.getProperty(name).getString()
 260                                         : "";
 261                 } catch (RepositoryException e) {
 262                         throw new AkbException("Cannot get property " + name, e);
 263                 }
 264         }
 265
 266         private class UsersContentProvider implements IStructuredContentProvider {
 267
 268                 public Object[] getElements(Object inputElement) {
 269                         return (Object[]) inputElement;
 270                 }
 271
 272                 public void dispose() {
 273                 }
 274
 275                 public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
 276                 }
 277         }
 278
 279         /* MANAGE FILTER */
 280         private void createFilterPart(Composite parent) {
 281                 // Text Area for the filter
 282                 filterTxt = new Text(parent, SWT.BORDER | SWT.SEARCH | SWT.ICON_SEARCH
 283                                 | SWT.ICON_CANCEL);
 284                 filterTxt.setMessage(FILTER_HELP_MSG);
 285                 filterTxt.setLayoutData(new GridData(GridData.GRAB_HORIZONTAL
 286                                 | GridData.HORIZONTAL_ALIGN_FILL));
 287                 filterTxt.addModifyListener(new ModifyListener() {
 288
 289                         public void modifyText(ModifyEvent event) {
 290                                 refreshFilteredList();
 291                         }
 292                 });
 293         }
 294
 295         /**
 296          * Refresh the user list: caller might overwrite in order to display a
 297          * subset of all users
 298          */
 299         protected void refreshFilteredList() {
 300                 List<Node> nodes;
 301                 try {
 302                         nodes = JcrUtils.nodeIteratorToList(listFilteredElements(session,
 303                                         hasFilter ? filterTxt.getText() : null));
 304                         usersViewer.setInput(nodes.toArray());
 305                 } catch (RepositoryException e) {
 306                         throw new AkbException("Unable to items", e);
 307                 }
 308         }
 309
 310         /**
 311          * Build repository request : caller might overwrite in order to display a
 312          * subset of all users
 313          */
 314         protected NodeIterator listFilteredElements(Session session, String filter)
 315                         throws RepositoryException {
 316                 QueryManager queryManager = session.getWorkspace().getQueryManager();
 317                 QueryObjectModelFactory factory = queryManager.getQOMFactory();
 318
 319                 Selector source = factory.selector(NodeType.MIX_TITLE,
 320                                 NodeType.MIX_TITLE);
 321
 322                 // Default Constraint: in correct sub tree
 323                 Constraint defaultC = factory.descendantNode(source.getSelectorName(),
 324                                 AkbNames.AKB_TEMPLATES_BASE_PATH);
 325
 326                 // FIXME: workaround to display only legal nodes
 327                 defaultC = factory.and(defaultC, factory.propertyExistence(
 328                                 source.getSelectorName(), Property.JCR_TITLE));
 329
 330                 // Build constraints based the textArea content
 331                 if (filter != null && !"".equals(filter.trim())) {
 332                         // Parse the String
 333                         String[] strs = filter.trim().split(" ");
 334                         for (String token : strs) {
 335                                 StaticOperand so = factory.literal(session.getValueFactory()
 336                                                 .createValue("*" + token + "*"));
 337                                 Constraint currC = factory.fullTextSearch(
 338                                                 source.getSelectorName(), null, so);
 339                                 if (defaultC == null)
 340                                         defaultC = currC;
 341                                 else
 342                                         defaultC = factory.and(defaultC, currC);
 343                         }
 344                 }
 345
 346                 Ordering order = factory.ascending(factory.propertyValue(
 347                                 source.getSelectorName(), Property.JCR_TITLE));
 348                 Ordering[] orderings = { order };
 349
 350                 QueryObjectModel query = factory.createQuery(source, defaultC,
 351                                 orderings, null);
 352
 353                 QueryResult result = query.execute();
 354                 return result.getNodes();
 355         }
 356 }