/**
   * Returns a valid instance selection for the current selection of the tree viewer. Returns <code>
   * null</code> if there is none.
   *
   * @return a valid instance selection for the current selection of the tree viewer or <code>null
   *     </code>
   */
  private InstanceSelection getValidSelection() {
    ISelection viewerSelection = treeViewer.getSelection();
    if (!(viewerSelection instanceof ITreeSelection) || viewerSelection.isEmpty()) return null;

    ITreeSelection treeSelection = (ITreeSelection) treeViewer.getSelection();
    TreePath firstPath = treeSelection.getPaths()[0]; // XXX use all paths
    // instead of first
    // only?

    InstanceValidationMessage firstMessage;
    Iterator<InstanceValidationMessage> restIter;

    if (firstPath.getLastSegment() instanceof InstanceValidationMessage) {
      firstMessage = (InstanceValidationMessage) firstPath.getLastSegment();
      restIter = Iterators.emptyIterator();
    } else {
      Collection<InstanceValidationMessage> messages =
          contentProvider.getMessages(treeSelection.getPaths()[0]);
      if (messages.isEmpty()) return null; // shouldn't happen, but doesn't really matter
      restIter = messages.iterator();
      firstMessage = restIter.next();
    }

    InstanceService is = PlatformUI.getWorkbench().getService(InstanceService.class);
    // check first message for valid instance reference
    if (firstMessage.getInstanceReference() == null
        || is.getInstance(firstMessage.getInstanceReference()) == null) return null;

    Set<InstanceReference> references = new HashSet<InstanceReference>();
    references.add(firstMessage.getInstanceReference());
    while (restIter.hasNext()) references.add(restIter.next().getInstanceReference());

    return new DefaultInstanceSelection(references.toArray());
  }
Пример #2
0
    /** @see Widget#dispose() */
    @Override
    public void dispose() {
      SchemaService ss = PlatformUI.getWorkbench().getService(SchemaService.class);
      InstanceService is = PlatformUI.getWorkbench().getService(InstanceService.class);

      ss.removeSchemaServiceListener(schemaListener);
      is.removeListener(instanceListener);

      refreshImage.dispose();

      listeners.clear();

      super.dispose();
    }
Пример #3
0
    /** Update the feature types selection */
    protected void updateTypesSelection() {
      SchemaSpaceID space = getSchemaSpace();

      TypeDefinition lastSelected = null;
      ISelection lastSelection = typeDefinitions.getSelection();
      if (!lastSelection.isEmpty() && lastSelection instanceof IStructuredSelection) {
        lastSelected = (TypeDefinition) ((IStructuredSelection) lastSelection).getFirstElement();
      }

      DataSet dataset = (space == SchemaSpaceID.SOURCE) ? (DataSet.SOURCE) : (DataSet.TRANSFORMED);
      InstanceService is = PlatformUI.getWorkbench().getService(InstanceService.class);

      // get instance types
      List<TypeDefinition> filteredTypes =
          new ArrayList<TypeDefinition>(is.getInstanceTypes(dataset));

      if (filteredTypes.isEmpty()) {
        // if there are no instances present, show all types
        SchemaService ss = PlatformUI.getWorkbench().getService(SchemaService.class);
        filteredTypes =
            new ArrayList<TypeDefinition>(ss.getSchemas(space).getMappingRelevantTypes());
      }

      typeDefinitions.setInput(filteredTypes);

      // select the previously selected type if possible
      TypeDefinition typeToSelect =
          (filteredTypes.contains(lastSelected)) ? (lastSelected) : (null);

      // fallback selection
      if (typeToSelect == null && !filteredTypes.isEmpty()) {
        typeToSelect = filteredTypes.iterator().next();
      }

      if (typeToSelect != null) {
        typeDefinitions.setSelection(new StructuredSelection(typeToSelect));
      }

      boolean enabled = !filteredTypes.isEmpty();
      typeDefinitions.getControl().setEnabled(enabled);
      count.getControl().setEnabled(enabled);

      layout(true, true);

      updateSelection();
    }
