Added editable unit for derived properties
[simantics/platform.git] / bundles / org.simantics.modeling.ui / src / org / simantics / modeling / ui / componentTypeEditor / ConfigurationPropertiesSection.java
1 package org.simantics.modeling.ui.componentTypeEditor;
2
3 import java.util.ArrayList;
4 import java.util.Collection;
5 import java.util.Collections;
6 import java.util.HashMap;
7 import java.util.HashSet;
8 import java.util.List;
9 import java.util.Map;
10 import java.util.Set;
11
12 import org.eclipse.jface.dialogs.IDialogSettings;
13 import org.eclipse.jface.layout.GridDataFactory;
14 import org.eclipse.jface.layout.GridLayoutFactory;
15 import org.eclipse.jface.layout.TableColumnLayout;
16 import org.eclipse.jface.resource.ImageDescriptor;
17 import org.eclipse.jface.viewers.ColumnWeightData;
18 import org.eclipse.jface.window.Window;
19 import org.eclipse.swt.SWT;
20 import org.eclipse.swt.custom.TableEditor;
21 import org.eclipse.swt.events.DisposeEvent;
22 import org.eclipse.swt.events.DisposeListener;
23 import org.eclipse.swt.events.MouseAdapter;
24 import org.eclipse.swt.events.MouseEvent;
25 import org.eclipse.swt.events.SelectionAdapter;
26 import org.eclipse.swt.events.SelectionEvent;
27 import org.eclipse.swt.graphics.Color;
28 import org.eclipse.swt.graphics.Rectangle;
29 import org.eclipse.swt.layout.FillLayout;
30 import org.eclipse.swt.widgets.Button;
31 import org.eclipse.swt.widgets.Composite;
32 import org.eclipse.swt.widgets.Control;
33 import org.eclipse.swt.widgets.Shell;
34 import org.eclipse.swt.widgets.Table;
35 import org.eclipse.swt.widgets.TableColumn;
36 import org.eclipse.swt.widgets.TableItem;
37 import org.eclipse.ui.PlatformUI;
38 import org.eclipse.ui.forms.widgets.Form;
39 import org.eclipse.ui.forms.widgets.FormToolkit;
40 import org.eclipse.ui.forms.widgets.Section;
41 import org.simantics.Simantics;
42 import org.simantics.databoard.Bindings;
43 import org.simantics.db.ReadGraph;
44 import org.simantics.db.Resource;
45 import org.simantics.db.WriteGraph;
46 import org.simantics.db.common.CommentMetadata;
47 import org.simantics.db.common.request.ObjectsWithType;
48 import org.simantics.db.common.request.PossibleIndexRoot;
49 import org.simantics.db.common.request.UniqueRead;
50 import org.simantics.db.common.request.WriteRequest;
51 import org.simantics.db.common.utils.NameUtils;
52 import org.simantics.db.exception.DatabaseException;
53 import org.simantics.db.layer0.adapter.CopyHandler2;
54 import org.simantics.db.layer0.adapter.Instances;
55 import org.simantics.db.layer0.util.Layer0Utils;
56 import org.simantics.db.layer0.variable.Variable;
57 import org.simantics.db.layer0.variable.Variables;
58 import org.simantics.layer0.Layer0;
59 import org.simantics.modeling.ui.Activator;
60 import org.simantics.modeling.ui.componentTypeEditor.LiftPropertiesDialog.LiftedProperty;
61 import org.simantics.modeling.userComponent.ComponentTypeCommands;
62 import org.simantics.selectionview.SelectionViewResources;
63 import org.simantics.structural.stubs.StructuralResource2;
64 import org.simantics.utils.datastructures.Pair;
65 import org.slf4j.Logger;
66 import org.slf4j.LoggerFactory;
67
68 public class ConfigurationPropertiesSection implements ComponentTypeViewerSection {
69
70     private static final Logger LOGGER = LoggerFactory.getLogger(ConfigurationPropertiesSection.class);
71     
72     private static final String[] COLUMN_NAMES = 
73             new String[] {"Name", "Type", "Default Value", "Unit", "Range", "Label", "Description"};
74     private static final int[] COLUMN_LENGTHS =
75             new int[] { 120, 100, 100, 50, 100, 100, 100 };
76     private static final int[] COLUMN_WEIGHTS =
77             new int[] { 0, 0, 0, 0, 0, 50, 100 };
78
79     /**
80      * Configuration property table column indexes that are to be considered
81      * immutable when the property relation is immutable. Note that relation
82      * immutability does not make the asserted default value immutable.
83      */
84     private static final int[] IMMUTABLE_COLUMNS_WITH_IMMUTABLE_RELATION =
85         { 0, 1, 3, 4, 5, 6 };
86     
87     ComponentTypeViewerData data;
88     Table table;
89     TableColumn[] columns;
90     TableEditor editor;
91     Button newProperty;
92     Button removeProperty;
93     Button liftProperties;
94
95     boolean hasTypes = false;
96     Button setTypes;
97     
98     Section section;
99     
100     public ConfigurationPropertiesSection(ComponentTypeViewerData data) {
101         this.data = data;
102         FormToolkit tk = data.tk;
103         Form form = data.form;
104         
105         section = tk.createSection(form.getBody(), Section.TITLE_BAR | Section.EXPANDED);
106         section.setLayout(new FillLayout());
107         section.setText("Configuration properties");
108
109         Composite sectionBody = tk.createComposite(section);
110         GridLayoutFactory.fillDefaults().numColumns(2).applyTo(sectionBody);
111         section.setClient(sectionBody);
112
113         Composite tableComposite = tk.createComposite(sectionBody);
114         GridDataFactory.fillDefaults().align(SWT.FILL, SWT.FILL).grab(true, true).applyTo(tableComposite);
115         TableColumnLayout tcl = new TableColumnLayout();
116         tableComposite.setLayout(tcl);
117
118         table = tk.createTable(tableComposite, SWT.MULTI | SWT.FULL_SELECTION | SWT.BORDER);
119         table.setLinesVisible(true);
120         table.setHeaderVisible(true);
121
122         columns = new TableColumn[COLUMN_NAMES.length];
123         for(int i=0;i<COLUMN_NAMES.length;++i) {
124             TableColumn column = new TableColumn(table, SWT.NONE);
125             columns[i] = column;
126             tcl.setColumnData(column, new ColumnWeightData(COLUMN_WEIGHTS[i], COLUMN_LENGTHS[i], true));
127             column.setText(COLUMN_NAMES[i]);
128         }
129
130         // Table editor
131         editor = new TableEditor(table);
132         editor.grabHorizontal = true;
133         editor.grabVertical = true;
134         editor.horizontalAlignment = SWT.LEFT;
135         table.addMouseListener(new MouseAdapter() {
136             @Override
137             public void mouseDown(MouseEvent e) {
138                 // Clean up any previous editor control
139                 Control oldEditor = editor.getEditor();
140                 if (oldEditor != null) oldEditor.dispose();
141
142                 if (data.readOnly)
143                     return;
144
145                 // Relative position
146                 Rectangle tableBounds = table.getClientArea();
147                 int rx = e.x - tableBounds.x;
148                 int ry = e.y - tableBounds.y;
149
150                 // Find cell
151                 TableItem selectedItem = null;
152                 int selectedColumn = -1;
153                 Rectangle selectedItemBounds = null;
154                 for(TableItem item : table.getItems()) {
155                     for(int column = 0;column < COLUMN_NAMES.length;++column) {
156                         Rectangle bounds = item.getBounds(column);
157                         if(bounds.contains(rx, ry)) {
158                             selectedItemBounds = bounds;
159                             selectedItem = item;
160                             selectedColumn = column;
161                             break;
162                         }
163                     }
164                 }
165                 if(selectedItem == null) {
166                     return;
167                 }
168
169                 // Table editor
170                 final int column = selectedColumn; 
171                 final ComponentTypeViewerPropertyInfo propertyInfo = (ComponentTypeViewerPropertyInfo)selectedItem.getData();
172                 final Resource resource = propertyInfo.resource;
173                 switch (column) {
174                 case 0:
175                     data.editName(table, editor, propertyInfo, selectedItem, column, ComponentTypeViewerData.PROPERTY_NAME_PATTERN);
176                     break;
177
178                 case 1:
179                     data.editType(table, editor, propertyInfo, selectedItem, column, true);
180                     break;
181
182                 case 2: {
183                     data.editValue(table, editor, propertyInfo, selectedItem, column, data.readOnly ? null : new StringWriter() {
184                         @Override
185                         public void perform(WriteGraph graph, String newValue) throws DatabaseException {
186                             graph.markUndoPoint();
187                             ComponentTypeCommands.setDefaultValue(graph, data.componentType, propertyInfo.resource, newValue);
188                         }
189                     }, null);
190                 } break;
191
192                 case 3:
193                     data.editUnit(table, editor, propertyInfo, selectedItem, column);
194                     break;
195
196                 case 4:
197                     data.editRange(table, editor, propertyInfo, selectedItem, selectedItemBounds, column);
198                     break;
199
200                 case 5:
201                     data.editValue(table, editor, propertyInfo, selectedItem, column, propertyInfo.immutable ? null : new StringWriter() {
202                         @Override
203                         public void perform(WriteGraph graph, String newValue) throws DatabaseException {
204                             graph.markUndoPoint();
205                             String value = newValue.isEmpty() ? null : newValue;
206                             ComponentTypeCommands.setLabel(graph, resource, value);
207                         }
208                     }, null);
209                     break;
210
211                 case 6:
212                     data.editMultilineText(table, editor, propertyInfo, selectedItem, selectedItemBounds, column, new StringWriter() {
213                         @Override
214                         public void perform(WriteGraph graph, String newValue) throws DatabaseException {
215                             graph.markUndoPoint();
216                             String value = newValue.isEmpty() ? null : newValue;
217                             ComponentTypeCommands.setDescription(graph, resource, value);
218                         }
219                     });
220                     break;
221                 }
222             }
223         });
224
225         // Buttons
226
227         Composite buttons = tk.createComposite(sectionBody);
228         GridDataFactory.fillDefaults().applyTo(buttons);
229         GridLayoutFactory.fillDefaults().applyTo(buttons);
230
231         newProperty = tk.createButton(buttons, "New property", SWT.PUSH);
232         GridDataFactory.fillDefaults().applyTo(newProperty);
233         removeProperty = tk.createButton(buttons, "Remove property", SWT.PUSH);
234         GridDataFactory.fillDefaults().applyTo(removeProperty);
235
236         liftProperties = tk.createButton(buttons, "Lift Properties", SWT.PUSH);
237         GridDataFactory.fillDefaults().applyTo(liftProperties);
238
239         hasTypes = !getTypes().isEmpty();
240         
241         if(hasTypes) {
242             setTypes = tk.createButton(buttons, "Assign Types", SWT.PUSH);
243             GridDataFactory.fillDefaults().applyTo(setTypes);
244         }
245
246         // Actions
247
248         table.addSelectionListener(new SelectionAdapter() {
249             @Override
250             public void widgetSelected(SelectionEvent e) {
251                 TableItem[] sel = table.getSelection();
252                 for (TableItem item : sel) {
253                     ComponentTypeViewerPropertyInfo pi = (ComponentTypeViewerPropertyInfo) item.getData();
254                     if (pi.immutable) {
255                         removeProperty.setEnabled(false);
256                         return;
257                     }
258                 }
259                 removeProperty.setEnabled(true);
260             }
261         });
262
263         newProperty.addSelectionListener(new SelectionAdapter() {
264             @Override
265             public void widgetSelected(SelectionEvent e) {
266                 if(editor.getEditor() != null)
267                     editor.getEditor().dispose();
268                 Simantics.getSession().async(new WriteRequest() {
269                     @Override
270                     public void perform(WriteGraph graph)
271                             throws DatabaseException {
272                         ComponentTypeCommands.createPropertyWithDefaults(graph, data.componentType);
273                     }
274                 });
275             }
276         });
277
278         removeProperty.addSelectionListener(new SelectionAdapter() {
279             @Override
280             public void widgetSelected(SelectionEvent e) {
281                 if(editor.getEditor() != null)
282                     editor.getEditor().dispose();
283                 final List<Resource> propertiesToBeRemoved = 
284                         new ArrayList<>();
285                 for(TableItem item : table.getSelection()) {
286                     ComponentTypeViewerPropertyInfo info = (ComponentTypeViewerPropertyInfo) item.getData();
287                     if (!info.immutable)
288                         propertiesToBeRemoved.add(info.resource);
289                 }
290                 System.out.println("remove " + propertiesToBeRemoved.size() + " resources");
291                 if(!propertiesToBeRemoved.isEmpty())
292                     Simantics.getSession().async(new WriteRequest() {
293                         @Override
294                         public void perform(WriteGraph graph)
295                                 throws DatabaseException {
296                             graph.markUndoPoint();
297                             for(Resource property : propertiesToBeRemoved)
298                                 ComponentTypeCommands.removeProperty(graph, data.componentType, property);
299                         }
300                     });
301             }
302         });
303         
304         liftProperties.addSelectionListener(new SelectionAdapter() {
305             @Override
306             public void widgetSelected(SelectionEvent e) {
307                 
308                 if(editor.getEditor() != null)
309                     editor.getEditor().dispose();
310
311                 try {
312                 
313                     Map<LiftedProperty, Pair<String, ImageDescriptor>> map = Simantics.sync(new UniqueRead<Map<LiftedProperty,Pair<String,ImageDescriptor>>>() {
314     
315                         @Override
316                         public Map<LiftedProperty, Pair<String, ImageDescriptor>> perform(ReadGraph graph) throws DatabaseException {
317                             
318                             Map<LiftedProperty, Pair<String,ImageDescriptor>> map = new HashMap<>(); 
319                             
320                             Layer0 L0 = Layer0.getInstance(graph);
321                             StructuralResource2 STR = StructuralResource2.getInstance(graph);
322                             SelectionViewResources SEL = SelectionViewResources.getInstance(graph);
323     
324                             Resource composite = graph.getPossibleObject(data.componentType, STR.IsDefinedBy);
325                             if(composite == null) return map;
326
327
328                             Set<String> existing = new HashSet<>();
329                             for(Resource predicate : graph.getObjects(data.componentType, L0.DomainOf)) {
330                                 if(graph.isSubrelationOf(predicate, L0.HasProperty)) {
331                                     existing.add(NameUtils.getSafeName(graph, predicate));
332                                 }
333                             }
334                             
335                             for(Resource component : graph.syncRequest(new ObjectsWithType(composite, L0.ConsistsOf, STR.Component))) {
336     
337                                 Resource type = graph.getPossibleType(component, STR.Component);
338                                 if(type == null) continue;
339                                 
340                                 String componentName = NameUtils.getSafeName(graph, component);
341     
342                                 for(Resource predicate : graph.getPredicates(component)) {
343                                     if(graph.isSubrelationOf(predicate, L0.HasProperty)) {
344     
345                                         // Do not list properties shown under other properties
346                                         if(graph.hasStatement(predicate, SEL.IsShownUnder)) continue;
347                                         
348                                         // Do not list properties that are not visible in selection view
349                                         if(!graph.hasStatement(predicate, SEL.HasStandardPropertyInfo)) continue;
350                                         
351                                         // Some properties are explicitly marked as non-liftable
352                                         Boolean canBeLifted = graph.getPossibleRelatedValue(predicate, SEL.canBeLifted, Bindings.BOOLEAN);
353                                         if(canBeLifted != null && !canBeLifted) continue;
354                                         
355                                         String predicateName = NameUtils.getSafeName(graph, predicate);
356                                         if(existing.contains(predicateName)) continue;
357                                         
358                                         String name = componentName + " " + predicateName;
359                                         map.put(new LiftedProperty(component, type, predicate), new Pair<String, ImageDescriptor>(name, null));
360                                         
361                                     }
362                                 }
363                                 
364                             }
365                             
366                             return map;
367                             
368                         }
369     
370                     });
371                     
372                     Shell shell = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell();
373                     LiftPropertiesDialog dialog = new LiftPropertiesDialog(shell, map, "Select properties to lift") {
374                         @Override
375                         protected IDialogSettings getBaseDialogSettings() {
376                             return Activator.getDefault().getDialogSettings();
377                         }
378                     };
379                     if (dialog.open() == Window.OK) {
380                         final Collection<LiftedProperty> _result = dialog.getResultT();
381                         final boolean mapProperties = dialog.getMapProperties();
382                         if (!_result.isEmpty()) {
383                             Simantics.getSession().async(new WriteRequest() {
384                                 public Resource findAssertion(ReadGraph graph, Resource sourceType, Resource predicate) throws DatabaseException {
385                                     Collection<Resource> ass = graph.getAssertedObjects(sourceType, predicate);
386                                     if(ass.size() == 1) return ass.iterator().next();
387                                     return null;
388                                 }
389                                 
390                                 public void processSubs(ReadGraph graph, Resource predicate, Resource component, Resource componentType, List<LiftedProperty> result, List<Resource> properties, List<Resource> assertions) throws DatabaseException {
391                                     SelectionViewResources SEL = SelectionViewResources.getInstance(graph);
392                                     for(Resource sub : graph.getObjects(predicate, SEL.UnderOf)) {
393                                         Resource ass = findAssertion(graph, componentType, sub);
394                                         if(ass == null) continue;
395                                         result.add(new LiftedProperty(component, componentType, sub));
396                                         properties.add(sub);
397                                         assertions.add(ass);
398                                         processSubs(graph, sub, component, componentType, result, properties, assertions);
399                                     }
400                                 }
401                                 
402                                 @Override
403                                 public void perform(WriteGraph graph) throws DatabaseException {
404                                     
405                                     Layer0 L0 = Layer0.getInstance(graph);
406                                     graph.markUndoPoint();
407                                     List<Resource> properties = new ArrayList<>();
408                                     List<Resource> assertions = new ArrayList<>();
409                                     
410                                     List<LiftedProperty> result = new ArrayList<>(); 
411                                     for(LiftedProperty p : _result) {
412                                         Resource ass = findAssertion(graph, p.getComponentType(), p.getPredicate());
413                                         if(ass == null) continue;
414                                         result.add(p);
415                                         properties.add(p.getPredicate());
416                                         assertions.add(ass);
417                                         processSubs(graph, p.getPredicate(), p.getComponent(), p.getComponentType(), result, properties, assertions);
418                                     }
419                                     
420                                     CopyHandler2 ch = Layer0Utils.getPossibleCopyHandler(graph, properties);
421                                     Collection<Resource> copies = Layer0Utils.copyTo(graph, data.componentType, null, ch, null);
422                                     int index = 0;
423                                     for(Resource copy : copies) {
424                                         Resource ass = assertions.get(index);
425                                         LiftedProperty p = result.get(index);
426                                         Collection<Resource> copyAss = Layer0Utils.copyTo(graph, null, ass);
427                                         if(copyAss.size() == 1) {
428                                             graph.deny(copy, L0.HasDomain);
429                                             graph.claim(data.componentType, L0.DomainOf, copy);
430                                             Layer0Utils.assert_(graph, data.componentType, copy, copyAss.iterator().next());
431                                             CommentMetadata cm = graph.getMetadata(CommentMetadata.class);
432                                             graph.addMetadata(cm.add("Lifted property " + NameUtils.getSafeName(graph, copy) + " into "+ NameUtils.getSafeName(graph, data.componentType)));
433                                         }
434                                         if(mapProperties) {
435                                             Variable v = Variables.getVariable(graph, p.getComponent());
436                                             Variable property = v.getProperty(graph, p.getPredicate());
437                                             Variable displayValue = property.getProperty(graph, Variables.DISPLAY_VALUE);
438                                             displayValue.setValue(graph, "=" + NameUtils.getSafeName(graph, p.getPredicate()), Bindings.STRING);
439                                         }
440                                         index++;
441                                     }
442                                     
443                                 }
444                             });
445                         }
446                     }
447
448                 } catch (DatabaseException e1) {
449                     
450                     LOGGER.error("Lifting properties failed", e1);
451                     return;
452                     
453                 }
454                 
455             }
456         });
457
458         if(hasTypes) {
459             
460             setTypes.addSelectionListener(new SelectionAdapter() {
461                 @Override
462                 public void widgetSelected(SelectionEvent e) {
463                     if(editor.getEditor() != null)
464                         editor.getEditor().dispose();
465                     final List<Resource> propertiesToSet = 
466                             new ArrayList<>();
467                     for(TableItem item : table.getSelection())
468                         propertiesToSet.add(((ComponentTypeViewerPropertyInfo)item.getData()).resource);
469                     
470                     if(propertiesToSet.size() != 1) return;
471
472                     Shell shell = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell();
473                     SetTypesDialog page = new SetTypesDialog(shell, getTypes(), "Select user types for property");
474                     if (page.open() == Window.OK) {
475                         final Object[] result = page.getResult();
476                         if (result != null && result.length > 0) {
477                             Simantics.getSession().async(new WriteRequest() {
478                                 @Override
479                                 public void perform(WriteGraph graph)
480                                         throws DatabaseException {
481                                     for(Object type : result) {
482                                         Layer0 L0 = Layer0.getInstance(graph);
483                                         graph.claim(propertiesToSet.get(0), L0.InstanceOf, null, (Resource)type);
484                                     }
485                                 }
486                             });
487                         }
488                     }
489                     
490                 }
491             });
492             
493         }
494
495         table.addDisposeListener(new DisposeListener() {
496             @Override
497             public void widgetDisposed(DisposeEvent e) {
498                 tk.dispose();
499             }
500         });
501     }
502
503     public void update(ComponentTypePropertiesResult result) {
504         if (table.isDisposed())
505             return;
506         
507         // Save old selection
508         Set<ComponentTypeViewerPropertyInfo> selected = new HashSet<>();
509         List<TableItem> selectedItems = new ArrayList<>(selected.size());
510         for (int i : table.getSelectionIndices()) {
511             TableItem item = table.getItem(i);
512             selected.add((ComponentTypeViewerPropertyInfo) item.getData());
513         }
514
515         int topIndex = table.getTopIndex();
516
517         table.removeAll();
518
519         if(editor.getEditor() != null)
520             editor.getEditor().dispose();
521
522         for(ComponentTypeViewerPropertyInfo info : result.getProperties()) {
523             boolean immutable = result.isImmutable() || info.immutable;
524             Color fg = immutable ? table.getDisplay().getSystemColor(SWT.COLOR_DARK_GRAY) : null;
525             if(info.sectionSpecificData != null)
526                 continue;
527
528             TableItem item = new TableItem(table, SWT.NONE);
529
530             item.setText(0, info.name);
531             item.setText(1, info.type);
532             item.setText(2, info.defaultValue);
533             item.setText(3, info.unitString());
534             item.setText(4, info.rangeString());
535             item.setText(5, info.label);
536             item.setText(6, info.description);
537
538             for (int columnIndex : IMMUTABLE_COLUMNS_WITH_IMMUTABLE_RELATION)
539                 item.setForeground(columnIndex, fg);
540
541             item.setData(info);
542
543             if (selected.contains(info))
544                 selectedItems.add(item);
545         }
546
547         // Restore old selection
548         table.setTopIndex(topIndex);
549         table.setSelection(selectedItems.toArray(new TableItem[selectedItems.size()]));
550         table.redraw();
551     }
552     
553     private Map<Resource, Pair<String, ImageDescriptor>> getTypes() {
554         try {
555             return Simantics.getSession().syncRequest(new UniqueRead<Map<Resource, Pair<String, ImageDescriptor>>>() {
556                 @Override
557                 public Map<Resource, Pair<String, ImageDescriptor>> perform(ReadGraph graph)
558                         throws DatabaseException {
559                     StructuralResource2 STR = StructuralResource2.getInstance(graph);
560                     Resource indexRoot = graph.syncRequest(new PossibleIndexRoot(data.componentType));
561                     Instances query = graph.adapt(STR.UserDefinedProperty, Instances.class);
562                     Collection<Resource> types = query.find(graph, indexRoot);
563                     Map<Resource, Pair<String, ImageDescriptor>> result = new HashMap<>();
564                     for(Resource type : types) {
565                         String name = NameUtils.getSafeLabel(graph, type);
566                         result.put(type, new Pair<String, ImageDescriptor>(name, null));
567                     }
568                     return result;
569                 }
570             });
571         } catch (DatabaseException e) {
572             LOGGER.error("Finding UserDefinedProperties failed.", e);
573             return Collections.emptyMap();
574         }
575     }
576
577     @Override
578     public void setReadOnly(boolean readOnly) {
579         boolean e = !readOnly;
580         newProperty.setEnabled(e);
581         removeProperty.setEnabled(e);
582         liftProperties.setEnabled(e);
583     }
584     
585     @Override
586     public Section getSection() {
587         return section;
588     }
589
590     @Override
591     public double getPriority() {
592         return 0;
593     }
594
595     @Override
596     public Object getSectionSpecificData(ReadGraph graph,
597             ComponentTypeViewerPropertyInfo info) throws DatabaseException {
598         return null;
599     }
600
601     @Override
602     public double getDataPriority() {
603         return 0.0;
604     }
605 }