X-Git-Url: https://gerrit.simantics.org/r/gitweb?a=blobdiff_plain;f=bundles%2Forg.simantics.charts%2Fsrc%2Forg%2Fsimantics%2Fcharts%2Feditor%2FSubscriptionDropParticipant.java;fp=bundles%2Forg.simantics.charts%2Fsrc%2Forg%2Fsimantics%2Fcharts%2Feditor%2FSubscriptionDropParticipant.java;h=c410414d2276a3b2930a00d4938b5b2f6563a837;hb=969bd23cab98a79ca9101af33334000879fb60c5;hp=0000000000000000000000000000000000000000;hpb=866dba5cd5a3929bbeae85991796acb212338a08;p=simantics%2Fplatform.git

diff --git a/bundles/org.simantics.charts/src/org/simantics/charts/editor/SubscriptionDropParticipant.java b/bundles/org.simantics.charts/src/org/simantics/charts/editor/SubscriptionDropParticipant.java
new file mode 100644
index 000000000..c410414d2
--- /dev/null
+++ b/bundles/org.simantics.charts/src/org/simantics/charts/editor/SubscriptionDropParticipant.java
@@ -0,0 +1,290 @@
+/*******************************************************************************
+ * Copyright (c) 2007, 2011 Association for Decentralized Information Management in
+ * Industry THTH ry.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     VTT Technical Research Centre of Finland - initial API and implementation
+ *******************************************************************************/
+package org.simantics.charts.editor;
+
+import java.awt.datatransfer.Transferable;
+import java.awt.datatransfer.UnsupportedFlavorException;
+import java.awt.dnd.DnDConstants;
+import java.awt.dnd.DropTargetDragEvent;
+import java.awt.dnd.DropTargetDropEvent;
+import java.awt.dnd.DropTargetEvent;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+
+import org.eclipse.jface.viewers.ISelection;
+import org.simantics.Simantics;
+import org.simantics.charts.query.AddChartItem;
+import org.simantics.charts.query.ChartItemDescriptor;
+import org.simantics.charts.ui.AddVariableToChartAction;
+import org.simantics.charts.ui.ChartDropActionFactory;
+import org.simantics.charts.ui.ChartVariable;
+import org.simantics.databoard.util.ObjectUtils;
+import org.simantics.db.ReadGraph;
+import org.simantics.db.Resource;
+import org.simantics.db.common.request.UnaryRead;
+import org.simantics.db.exception.DatabaseException;
+import org.simantics.db.layer0.SelectionHints;
+import org.simantics.db.layer0.request.PossibleModel;
+import org.simantics.db.layer0.variable.RVI;
+import org.simantics.db.layer0.variable.Variable;
+import org.simantics.db.layer0.variable.VariableReference;
+import org.simantics.db.layer0.variable.Variables;
+import org.simantics.db.request.Read;
+import org.simantics.g2d.diagram.participant.AbstractDiagramParticipant;
+import org.simantics.g2d.dnd.DragItem;
+import org.simantics.g2d.dnd.IDnDContext;
+import org.simantics.g2d.dnd.IDragItem;
+import org.simantics.g2d.dnd.IDropTargetParticipant;
+import org.simantics.modeling.ModelingResources;
+import org.simantics.modeling.PropertyVariables;
+import org.simantics.modeling.PropertyVariablesImpl;
+import org.simantics.modeling.utils.VariableReferences;
+import org.simantics.ui.dnd.LocalObjectTransfer;
+import org.simantics.ui.dnd.LocalObjectTransferable;
+import org.simantics.ui.selection.WorkbenchSelectionElement;
+import org.simantics.utils.ui.ErrorLogger;
+import org.simantics.utils.ui.ISelectionUtils;
+import org.simantics.utils.ui.dialogs.ShowMessage;
+
+/**
+ * @author Tuukka Lehtonen
+ */
+public class SubscriptionDropParticipant extends AbstractDiagramParticipant implements IDropTargetParticipant { 
+
+    private static class SubscriptionItemDragItem extends DragItem<ChartItemDescriptor> {
+        public SubscriptionItemDragItem(ChartItemDescriptor obj) {
+            super(obj);
+        }
+    }
+
+    private static class VariableReferenceDragItem extends DragItem<VariableReference> {
+        public VariableReferenceDragItem(VariableReference obj) {
+            super(obj);
+        }
+    }
+    
+    Resource container;
+    Resource model;
+
+    public SubscriptionDropParticipant(Resource container) {
+        this.container = container;
+        try {
+			model = Simantics.getSession().sync( new PossibleModel( container ) );
+		} catch (DatabaseException e) {
+		}
+    }
+
+    @Override
+    public void dragEnter(DropTargetDragEvent dtde, IDnDContext dp) {
+        // The transferable doesn't know LOT
+        if (!dtde.isDataFlavorSupported(LocalObjectTransferable.FLAVOR)) {
+            dtde.rejectDrag();
+            return;
+        }
+
+        // The source cannot link, too bad
+        if ((dtde.getSourceActions() & DnDConstants.ACTION_LINK) == 0) {
+            dtde.rejectDrag();
+            return;
+        }
+
+        // Ensure the content is usable
+        try {
+            Transferable t = dtde.getTransferable();
+            Object data = t.getTransferData(LocalObjectTransferable.FLAVOR);
+            data = LocalObjectTransfer.getTransfer().getObject();
+
+            List<IDragItem> items = new ArrayList<IDragItem>();
+
+            final List<Resource> resources = ISelectionUtils.getPossibleKeys(data, SelectionHints.KEY_MAIN, Resource.class);
+            if (!resources.isEmpty()) {
+                // Support SubscriptionItem drags
+                items.addAll( Simantics.getSession().syncRequest(new Read<List<IDragItem>>() {
+                    @Override
+                    public List<IDragItem> perform(ReadGraph graph) throws DatabaseException {
+                        List<IDragItem> result = new ArrayList<IDragItem>();
+                        //Layer0 L0 = Layer0.getInstance(graph);
+                        ModelingResources MOD = ModelingResources.getInstance(graph);
+                        Resource targetModel = graph.syncRequest(new PossibleModel(container));
+                        if (targetModel != null) {
+                            for (Resource r : resources) {
+                            	//System.out.println( graph.getPossibleRelatedValue(r, L0.HasName) );
+                                if (graph.isInstanceOf(r, MOD.Subscription_Item)) {
+                                    Resource model = graph.syncRequest(new PossibleModel(r));
+                                    if (ObjectUtils.objectEquals(targetModel, model))
+                                        result.add( new SubscriptionItemDragItem( AddChartItem.createDescriptor(graph, r) ) );
+                                }
+                            }
+                        }
+                        return result;
+                    }
+                }) );
+            }
+
+            if(data instanceof RVI) {
+
+                VariableReferenceDragItem vrdi = new VariableReferenceDragItem(Simantics.getSession().sync(new UnaryRead<RVI, VariableReference>((RVI)data) {
+                    @Override
+                    public VariableReference perform(ReadGraph graph) throws DatabaseException {
+                        return new VariableReference(parameter, Variables.getDatatype(graph, model, parameter), null);
+                    }
+                }));
+                items.add( vrdi );
+
+            } else {
+                // Variable/PropertyVariable are mutually exclusive
+                List<IDragItem> varItems = null;
+
+                // 1st try Variable
+                final List<Variable> vars2 = ISelectionUtils.getPossibleKeys(data, SelectionHints.KEY_MAIN, Variable.class);
+                if (!vars2.isEmpty()) {
+                    varItems = Simantics.getSession().syncRequest( new Read<List<IDragItem>>() {
+                        @Override
+                        public List<IDragItem> perform(ReadGraph graph) throws DatabaseException {
+                            return toDragItems( graph.syncRequest(VariableReferences.variablesToReferences(model, vars2)) );
+                        }
+                    } );
+                }
+                if (varItems == null || varItems.isEmpty()) {
+                    // Try legacy PropertyVariables
+                    final List<PropertyVariables> vars = ISelectionUtils.getPossibleKeys(data, SelectionHints.KEY_MAIN, PropertyVariables.class);
+                    if (!vars.isEmpty()) {
+                        varItems = Simantics.getSession().syncRequest( new Read<List<IDragItem>>() {
+                            @Override
+                            public List<IDragItem> perform(ReadGraph graph) throws DatabaseException {
+                                List<PropertyVariables> vars2 = PropertyVariablesImpl.resolve(graph, vars);
+                                return toDragItems( graph.syncRequest(VariableReferences.toReferences(model, vars2)) );
+                            }
+                        } );
+                    }
+                }
+                if (varItems != null)
+                    items.addAll(varItems);
+
+                // Try WorkbenchSelectionElement
+                if (data instanceof ISelection) {
+                    final List<WorkbenchSelectionElement> wses = ISelectionUtils.filterSelection((ISelection)data, WorkbenchSelectionElement.class);
+                    if (!wses.isEmpty()) {
+                        items.addAll( Simantics.getSession().syncRequest( new Read<List<IDragItem>>() {
+                            @Override
+                            public List<IDragItem> perform(ReadGraph graph) throws DatabaseException {
+                                List<Variable> wsevars = new ArrayList<Variable>();
+                                ChartVariable av = new ChartVariable(graph);
+                                for(WorkbenchSelectionElement wse : wses) {
+                                    Variable v = wse.getContent(av);
+                                    if(v != null) {
+                                        wsevars.add(v);
+                                    }
+                                }
+                                return toDragItems( graph.syncRequest(VariableReferences.variablesToReferences(model, wsevars)) );
+                            }
+                        } ) );
+                    }
+                }
+            }
+
+            if (items.isEmpty()) {
+                dtde.rejectDrag();
+            } else {
+                // Accept, make sure it is Link
+                for (IDragItem i : items)
+                    dp.add(i);
+                dtde.acceptDrag( DnDConstants.ACTION_LINK );
+            }
+        } catch (UnsupportedFlavorException e) {
+            throw new RuntimeException(e);
+        } catch (IOException e) {
+            ErrorLogger.defaultLogError(e);
+            dtde.rejectDrag();
+        } catch (DatabaseException e) {
+            ErrorLogger.defaultLogError(e);
+            dtde.rejectDrag();
+        }
+    }
+
+    @Override
+    public void dragExit(DropTargetEvent dte, IDnDContext dp) {
+        for (IDragItem i : dp.getItemsByClass(SubscriptionItemDragItem.class))
+            dp.remove(i);
+        for (IDragItem i : dp.getItemsByClass(VariableReferenceDragItem.class))
+            dp.remove(i);
+    }
+
+    @Override
+    public void dragOver(DropTargetDragEvent dtde, IDnDContext dp) {
+    }
+
+    @Override
+    public void drop(DropTargetDropEvent dtde, IDnDContext dp) {
+    	// Subscription Item
+        Collection<SubscriptionItemDragItem> subs = dp.getItemsByClass(SubscriptionItemDragItem.class);
+        if (!subs.isEmpty()) {
+            List<ChartItemDescriptor> cicr = new ArrayList<ChartItemDescriptor>();
+            for (SubscriptionItemDragItem sidi : subs) {
+                cicr.add(sidi.getObject());
+            }
+            ChartDropActionFactory.addPlots(container, cicr, Collections.<Resource>emptySet()).run();
+            dtde.dropComplete(true);
+            return;
+        }
+        
+        // Variable Reference
+        Collection<VariableReferenceDragItem> vrdis = dp.getItemsByClass(VariableReferenceDragItem.class);
+        if (!vrdis.isEmpty()) {
+            List<VariableReference> refs = new ArrayList<VariableReference>();
+            for (VariableReferenceDragItem vrdi : vrdis) {
+                refs.add( vrdi.getObject() );
+            }
+            Resource chart = container;
+            try {
+                AddVariableToChartAction a = new AddVariableToChartAction( chart, null, refs );
+				a.init();
+	            a.run();
+	            dtde.dropComplete(true);
+			} catch (DatabaseException e) {
+				ShowMessage.showError(e.getClass().getName(), e.getMessage());
+	            dtde.dropComplete(true);
+			}
+            return;
+        }
+        
+        dtde.rejectDrop();
+    }
+
+    @Override
+    public void dropActionChanged(DropTargetDragEvent dtde, IDnDContext dp) {
+        dtde.acceptDrag( DnDConstants.ACTION_LINK );
+    }
+
+    @Override
+    public int getAllowedOps() {
+        return DnDConstants.ACTION_LINK;
+    }
+
+    private static List<IDragItem> toDragItems(Collection<VariableReference> references) {
+        List<IDragItem> result = new ArrayList<IDragItem>(references.size());
+        for (VariableReference vr : references) {
+            VariableReferenceDragItem di = new VariableReferenceDragItem( vr );
+            result.add( di );
+        }
+        return result;
+    }
+    
+    @Override
+    public double getPriority() {
+    	return 10.0;
+    }
+
+}
\ No newline at end of file