Пример #4
0
    /** Update the selection */
    protected void updateSelection() {
      if (!typeDefinitions.getSelection().isEmpty()) {
        TypeDefinition type =
            (TypeDefinition)
                ((IStructuredSelection) typeDefinitions.getSelection()).getFirstElement();

        filterField.setType(type);

        SchemaSpaceID space = getSchemaSpace();

        Integer max = (Integer) ((IStructuredSelection) count.getSelection()).getFirstElement();

        InstanceService is = PlatformUI.getWorkbench().getService(InstanceService.class);

        List<Instance> instanceList = new ArrayList<Instance>();
        DataSet dataset =
            (space == SchemaSpaceID.SOURCE) ? (DataSet.SOURCE) : (DataSet.TRANSFORMED);

        Filter filter = null;
        String filterExpression = filterField.getFilterExpression();
        /*
         * Custom filter handling.
         *
         * FIXME Ultimately this should be done by the filter field
         * instead, which should be able to handle all kinds of
         * registered filters (e.g. also Groovy).
         */
        if (filterExpression.startsWith("id:")) {
          // XXX meta ID "hack"
          String metaFilter = filterExpression.substring("id:".length());
          String[] values = metaFilter.split(",");

          filter =
              new MetaFilter(
                  type, InstanceMetadata.METADATA_ID, new HashSet<>(Arrays.asList(values)));
        } else if (filterExpression.startsWith("source:")) {
          // XXX meta source ID "hack"
          String metaFilter = filterExpression.substring("source:".length());
          String[] values = metaFilter.split(",");

          filter =
              new MetaFilter(
                  type, InstanceMetadata.METADATA_SOURCEID, new HashSet<>(Arrays.asList(values)));
        } else {
          filter = filterField.getFilter();
        }

        InstanceCollection instances = is.getInstances(dataset);
        if (filter != null) {
          instances = instances.select(filter);
        }

        ResourceIterator<Instance> it = instances.iterator();
        try {
          int num = 0;
          while (it.hasNext() && num < max) {
            Instance instance = it.next();
            if (instance.getDefinition().equals(type)) {
              instanceList.add(instance);
              num++;
            }
          }
        } finally {
          it.close();
        }

        selection = instanceList;
        selectedType = type;
      } else {
        selection = null;
        selectedType = null;

        filterField.setType(null);
      }

      for (InstanceSelectionListener listener : listeners) {
        listener.selectionChanged(selectedType, selection);
      }
    }
