eclipse/plugins/org.argeo.slc.client.ui.dist/src/main/java/org/argeo/slc/client/ui/dist/utils/ArtifactsTableConfigurer.java

   1 package org.argeo.slc.client.ui.dist.utils;
   2
   3 import java.text.DateFormat;
   4 import java.text.SimpleDateFormat;
   5 import java.util.HashMap;
   6 import java.util.Map;
   7
   8 import javax.jcr.PropertyType;
   9 import javax.jcr.RepositoryException;
  10 import javax.jcr.Value;
  11 import javax.jcr.query.Row;
  12
  13 import org.apache.commons.logging.Log;
  14 import org.apache.commons.logging.LogFactory;
  15 import org.argeo.ArgeoException;
  16 import org.argeo.eclipse.ui.GenericTableComparator;
  17 import org.argeo.slc.client.ui.dist.DistConstants;
  18 import org.argeo.slc.jcr.SlcNames;
  19 import org.argeo.slc.jcr.SlcTypes;
  20 import org.eclipse.jface.viewers.ColumnLabelProvider;
  21 import org.eclipse.jface.viewers.TableViewer;
  22 import org.eclipse.jface.viewers.TableViewerColumn;
  23 import org.eclipse.jface.viewers.Viewer;
  24 import org.eclipse.swt.SWT;
  25 import org.eclipse.swt.events.SelectionAdapter;
  26 import org.eclipse.swt.events.SelectionEvent;
  27 import org.eclipse.swt.graphics.Image;
  28 import org.eclipse.swt.widgets.TableColumn;
  29
  30 /**
  31  * Centralizes and factorizes useful methods to create and manage tables that
  32  * display artifacts for both editors and views.
  33  */
  34 public class ArtifactsTableConfigurer implements SlcNames, SlcTypes,
  35                 DistConstants {
  36         private final static Log log = LogFactory
  37                         .getLog(ArtifactsTableConfigurer.class);
  38         // Used in the comparator to be able to retrieve the value from a row
  39         // knowing the corresponding column index.
  40         private Map<Integer, String> indexToName = new HashMap<Integer, String>();
  41
  42         private CurrentTableComparator comparator;
  43         private TableViewer viewer;
  44
  45         protected DateFormat timeFormatter = new SimpleDateFormat(DATE_TIME_FORMAT);
  46
  47         /**
  48          * Create and initialize the table configurer.
  49          */
  50         public ArtifactsTableConfigurer(TableViewer viewer,
  51                         int defaultSortColumnIndex, int direction) {
  52                 this.viewer = viewer;
  53                 comparator = new CurrentTableComparator(defaultSortColumnIndex,
  54                                 direction);
  55         }
  56
  57         public GenericTableComparator getComparator() {
  58                 return comparator;
  59         }
  60
  61         /**
  62          * Configure column width and header label depending on the value that will
  63          * be displayed in the current column.
  64          *
  65          * @param jcrColumnName
  66          * @param column
  67          * @param columnIndex
  68          */
  69         public void configureColumn(String jcrColumnName, TableViewerColumn column,
  70                         int columnIndex) {
  71
  72                 if (columnIndex != -1
  73                                 && getSelectionAdapter(column.getColumn(), columnIndex) != null) {
  74                         column.getColumn().addSelectionListener(
  75                                         getSelectionAdapter(column.getColumn(), columnIndex));
  76                         indexToName.put(new Integer(columnIndex), jcrColumnName);
  77                 }
  78                 Object[] objs = getColumnLabelAndWidth(jcrColumnName);
  79                 column.getColumn().setWidth((Integer) objs[0]);
  80                 column.getColumn().setText((String) objs[1]);
  81         }
  82
  83         /**
  84          * Returns corresponding default width ( (int) object[0] ) and the header
  85          * label ( (String) object[1] ) depending on the property name.
  86          */
  87         public static Object[] getColumnLabelAndWidth(String propertyName) {
  88                 // to avoid npe :
  89                 if (propertyName == null)
  90                         return new Object[] { 60, "(No name)" };
  91
  92                 if (propertyName.equals(SLC_ARTIFACT + "." + SLC_ARTIFACT_ID)) {
  93                         return new Object[] { 140, "Artifact ID" };
  94                 } else if (propertyName.equals(SLC_ARTIFACT + "." + SLC_GROUP_ID)) {
  95                         return new Object[] { 120, "Group ID" };
  96                 } else if (propertyName.equals(SLC_ARTIFACT + "."
  97                                 + SLC_ARTIFACT_VERSION)) {
  98                         return new Object[] { 60, "Version" };
  99                 } else if (propertyName.equals(SLC_ARTIFACT + "."
 100                                 + SLC_ARTIFACT_CLASSIFIER)) {
 101                         return new Object[] { 60, "Classifier" };
 102                 } else if (propertyName.equals(SLC_ARTIFACT + "."
 103                                 + SLC_ARTIFACT_EXTENSION)) {
 104                         return new Object[] { 40, "Type" };
 105                 } else if (propertyName.equals(SLC_ARTIFACT + ".jcr:uuid")) {
 106                         return new Object[] { 20, "UUID" };
 107                 } else {
 108                         if (log.isTraceEnabled())
 109                                 log.trace("No Column label provider defined for property: ["
 110                                                 + propertyName + "]");
 111                         return new Object[] { 60, propertyName };
 112                 }
 113         }
 114
 115         /**
 116          * Might be used by client classes to sort columns.
 117          *
 118          * @param column
 119          * @param index
 120          * @return
 121          */
 122         public SelectionAdapter getSelectionAdapter(final TableColumn column,
 123                         final int index) {
 124
 125                 // A comparator must be define
 126                 if (comparator == null)
 127                         return null;
 128
 129                 SelectionAdapter selectionAdapter = new SelectionAdapter() {
 130                         @Override
 131                         public void widgetSelected(SelectionEvent e) {
 132
 133                                 try {
 134
 135                                         comparator.setColumn(index);
 136                                         int dir = viewer.getTable().getSortDirection();
 137                                         if (viewer.getTable().getSortColumn() == column) {
 138                                                 dir = dir == SWT.UP ? SWT.DOWN : SWT.UP;
 139                                         } else {
 140
 141                                                 dir = SWT.DOWN;
 142                                         }
 143                                         viewer.getTable().setSortDirection(dir);
 144                                         viewer.getTable().setSortColumn(column);
 145                                         viewer.refresh();
 146                                 } catch (Exception exc) {
 147                                         exc.printStackTrace();
 148                                 }
 149                         }
 150                 };
 151                 return selectionAdapter;
 152         }
 153
 154         /**
 155          * provides a label provider that returns the content of a specific cell.
 156          * Specific treatment is done for some columns when the query returns a code
 157          * that must be translated to the corresponding value at display time.
 158          */
 159         public ColumnLabelProvider getLabelProvider(final String columnName) {
 160                 boolean test = false;
 161
 162                 if (test) {
 163                         return new ColumnLabelProvider() {
 164                                 public String getText(Object element) {
 165                                         return null;
 166                                 }
 167
 168                                 public Image getImage(Object element) {
 169                                         return null;
 170                                 }
 171                         };
 172                 } else
 173                         return new ColumnLabelProvider() {
 174                                 public String getText(Object element) {
 175                                         Row row = (Row) element;
 176                                         try {
 177                                                 return row.getValue(columnName).getString();
 178                                         } catch (RepositoryException e) {
 179                                                 throw new ArgeoException("Cannot display row " + row, e);
 180                                         }
 181                                 }
 182
 183                                 public Image getImage(Object element) {
 184                                         return null;
 185                                 }
 186                         };
 187         }
 188
 189         /** Implements comparator for various types of Artifact Table row */
 190         private class CurrentTableComparator extends GenericTableComparator {
 191
 192                 public CurrentTableComparator(int colIndex, int direction) {
 193                         super(colIndex, direction);
 194                 }
 195
 196                 @Override
 197                 public int compare(Viewer viewer, Object e1, Object e2) {
 198                         int rc = 0;
 199
 200                         if (e1 instanceof Row) {
 201                                 try {
 202
 203                                         Value v1 = ((Row) e1).getValue(indexToName
 204                                                         .get(propertyIndex));
 205                                         Value v2 = ((Row) e2).getValue(indexToName
 206                                                         .get(propertyIndex));
 207
 208                                         if (v1.getType() == PropertyType.STRING)
 209                                                 rc = v1.getString().compareTo(v2.getString());
 210                                         else if (v1.getType() == PropertyType.DATE)
 211                                                 rc = v1.getDate().compareTo(v2.getDate());
 212                                         else
 213                                                 throw new ArgeoException("comparator for object type "
 214                                                                 + v1.getType() + " is not yet implemented");
 215                                 } catch (Exception e) {
 216                                         throw new ArgeoException("rows cannot be compared ", e);
 217                                 }
 218                         } else
 219                                 throw new ArgeoException("Unsupported row type");
 220                         // If descending order, flip the direction
 221                         if (direction == DESCENDING) {
 222                                 rc = -rc;
 223                         }
 224                         return rc;
 225                 }
 226         }
 227 }