service/simulator/java/eclipse-plugin/ClientControllerPlugin/src/oic/simulator/clientcontroller/view/AttributeEditingSupport.java

   1 /*
   2  * Copyright 2015 Samsung Electronics All Rights Reserved.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package oic.simulator.clientcontroller.view;
  18
  19 import java.util.List;
  20
  21 import oic.simulator.clientcontroller.Activator;
  22 import oic.simulator.clientcontroller.manager.ResourceManager;
  23 import oic.simulator.clientcontroller.remoteresource.AttributeElement;
  24 import oic.simulator.clientcontroller.remoteresource.RemoteResource;
  25 import oic.simulator.clientcontroller.utils.AttributeValueBuilder;
  26 import oic.simulator.clientcontroller.utils.Utility;
  27 import oic.simulator.clientcontroller.view.dialogs.PostRequestDialog;
  28
  29 import org.eclipse.jface.dialogs.TitleAreaDialog;
  30 import org.eclipse.jface.viewers.CellEditor;
  31 import org.eclipse.jface.viewers.CheckboxCellEditor;
  32 import org.eclipse.jface.viewers.ComboBoxCellEditor;
  33 import org.eclipse.jface.viewers.EditingSupport;
  34 import org.eclipse.jface.viewers.IStructuredSelection;
  35 import org.eclipse.jface.viewers.TreeViewer;
  36 import org.eclipse.swt.SWT;
  37 import org.eclipse.swt.custom.CCombo;
  38 import org.eclipse.swt.events.ModifyEvent;
  39 import org.eclipse.swt.events.ModifyListener;
  40 import org.eclipse.swt.widgets.MessageBox;
  41 import org.eclipse.swt.widgets.Tree;
  42 import org.eclipse.swt.widgets.TreeItem;
  43 import org.oic.simulator.AttributeValue;
  44 import org.oic.simulator.AttributeValue.TypeInfo;
  45 import org.oic.simulator.AttributeValue.ValueType;
  46 import org.oic.simulator.InvalidArgsException;
  47 import org.oic.simulator.SimulatorResourceAttribute;
  48
  49 /**
  50  * This class provides editing support to the resources attributes table in the
  51  * attributes view.
  52  */
  53 public class AttributeEditingSupport {
  54
  55     private AttributeValueEditor attValueEditor;
  56     private PostRequestEditor    postReqEditor;
  57
  58     public AttributeValueEditor createAttributeValueEditor(TreeViewer viewer,
  59             TitleAreaDialog dialog) {
  60         attValueEditor = new AttributeValueEditor(viewer, dialog);
  61         return attValueEditor;
  62     }
  63
  64     public PostRequestEditor createAutomationEditor(TreeViewer viewer) {
  65         postReqEditor = new PostRequestEditor(viewer);
  66         return postReqEditor;
  67     }
  68
  69     class AttributeValueEditor extends EditingSupport {
  70
  71         private final TreeViewer viewer;
  72         private CCombo           comboBox;
  73         private TitleAreaDialog  dialog;
  74
  75         public AttributeValueEditor(TreeViewer viewer, TitleAreaDialog dialog) {
  76             super(viewer);
  77             this.viewer = viewer;
  78             this.dialog = dialog;
  79         }
  80
  81         @Override
  82         protected boolean canEdit(Object arg0) {
  83             return true;
  84         }
  85
  86         @Override
  87         protected CellEditor getCellEditor(final Object element) {
  88             ResourceManager resourceManager = Activator.getDefault()
  89                     .getResourceManager();
  90
  91             RemoteResource res = resourceManager
  92                     .getCurrentResourceInSelection();
  93             if (null == res) {
  94                 return null;
  95             }
  96
  97             final SimulatorResourceAttribute attribute;
  98             if (!(element instanceof AttributeElement)) {
  99                 return null;
 100             }
 101
 102             final AttributeElement attributeElement = ((AttributeElement) element);
 103             attribute = attributeElement.getSimulatorResourceAttribute();
 104             if (null == attribute) {
 105                 return null;
 106             }
 107
 108             final AttributeValue val = attribute.value();
 109             if (null == val) {
 110                 return null;
 111             }
 112
 113             final TypeInfo type = val.typeInfo();
 114             if (type.mBaseType == ValueType.RESOURCEMODEL) {
 115                 return null;
 116             }
 117
 118             String values[] = null;
 119             List<String> valueSet = resourceManager
 120                     .getAllValuesOfAttribute(attribute);
 121             values = convertListToStringArray(valueSet);
 122
 123             ComboBoxCellEditor comboEditor;
 124             comboEditor = new ComboBoxCellEditor(viewer.getTree(), values);
 125             comboBox = (CCombo) comboEditor.getControl();
 126             comboBox.addModifyListener(new ModifyListener() {
 127
 128                 @Override
 129                 public void modifyText(ModifyEvent event) {
 130                     String newValue = comboBox.getText();
 131
 132                     if (null != newValue && !newValue.isEmpty()) {
 133                         attributeElement.setPostState(true);
 134                     } else {
 135                         attributeElement.setPostState(false);
 136                     }
 137
 138                     if (dialog instanceof PostRequestDialog) {
 139                         viewer.update(attributeElement, null);
 140                     }
 141                 }
 142             });
 143             return comboEditor;
 144         }
 145
 146         @Override
 147         protected Object getValue(Object element) {
 148             int indexOfItem = 0;
 149             SimulatorResourceAttribute att = null;
 150
 151             if (element instanceof AttributeElement) {
 152                 att = ((AttributeElement) element)
 153                         .getSimulatorResourceAttribute();
 154             }
 155
 156             if (att == null) {
 157                 return 0;
 158             }
 159
 160             String valueString = Utility.getAttributeValueAsString(att.value());
 161             List<String> valueSet = Activator.getDefault().getResourceManager()
 162                     .getAllValuesOfAttribute(att);
 163             if (null != valueSet) {
 164                 indexOfItem = valueSet.indexOf(valueString);
 165             }
 166             if (indexOfItem == -1) {
 167                 indexOfItem = 0;
 168             }
 169             return indexOfItem;
 170         }
 171
 172         @Override
 173         protected void setValue(Object element, Object value) {
 174             SimulatorResourceAttribute att = null;
 175             if (element instanceof AttributeElement) {
 176                 att = ((AttributeElement) element)
 177                         .getSimulatorResourceAttribute();
 178             }
 179
 180             if (att == null) {
 181                 return;
 182             }
 183
 184             AttributeValue val = att.value();
 185             if (null == val) {
 186                 return;
 187             }
 188
 189             TypeInfo type = val.typeInfo();
 190
 191             String oldValue = String.valueOf(Utility
 192                     .getAttributeValueAsString(val));
 193             String newValue = comboBox.getText();
 194             if (!oldValue.equals(newValue)) {
 195                 // Get the AttriuteValue from the string
 196                 AttributeValue attValue = AttributeValueBuilder.build(newValue,
 197                         type.mBaseType);
 198                 boolean invalid = false;
 199                 if (null == attValue) {
 200                     invalid = true;
 201                 } else {
 202                     TypeInfo resTypeInfo = attValue.typeInfo();
 203                     if (type.mDepth != resTypeInfo.mDepth
 204                             || type.mType != resTypeInfo.mType
 205                             || type.mBaseType != resTypeInfo.mBaseType) {
 206                         invalid = true;
 207                     }
 208                 }
 209                 if (invalid) {
 210                     MessageBox dialog = new MessageBox(viewer.getTree()
 211                             .getShell(), SWT.ICON_ERROR | SWT.OK);
 212                     dialog.setText("Invalid Value");
 213                     dialog.setMessage("Given value is invalid");
 214                     dialog.open();
 215                 } else {
 216                     updateAttributeValue(att, attValue);
 217                 }
 218             }
 219
 220             viewer.update(element, null);
 221         }
 222
 223         public String[] convertListToStringArray(List<String> values) {
 224             String[] strArr;
 225             if (null != values && values.size() > 0) {
 226                 strArr = values.toArray(new String[1]);
 227             } else {
 228                 strArr = new String[1];
 229             }
 230             return strArr;
 231         }
 232
 233         public void updateAttributeValue(SimulatorResourceAttribute att,
 234                 AttributeValue value) {
 235             IStructuredSelection selection = (IStructuredSelection) viewer
 236                     .getSelection();
 237             if (null == selection) {
 238                 return;
 239             }
 240
 241             Object obj = selection.getFirstElement();
 242             if (null == obj) {
 243                 return;
 244             }
 245
 246             Tree t = viewer.getTree();
 247             TreeItem item = t.getSelection()[0];
 248             if (null == item) {
 249                 return;
 250             }
 251
 252             TreeItem parent = item.getParentItem();
 253             if (null != parent) {
 254                 while (parent.getParentItem() != null) {
 255                     parent = parent.getParentItem();
 256                 }
 257                 Object data = parent.getData();
 258                 ((AttributeElement) data).setPostState(true);
 259             }
 260
 261             if (item.getData() instanceof AttributeElement) {
 262                 AttributeElement attributeElement = (AttributeElement) item
 263                         .getData();
 264                 attributeElement.getSimulatorResourceAttribute()
 265                         .setValue(value);
 266
 267                 parent = item.getParentItem();
 268                 if (null != parent) {
 269                     Object data = parent.getData();
 270                     try {
 271                         ((AttributeElement) data).deepSetChildValue(att);
 272                     } catch (InvalidArgsException e) {
 273                         e.printStackTrace();
 274                     }
 275                 }
 276             }
 277         }
 278     }
 279
 280     class PostRequestEditor extends EditingSupport {
 281
 282         private final TreeViewer viewer;
 283
 284         public PostRequestEditor(TreeViewer viewer) {
 285             super(viewer);
 286             this.viewer = viewer;
 287         }
 288
 289         @Override
 290         protected boolean canEdit(Object arg0) {
 291             return true;
 292         }
 293
 294         @Override
 295         protected CellEditor getCellEditor(Object element) {
 296             SimulatorResourceAttribute att = null;
 297             if (element instanceof AttributeElement) {
 298                 att = ((AttributeElement) element)
 299                         .getSimulatorResourceAttribute();
 300             }
 301
 302             if (null == att) {
 303                 return null;
 304             }
 305
 306             AttributeValue val = att.value();
 307             if (null == val) {
 308                 return null;
 309             }
 310
 311             TypeInfo type = val.typeInfo();
 312
 313             if (type.mType == ValueType.RESOURCEMODEL
 314                     || type.mBaseType == ValueType.RESOURCEMODEL) {
 315                 return null;
 316             }
 317
 318             return new CheckboxCellEditor(null, SWT.CHECK | SWT.READ_ONLY);
 319         }
 320
 321         @Override
 322         protected Object getValue(Object element) {
 323             if (element instanceof AttributeElement) {
 324                 return ((AttributeElement) element).getPostState();
 325             }
 326
 327             return false;
 328         }
 329
 330         @Override
 331         protected void setValue(Object element, Object value) {
 332             if (!(element instanceof AttributeElement)) {
 333                 return;
 334             }
 335             boolean status = (Boolean) value;
 336             ((AttributeElement) element).setPostState(status);
 337             viewer.update(element, null);
 338         }
 339     }
 340 }