swt/org.argeo.tool.devops.e4/src/org/argeo/cms/swt/useradmin/LdifUsersTable.java

   1 package org.argeo.cms.swt.useradmin;
   2
   3 import java.util.ArrayList;
   4 import java.util.List;
   5
   6 import org.argeo.eclipse.ui.ColumnDefinition;
   7 import org.argeo.eclipse.ui.EclipseUiException;
   8 import org.argeo.eclipse.ui.EclipseUiUtils;
   9 import org.eclipse.jface.layout.TableColumnLayout;
  10 import org.eclipse.jface.viewers.CheckboxTableViewer;
  11 import org.eclipse.jface.viewers.ColumnLabelProvider;
  12 import org.eclipse.jface.viewers.ColumnWeightData;
  13 import org.eclipse.jface.viewers.IStructuredContentProvider;
  14 import org.eclipse.jface.viewers.TableViewer;
  15 import org.eclipse.jface.viewers.TableViewerColumn;
  16 import org.eclipse.jface.viewers.Viewer;
  17 import org.eclipse.swt.SWT;
  18 import org.eclipse.swt.events.ModifyEvent;
  19 import org.eclipse.swt.events.ModifyListener;
  20 import org.eclipse.swt.events.SelectionAdapter;
  21 import org.eclipse.swt.events.SelectionEvent;
  22 import org.eclipse.swt.layout.GridData;
  23 import org.eclipse.swt.layout.GridLayout;
  24 import org.eclipse.swt.widgets.Composite;
  25 import org.eclipse.swt.widgets.Link;
  26 import org.eclipse.swt.widgets.Table;
  27 import org.eclipse.swt.widgets.TableColumn;
  28 import org.eclipse.swt.widgets.Text;
  29 import org.osgi.service.useradmin.User;
  30
  31 /**
  32  * Generic composite that display a filter and a table viewer to display users
  33  * (can also be groups)
  34  *
  35  * Warning: this class does not extends <code>TableViewer</code>. Use the
  36  * getTableViewer method to access it.
  37  *
  38  */
  39 public abstract class LdifUsersTable extends Composite {
  40         private static final long serialVersionUID = -7385959046279360420L;
  41
  42         // Context
  43         // private UserAdmin userAdmin;
  44
  45         // Configuration
  46         private List<ColumnDefinition> columnDefs = new ArrayList<ColumnDefinition>();
  47         private boolean hasFilter;
  48         private boolean preventTableLayout = false;
  49         private boolean hasSelectionColumn;
  50         private int tableStyle;
  51
  52         // Local UI Objects
  53         private TableViewer usersViewer;
  54         private Text filterTxt;
  55
  56         /* EXPOSED METHODS */
  57
  58         /**
  59          * @param parent
  60          * @param style
  61          */
  62         public LdifUsersTable(Composite parent, int style) {
  63                 super(parent, SWT.NO_FOCUS);
  64                 this.tableStyle = style;
  65         }
  66
  67         // TODO workaround the bug of the table layout in the Form
  68         public LdifUsersTable(Composite parent, int style, boolean preventTableLayout) {
  69                 super(parent, SWT.NO_FOCUS);
  70                 this.tableStyle = style;
  71                 this.preventTableLayout = preventTableLayout;
  72         }
  73
  74         /** This must be called before the call to populate method */
  75         public void setColumnDefinitions(List<ColumnDefinition> columnDefinitions) {
  76                 this.columnDefs = columnDefinitions;
  77         }
  78
  79         /**
  80          *
  81          * @param addFilter
  82          *            choose to add a field to filter results or not
  83          * @param addSelection
  84          *            choose to add a column to select some of the displayed results or
  85          *            not
  86          */
  87         public void populate(boolean addFilter, boolean addSelection) {
  88                 // initialization
  89                 Composite parent = this;
  90                 hasFilter = addFilter;
  91                 hasSelectionColumn = addSelection;
  92
  93                 // Main Layout
  94                 GridLayout layout = EclipseUiUtils.noSpaceGridLayout();
  95                 layout.verticalSpacing = 5;
  96                 this.setLayout(layout);
  97                 if (hasFilter)
  98                         createFilterPart(parent);
  99
 100                 Composite tableComp = new Composite(parent, SWT.NO_FOCUS);
 101                 tableComp.setLayoutData(EclipseUiUtils.fillAll());
 102                 usersViewer = createTableViewer(tableComp);
 103                 usersViewer.setContentProvider(new UsersContentProvider());
 104         }
 105
 106         /**
 107          *
 108          * @param showMore
 109          *            display static filters on creation
 110          * @param addSelection
 111          *            choose to add a column to select some of the displayed results or
 112          *            not
 113          */
 114         public void populateWithStaticFilters(boolean showMore, boolean addSelection) {
 115                 // initialization
 116                 Composite parent = this;
 117                 hasFilter = true;
 118                 hasSelectionColumn = addSelection;
 119
 120                 // Main Layout
 121                 GridLayout layout = EclipseUiUtils.noSpaceGridLayout();
 122                 layout.verticalSpacing = 5;
 123                 this.setLayout(layout);
 124                 createStaticFilterPart(parent, showMore);
 125
 126                 Composite tableComp = new Composite(parent, SWT.NO_FOCUS);
 127                 tableComp.setLayoutData(EclipseUiUtils.fillAll());
 128                 usersViewer = createTableViewer(tableComp);
 129                 usersViewer.setContentProvider(new UsersContentProvider());
 130         }
 131
 132         /** Enable access to the selected users or groups */
 133         public List<User> getSelectedUsers() {
 134                 if (hasSelectionColumn) {
 135                         Object[] elements = ((CheckboxTableViewer) usersViewer).getCheckedElements();
 136
 137                         List<User> result = new ArrayList<User>();
 138                         for (Object obj : elements) {
 139                                 result.add((User) obj);
 140                         }
 141                         return result;
 142                 } else
 143                         throw new EclipseUiException(
 144                                         "Unvalid request: no selection column " + "has been created for the current table");
 145         }
 146
 147         /** Returns the User table viewer, typically to add doubleclick listener */
 148         public TableViewer getTableViewer() {
 149                 return usersViewer;
 150         }
 151
 152         /**
 153          * Force the refresh of the underlying table using the current filter string if
 154          * relevant
 155          */
 156         public void refresh() {
 157                 String filter = hasFilter ? filterTxt.getText().trim() : null;
 158                 if ("".equals(filter))
 159                         filter = null;
 160                 refreshFilteredList(filter);
 161         }
 162
 163         /** Effective repository request: caller must implement this method */
 164         abstract protected List<User> listFilteredElements(String filter);
 165
 166         // protected List<User> listFilteredElements(String filter) {
 167         // List<User> users = new ArrayList<User>();
 168         // try {
 169         // Role[] roles = userAdmin.getRoles(filter);
 170         // // Display all users and groups
 171         // for (Role role : roles)
 172         // users.add((User) role);
 173         // } catch (InvalidSyntaxException e) {
 174         // throw new EclipseUiException("Unable to get roles with filter: "
 175         // + filter, e);
 176         // }
 177         // return users;
 178         // }
 179
 180         /* GENERIC COMPOSITE METHODS */
 181         @Override
 182         public boolean setFocus() {
 183                 if (hasFilter)
 184                         return filterTxt.setFocus();
 185                 else
 186                         return usersViewer.getTable().setFocus();
 187         }
 188
 189         @Override
 190         public void dispose() {
 191                 super.dispose();
 192         }
 193
 194         /* LOCAL CLASSES AND METHODS */
 195         // Will be usefull to rather use a virtual table viewer
 196         private void refreshFilteredList(String filter) {
 197                 List<User> users = listFilteredElements(filter);
 198                 usersViewer.setInput(users.toArray());
 199         }
 200
 201         private class UsersContentProvider implements IStructuredContentProvider {
 202                 private static final long serialVersionUID = 1L;
 203
 204                 public Object[] getElements(Object inputElement) {
 205                         return (Object[]) inputElement;
 206                 }
 207
 208                 public void dispose() {
 209                 }
 210
 211                 public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
 212                 }
 213         }
 214
 215         /* MANAGE FILTER */
 216         private void createFilterPart(Composite parent) {
 217                 // Text Area for the filter
 218                 filterTxt = new Text(parent, SWT.BORDER | SWT.SEARCH | SWT.ICON_SEARCH | SWT.ICON_CANCEL);
 219                 filterTxt.setLayoutData(new GridData(GridData.FILL, GridData.FILL, true, false));
 220                 filterTxt.addModifyListener(new ModifyListener() {
 221                         private static final long serialVersionUID = 1L;
 222
 223                         public void modifyText(ModifyEvent event) {
 224                                 refreshFilteredList(filterTxt.getText());
 225                         }
 226                 });
 227         }
 228
 229         private void createStaticFilterPart(Composite parent, boolean showMore) {
 230                 Composite filterComp = new Composite(parent, SWT.NO_FOCUS);
 231                 filterComp.setLayout(new GridLayout(2, false));
 232                 filterComp.setLayoutData(EclipseUiUtils.fillWidth());
 233                 // generic search
 234                 filterTxt = new Text(filterComp, SWT.BORDER | SWT.SEARCH | SWT.ICON_SEARCH | SWT.ICON_CANCEL);
 235                 filterTxt.setLayoutData(new GridData(GridData.FILL, GridData.FILL, true, false));
 236                 // filterTxt.setLayoutData(new GridData(GridData.GRAB_HORIZONTAL |
 237                 // GridData.HORIZONTAL_ALIGN_FILL));
 238                 filterTxt.addModifyListener(new ModifyListener() {
 239                         private static final long serialVersionUID = 1L;
 240
 241                         public void modifyText(ModifyEvent event) {
 242                                 refreshFilteredList(filterTxt.getText());
 243                         }
 244                 });
 245
 246                 // add static filter abilities
 247                 Link moreLk = new Link(filterComp, SWT.NONE);
 248                 Composite staticFilterCmp = new Composite(filterComp, SWT.NO_FOCUS);
 249                 staticFilterCmp.setLayoutData(EclipseUiUtils.fillWidth(2));
 250                 populateStaticFilters(staticFilterCmp);
 251
 252                 MoreLinkListener listener = new MoreLinkListener(moreLk, staticFilterCmp, showMore);
 253                 // initialise the layout
 254                 listener.refresh();
 255                 moreLk.addSelectionListener(listener);
 256         }
 257
 258         /** Overwrite to add static filters */
 259         protected void populateStaticFilters(Composite staticFilterCmp) {
 260         }
 261
 262         // private void addMoreSL(final Link more) {
 263         // more.addSelectionListener( }
 264
 265         private class MoreLinkListener extends SelectionAdapter {
 266                 private static final long serialVersionUID = -524987616510893463L;
 267                 private boolean isShown;
 268                 private final Composite staticFilterCmp;
 269                 private final Link moreLk;
 270
 271                 public MoreLinkListener(Link moreLk, Composite staticFilterCmp, boolean isShown) {
 272                         this.moreLk = moreLk;
 273                         this.staticFilterCmp = staticFilterCmp;
 274                         this.isShown = isShown;
 275                 }
 276
 277                 @Override
 278                 public void widgetSelected(SelectionEvent e) {
 279                         isShown = !isShown;
 280                         refresh();
 281                 }
 282
 283                 public void refresh() {
 284                         GridData gd = (GridData) staticFilterCmp.getLayoutData();
 285                         if (isShown) {
 286                                 moreLk.setText("<a> Less... </a>");
 287                                 gd.heightHint = SWT.DEFAULT;
 288                         } else {
 289                                 moreLk.setText("<a> More... </a>");
 290                                 gd.heightHint = 0;
 291                         }
 292                         forceLayout();
 293                 }
 294         }
 295
 296         private void forceLayout() {
 297                 LdifUsersTable.this.getParent().layout(true, true);
 298         }
 299
 300         private TableViewer createTableViewer(final Composite parent) {
 301
 302                 int style = tableStyle | SWT.H_SCROLL | SWT.V_SCROLL;
 303                 if (hasSelectionColumn)
 304                         style = style | SWT.CHECK;
 305                 Table table = new Table(parent, style);
 306                 TableColumnLayout layout = new TableColumnLayout();
 307
 308                 // TODO the table layout does not works with the scrolled form
 309
 310                 if (preventTableLayout) {
 311                         parent.setLayout(EclipseUiUtils.noSpaceGridLayout());
 312                         table.setLayoutData(EclipseUiUtils.fillAll());
 313                 } else
 314                         parent.setLayout(layout);
 315
 316                 TableViewer viewer;
 317                 if (hasSelectionColumn)
 318                         viewer = new CheckboxTableViewer(table);
 319                 else
 320                         viewer = new TableViewer(table);
 321                 table.setLinesVisible(true);
 322                 table.setHeaderVisible(true);
 323
 324                 TableViewerColumn column;
 325                 // int offset = 0;
 326                 if (hasSelectionColumn) {
 327                         // offset = 1;
 328                         column = ViewerUtils.createTableViewerColumn(viewer, "", SWT.NONE, 25);
 329                         column.setLabelProvider(new ColumnLabelProvider() {
 330                                 private static final long serialVersionUID = 1L;
 331
 332                                 @Override
 333                                 public String getText(Object element) {
 334                                         return null;
 335                                 }
 336                         });
 337                         layout.setColumnData(column.getColumn(), new ColumnWeightData(25, 25, false));
 338
 339                         SelectionAdapter selectionAdapter = new SelectionAdapter() {
 340                                 private static final long serialVersionUID = 1L;
 341
 342                                 boolean allSelected = false;
 343
 344                                 @Override
 345                                 public void widgetSelected(SelectionEvent e) {
 346                                         allSelected = !allSelected;
 347                                         ((CheckboxTableViewer) usersViewer).setAllChecked(allSelected);
 348                                 }
 349                         };
 350                         column.getColumn().addSelectionListener(selectionAdapter);
 351                 }
 352
 353                 // NodeViewerComparator comparator = new NodeViewerComparator();
 354                 // TODO enable the sort by click on the header
 355                 // int i = offset;
 356                 for (ColumnDefinition colDef : columnDefs)
 357                         createTableColumn(viewer, layout, colDef);
 358
 359                 // column = ViewerUtils.createTableViewerColumn(viewer,
 360                 // colDef.getHeaderLabel(), SWT.NONE, colDef.getColumnSize());
 361                 // column.setLabelProvider(new CLProvider(colDef.getPropertyName()));
 362                 // column.getColumn().addSelectionListener(
 363                 // JcrUiUtils.getNodeSelectionAdapter(i,
 364                 // colDef.getPropertyType(), colDef.getPropertyName(),
 365                 // comparator, viewer));
 366                 // i++;
 367                 // }
 368
 369                 // IMPORTANT: initialize comparator before setting it
 370                 // JcrColumnDefinition firstCol = colDefs.get(0);
 371                 // comparator.setColumn(firstCol.getPropertyType(),
 372                 // firstCol.getPropertyName());
 373                 // viewer.setComparator(comparator);
 374
 375                 return viewer;
 376         }
 377
 378         /** Default creation of a column for a user table */
 379         private TableViewerColumn createTableColumn(TableViewer tableViewer, TableColumnLayout layout,
 380                         ColumnDefinition columnDef) {
 381
 382                 boolean resizable = true;
 383                 TableViewerColumn tvc = new TableViewerColumn(tableViewer, SWT.NONE);
 384                 TableColumn column = tvc.getColumn();
 385
 386                 column.setText(columnDef.getLabel());
 387                 column.setWidth(columnDef.getMinWidth());
 388                 column.setResizable(resizable);
 389
 390                 ColumnLabelProvider lp = columnDef.getLabelProvider();
 391                 // add a reference to the display to enable font management
 392                 // if (lp instanceof UserAdminAbstractLP)
 393                 // ((UserAdminAbstractLP) lp).setDisplay(tableViewer.getTable()
 394                 // .getDisplay());
 395                 tvc.setLabelProvider(lp);
 396
 397                 layout.setColumnData(column, new ColumnWeightData(columnDef.getWeight(), columnDef.getMinWidth(), resizable));
 398
 399                 return tvc;
 400         }
 401 }