Пример #5
0
    /** @see Composite#Composite(Composite, int) */
    public InstanceSelectorControl(Composite parent, int style) {
      super(parent, style);

      refreshImage =
          DataViewPlugin.getImageDescriptor("icons/refresh.gif").createImage(); // $NON-NLS-1$

      GridLayout layout = new GridLayout((spaceID == null) ? (4) : (3), false);
      layout.marginHeight = 2;
      layout.marginWidth = 3;
      setLayout(layout);

      // schema type selector
      if (spaceID == null) {
        schemaSpaces = new ComboViewer(this, SWT.READ_ONLY);
        schemaSpaces.setLabelProvider(
            new LabelProvider() {

              @Override
              public String getText(Object element) {
                if (element instanceof SchemaSpaceID) {
                  switch ((SchemaSpaceID) element) {
                    case SOURCE:
                      return Messages.InstanceServiceFeatureSelector_SourceReturnText;
                    case TARGET:
                      return Messages.InstanceServiceFeatureSelector_TargetReturnText;
                    default:
                      return Messages.InstanceServiceFeatureSelector_defaultReturnText;
                  }
                } else {
                  return super.getText(element);
                }
              }
            });
        schemaSpaces.setContentProvider(ArrayContentProvider.getInstance());
        schemaSpaces.setInput(new Object[] {SchemaSpaceID.SOURCE, SchemaSpaceID.TARGET});
        schemaSpaces.setSelection(new StructuredSelection(SchemaSpaceID.SOURCE));
      } else {
        schemaSpaces = null;
      }

      // feature type selector
      typeDefinitions = new ComboViewer(this, SWT.READ_ONLY);
      typeDefinitions.setContentProvider(ArrayContentProvider.getInstance());
      typeDefinitions.setComparator(new DefinitionComparator());
      typeDefinitions.setLabelProvider(new DefinitionLabelProvider(null));
      typeDefinitions.addSelectionChangedListener(
          new ISelectionChangedListener() {

            @Override
            public void selectionChanged(SelectionChangedEvent event) {
              updateSelection();
            }
          });

      // filter field
      filterField =
          new CQLFilterField(
              (selectedType == null) ? (null) : (selectedType), this, SWT.NONE, spaceID);
      filterField.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, false));
      filterField.addListener(
          new PropertyChangeListener() {

            @Override
            public void propertyChange(PropertyChangeEvent evt) {
              if (evt.getPropertyName().equals(TypeFilterField.PROPERTY_FILTER)) {
                updateSelection();
              }
            }
          });

      // refresh button
      /*
       * XXX disabled for now - Button refresh = new Button(this,
       * SWT.PUSH); refresh.setImage(refreshImage);
       * refresh.setToolTipText("Refresh"); refresh.setLayoutData(new
       * GridData(SWT.CENTER, SWT.CENTER, false, false));
       * refresh.addSelectionListener(new SelectionAdapter() {
       *
       * @Override public void widgetSelected(SelectionEvent e) {
       * updateSelection(); }
       *
       * });
       */

      // max count selector
      count = new ComboViewer(this, SWT.READ_ONLY);
      count.setContentProvider(ArrayContentProvider.getInstance());
      count.setInput(
          new Integer[] {
            Integer.valueOf(1),
            Integer.valueOf(2),
            Integer.valueOf(3),
            Integer.valueOf(4),
            Integer.valueOf(5)
          });
      count.setSelection(new StructuredSelection(Integer.valueOf(2)));
      count.addSelectionChangedListener(
          new ISelectionChangedListener() {

            @Override
            public void selectionChanged(SelectionChangedEvent event) {
              updateSelection();
            }
          });

      updateTypesSelection();

      if (schemaSpaces != null) {
        schemaSpaces.addSelectionChangedListener(
            new ISelectionChangedListener() {

              @Override
              public void selectionChanged(SelectionChangedEvent event) {
                updateTypesSelection();
              }
            });
      }

      // service listeners
      SchemaService ss = PlatformUI.getWorkbench().getService(SchemaService.class);
      ss.addSchemaServiceListener(
          schemaListener =
              new SchemaServiceListener() {

                @Override
                public void schemaAdded(SchemaSpaceID spaceID, Schema schema) {
                  final Display display = PlatformUI.getWorkbench().getDisplay();
                  display.syncExec(
                      new Runnable() {

                        @Override
                        public void run() {
                          updateTypesSelection();
                        }
                      });
                }

                @Override
                public void schemasCleared(SchemaSpaceID spaceID) {
                  final Display display = PlatformUI.getWorkbench().getDisplay();
                  display.syncExec(
                      new Runnable() {

                        @Override
                        public void run() {
                          updateTypesSelection();
                        }
                      });
                }

                @Override
                public void mappableTypesChanged(
                    SchemaSpaceID spaceID, Collection<? extends TypeDefinition> types) {
                  final Display display = PlatformUI.getWorkbench().getDisplay();
                  display.syncExec(
                      new Runnable() {

                        @Override
                        public void run() {
                          updateTypesSelection();
                        }
                      });
                }
              });

      InstanceService is = PlatformUI.getWorkbench().getService(InstanceService.class);
      is.addListener(
          instanceListener =
              new InstanceServiceAdapter() {

                @Override
                public void datasetChanged(DataSet dataSet) {
                  final Display display = PlatformUI.getWorkbench().getDisplay();
                  display.syncExec(
                      new Runnable() {

                        @Override
                        public void run() {
                          updateTypesSelection();
                        }
                      });
                }
              });
    }