service/simulator/java/eclipse-plugin/ServiceProviderPlugin/src/oic/simulator/serviceprovider/view/ResourceObserverView.java

   1 package oic.simulator.serviceprovider.view;
   2
   3 import java.util.Iterator;
   4 import java.util.Map;
   5 import java.util.Set;
   6
   7 import oic.simulator.serviceprovider.Activator;
   8 import oic.simulator.serviceprovider.listener.IObserverListChangedUIListener;
   9 import oic.simulator.serviceprovider.listener.IResourceSelectionChangedUIListener;
  10 import oic.simulator.serviceprovider.manager.ResourceManager;
  11 import oic.simulator.serviceprovider.resource.ObserverDetail;
  12 import oic.simulator.serviceprovider.resource.SimulatorResource;
  13 import oic.simulator.serviceprovider.utils.Constants;
  14
  15 import org.eclipse.jface.viewers.CellEditor;
  16 import org.eclipse.jface.viewers.CheckboxCellEditor;
  17 import org.eclipse.jface.viewers.ColumnLabelProvider;
  18 import org.eclipse.jface.viewers.EditingSupport;
  19 import org.eclipse.jface.viewers.IStructuredContentProvider;
  20 import org.eclipse.jface.viewers.StyledCellLabelProvider;
  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.jface.viewers.ViewerCell;
  25 import org.eclipse.swt.SWT;
  26 import org.eclipse.swt.graphics.Image;
  27 import org.eclipse.swt.layout.GridData;
  28 import org.eclipse.swt.layout.GridLayout;
  29 import org.eclipse.swt.widgets.Composite;
  30 import org.eclipse.swt.widgets.Display;
  31 import org.eclipse.swt.widgets.Table;
  32 import org.eclipse.ui.part.ViewPart;
  33
  34 public class ResourceObserverView extends ViewPart {
  35     public static final String                  VIEW_ID       = "oic.simulator.serviceprovider.view.observer";
  36
  37     private TableViewer                         tblViewer;
  38
  39     private final String[]                      columnHeaders = {
  40             "Client Address", "Port", "Notify"               };
  41
  42     private final Integer[]                     columnWidth   = { 150, 75, 50 };
  43
  44     private IResourceSelectionChangedUIListener resourceSelectionChangedListener;
  45
  46     private IObserverListChangedUIListener      resourceObserverListChangedListener;
  47
  48     private ResourceManager                     resourceManagerRef;
  49
  50     public ResourceObserverView() {
  51
  52         resourceManagerRef = Activator.getDefault().getResourceManager();
  53
  54         resourceSelectionChangedListener = new IResourceSelectionChangedUIListener() {
  55
  56             @Override
  57             public void onResourceSelectionChange() {
  58                 Display.getDefault().asyncExec(new Runnable() {
  59
  60                     @Override
  61                     public void run() {
  62                         if (null != tblViewer) {
  63                             changeButtonStatus();
  64                             updateViewer(getData(resourceManagerRef
  65                                     .getCurrentResourceInSelection()));
  66                         }
  67                     }
  68                 });
  69             }
  70         };
  71
  72         resourceObserverListChangedListener = new IObserverListChangedUIListener() {
  73
  74             @Override
  75             public void onObserverListChanged(final String resourceURI) {
  76                 Display.getDefault().asyncExec(new Runnable() {
  77
  78                     @Override
  79                     public void run() {
  80                         if (null == resourceURI) {
  81                             return;
  82                         }
  83                         SimulatorResource resource = resourceManagerRef
  84                                 .getCurrentResourceInSelection();
  85                         if (null == resource) {
  86                             return;
  87                         }
  88                         if (resource.getResourceURI().equals(resourceURI)) {
  89                             if (null != tblViewer) {
  90                                 updateViewer(getData(resource));
  91                             }
  92                         }
  93                     }
  94                 });
  95
  96             }
  97         };
  98     }
  99
 100     private Map<Integer, ObserverDetail> getData(SimulatorResource resource) {
 101         if (null == resource) {
 102             return null;
 103         }
 104         return resource.getObserver();
 105     }
 106
 107     private void updateViewer(Map<Integer, ObserverDetail> observer) {
 108         if (null != tblViewer) {
 109             Table tbl = tblViewer.getTable();
 110             if (null != observer && observer.size() > 0) {
 111                 tblViewer.setInput(observer.entrySet().toArray());
 112                 if (!tbl.isDisposed()) {
 113                     tbl.setLinesVisible(true);
 114                 }
 115             } else {
 116                 if (!tbl.isDisposed()) {
 117                     tbl.removeAll();
 118                     tbl.setLinesVisible(false);
 119                 }
 120             }
 121         }
 122     }
 123
 124     @Override
 125     public void createPartControl(Composite parent) {
 126         parent.setLayout(new GridLayout(1, false));
 127
 128         tblViewer = new TableViewer(parent, SWT.SINGLE | SWT.H_SCROLL
 129                 | SWT.V_SCROLL | SWT.FULL_SELECTION | SWT.BORDER);
 130
 131         createColumns(tblViewer);
 132
 133         // make lines and header visible
 134         final Table table = tblViewer.getTable();
 135         table.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
 136         table.setHeaderVisible(true);
 137         table.setLinesVisible(true);
 138
 139         tblViewer.setContentProvider(new ObserverContentProvider());
 140
 141         addManagerListeners();
 142
 143         // Check whether there is any resource selected already
 144         Map<Integer, ObserverDetail> observerList = getData(resourceManagerRef
 145                 .getCurrentResourceInSelection());
 146         if (null != observerList) {
 147             updateViewer(observerList);
 148         }
 149     }
 150
 151     public void createColumns(TableViewer tableViewer) {
 152         TableViewerColumn addressColumn = new TableViewerColumn(tableViewer,
 153                 SWT.NONE);
 154         addressColumn.getColumn().setWidth(columnWidth[0]);
 155         addressColumn.getColumn().setText(columnHeaders[0]);
 156         addressColumn.setLabelProvider(new StyledCellLabelProvider() {
 157             @Override
 158             public void update(ViewerCell cell) {
 159                 Object element = cell.getElement();
 160                 if (element instanceof Map.Entry) {
 161                     @SuppressWarnings("unchecked")
 162                     Map.Entry<Integer, ObserverDetail> observer = (Map.Entry<Integer, ObserverDetail>) element;
 163                     cell.setText(observer.getValue().getObserverInfo()
 164                             .getAddress());
 165                 }
 166             }
 167         });
 168
 169         TableViewerColumn portColumn = new TableViewerColumn(tableViewer,
 170                 SWT.NONE);
 171         portColumn.getColumn().setWidth(columnWidth[1]);
 172         portColumn.getColumn().setText(columnHeaders[1]);
 173         portColumn.setLabelProvider(new StyledCellLabelProvider() {
 174             @Override
 175             public void update(ViewerCell cell) {
 176                 Object element = cell.getElement();
 177                 if (element instanceof Map.Entry) {
 178                     @SuppressWarnings("unchecked")
 179                     Map.Entry<Integer, ObserverDetail> observer = (Map.Entry<Integer, ObserverDetail>) element;
 180                     cell.setText(String.valueOf(observer.getValue()
 181                             .getObserverInfo().getPort()));
 182                 }
 183             }
 184         });
 185
 186         TableViewerColumn notifyColumn = new TableViewerColumn(tableViewer,
 187                 SWT.NONE);
 188         notifyColumn.getColumn().setWidth(columnWidth[2]);
 189         notifyColumn.getColumn().setText(columnHeaders[2]);
 190         notifyColumn.setLabelProvider(new ColumnLabelProvider() {
 191
 192             @Override
 193             public String getText(Object element) {
 194                 return "";
 195             }
 196
 197             @Override
 198             public Image getImage(Object element) {
 199                 @SuppressWarnings("unchecked")
 200                 Map.Entry<Integer, ObserverDetail> observer = (Map.Entry<Integer, ObserverDetail>) element;
 201                 if (observer.getValue().isClicked()) {
 202                     return Activator.getDefault().getImageRegistry()
 203                             .get(Constants.NOTIFY_BUTTON_SELECTED);
 204                 }
 205                 return Activator.getDefault().getImageRegistry()
 206                         .get(Constants.NOTIFY_BUTTON_UNSELECTED);
 207             }
 208         });
 209         notifyColumn.setEditingSupport(new NotifyEditor(tableViewer));
 210     }
 211
 212     private void addManagerListeners() {
 213         resourceManagerRef
 214                 .addResourceSelectionChangedUIListener(resourceSelectionChangedListener);
 215         resourceManagerRef
 216                 .addObserverListChangedUIListener(resourceObserverListChangedListener);
 217     }
 218
 219     class ObserverContentProvider implements IStructuredContentProvider {
 220
 221         @Override
 222         public void dispose() {
 223         }
 224
 225         @Override
 226         public void inputChanged(Viewer arg0, Object arg1, Object arg2) {
 227         }
 228
 229         @Override
 230         public Object[] getElements(Object element) {
 231             return (Object[]) element;
 232         }
 233
 234     }
 235
 236     class NotifyEditor extends EditingSupport {
 237
 238         private final TableViewer viewer;
 239
 240         public NotifyEditor(TableViewer viewer) {
 241             super(viewer);
 242             this.viewer = viewer;
 243         }
 244
 245         @Override
 246         protected boolean canEdit(Object arg0) {
 247             return true;
 248         }
 249
 250         @Override
 251         protected CellEditor getCellEditor(Object element) {
 252             return new CheckboxCellEditor(null, SWT.CHECK | SWT.READ_ONLY);
 253         }
 254
 255         @Override
 256         protected Object getValue(Object element) {
 257             System.out.println("getValue()");
 258             @SuppressWarnings("unchecked")
 259             Map.Entry<Integer, ObserverDetail> observer = (Map.Entry<Integer, ObserverDetail>) element;
 260             return observer.getValue().isClicked();
 261         }
 262
 263         @Override
 264         protected void setValue(Object element, Object value) {
 265             System.out.println("setValue()");
 266             // Change the button status of all the resources
 267             changeButtonStatus();
 268
 269             @SuppressWarnings("unchecked")
 270             Map.Entry<Integer, ObserverDetail> observer = (Map.Entry<Integer, ObserverDetail>) element;
 271             observer.getValue().setClicked(true);
 272             viewer.refresh();
 273
 274             // Call Native Method
 275             resourceManagerRef.notifyObserverRequest(
 276                     resourceManagerRef.getCurrentResourceInSelection(),
 277                     observer.getValue().getObserverInfo().getId());
 278         }
 279     }
 280
 281     private void changeButtonStatus() {
 282         SimulatorResource resource = resourceManagerRef
 283                 .getCurrentResourceInSelection();
 284         if (null == resource) {
 285             return;
 286         }
 287         Map<Integer, ObserverDetail> observerMap = resource.getObserver();
 288         if (null == observerMap) {
 289             return;
 290         }
 291         Set<Integer> keySet = observerMap.keySet();
 292         Iterator<Integer> itr = keySet.iterator();
 293         while (itr.hasNext()) {
 294             observerMap.get(itr.next()).setClicked(false);
 295         }
 296     }
 297
 298     @Override
 299     public void dispose() {
 300         // Unregister the listener
 301         if (null != resourceSelectionChangedListener) {
 302             resourceManagerRef
 303                     .removeResourceSelectionChangedUIListener(resourceSelectionChangedListener);
 304         }
 305
 306         if (null != resourceObserverListChangedListener) {
 307             resourceManagerRef
 308                     .removeObserverListChangedUIListener(resourceObserverListChangedListener);
 309         }
 310         super.dispose();
 311     }
 312
 313     @Override
 314     public void setFocus() {
 315     }
 316
 317 }