diagramResourceOf :: Diagram -> <ReadGraph> Resource
diagramResourceOf d = singleObject d MOD.CompositeToDiagram
-import "Extras/HashMap" as Map
-
"""Constructs a transformation for a diagram element."""
mapDiagramElement :: (a -> <e> b) -> (a -> <e> b) -> (a -> <e> Maybe b) -> (a -> <e> b) -> DiagramElement a -> <e> DiagramElement b
mapDiagramElement mapComponentType mapTerminal mapAttribute mapFlagType diagramElement =
configuration = diagram'
diagram = compositeToDiagram' configuration
hasName = L0.HasName
- componentMap = Map.fromList [ (c `relatedValue` hasName :: String, c)
- | c <- children configuration
- ]
+ componentMap = MMap.fromEntryList [ (c `relatedValue` hasName :: String, c)
+ | c <- children configuration
+ ]
denyByPredicate diagram L0.ConsistsOf
elements = setElements (DiagramInfo diagram configuration componentMap) joinMap elementSpecs
claimRelatedValue diagram DIA.HasModCount
createDiagramR (NewDiagram model path folderType compositeType) joinMap elementSpecs = (runProc do
configuration = createConfiguration ()
diagram = compositeToDiagram' configuration
- elements = setElements (DiagramInfo diagram configuration (Map.create ())) joinMap elementSpecs
+ elements = setElements (DiagramInfo diagram configuration (MMap.create ())) joinMap elementSpecs
claimRelatedValue diagram DIA.HasModCount
(fromInteger (length elements) :: Long)
(configuration, elements)
/*
createJoin :: (Dynamic -> <WriteGraph> Resource) -> Dynamic -> <Proc,WriteGraph> Resource
-createJoin joinMap key = if Map.contains joinMap key
- then Map.unsafeGet joinMap key
+createJoin joinMap key = if MMap.containsKey joinMap key
+ then MMap.unsafeGet joinMap key
else do
j = newEntity [
hasType STR.ConnectionJoin
]
- Map.put joinMap key j
+ MMap.put joinMap key j
j
*/
data DiagramInfo = DiagramInfo
Resource // diagram
Resource // configuration
- (Map.T String Resource) // existing components
+ (MMap.T String Resource) // existing components
"""
Sets the elements of the diagram. Diagram is assumed to be empty,
for (zip elementSpecs elements) setConnectionName
elements
) where
- elementMap = Map.create ()
+ elementMap = MMap.create ()
idRef = ref (0 :: Integer)
isConnectionResource r = isInstanceOf r DIA.Connection
idRef := id + 1
show id
createElement (Component componentType name position properties) = do
- component = if Map.contains componentMap name
- then Map.unsafeGet componentMap name
+ component = if MMap.containsKey componentMap name
+ then MMap.unsafeGet componentMap name
else newEntity [
hasName name,
hasParent configuration,
MOD.ElementToComponent
component
]
- Map.put elementMap name element
+ MMap.put elementMap name element
Just element
newOrMappedElement eName = do
- element = match Map.get elementMap eName with
+ element = match MMap.get elementMap eName with
Just element -> element
Nothing -> newEntity []
- Map.put elementMap eName element
+ MMap.put elementMap eName element
element
createElement (SimpleConnection aName ar bName br _) = do
connection = newEntity [
then do
claim flag DIA.ExternalFlag flag
else ()
- Map.put elementMap name flag
+ MMap.put elementMap name flag
Just flag
createElement (Connection nodeSpecs edges _) = do
connection = newEntity [
hasFont font
]
createElement (Monitor label (Just (MonitorReference componentName suffix)) (MonitorVisuals font strokeWidth hAlign vAlign) position) = do
- match (Map.get elementMap componentName) with
+ match (MMap.get elementMap componentName) with
Nothing -> Nothing // Monitored component is not on the same diagram as the monitor. Not supported by this routine.
Just element -> do
component = singleObject element MOD.ElementToComponent
nodeResources = connectors + routeLines
nodeResourceWithIds = zip nodeResources [0..length nodeResources-1]
edges = runProc do
- rMap = Map.fromList nodeResourceWithIds
+ rMap = MMap.fromEntryList nodeResourceWithIds
edgesOf (node,i) =
[ Edge i j
| r <- node # DIA.AreConnected
- , j = Map.unsafeGet rMap r
+ , j = MMap.unsafeGet rMap r
, j > i ]
concatMap edgesOf nodeResourceWithIds
import "Simantics/DB"
-import "Extras/HashMap" as Map
import "Simantics/Entity"
import "Simantics/Model"
import "Simantics/Diagram"
import "http://www.simantics.org/Modeling-1.2" as MOD
import "http://www.simantics.org/ModelingTemplate2d-1.0" as TMPL
-applyConnectionTypes :: Map.T (DiagramElement Resource) (Resource,Resource) -> <Proc,WriteGraph,ReadGraph> ()
+applyConnectionTypes :: MMap.T (DiagramElement Resource) (Resource,Resource) -> <Proc,WriteGraph,ReadGraph> ()
applyConnectionTypes elementMap =
let
isConnection ((Connection _ _ _),_) = True
isConnection _ = False
- in iter (\(a,(source,target)) -> applyConnectionType target) (filter isConnection (Map.entries elementMap))
+ in iter (\(a,(source,target)) -> applyConnectionType target) (filter isConnection (MMap.entries elementMap))
// ----
-doElementPostProcessing (elementMap :: Map.T (DiagramElement Resource) (Resource,Resource))
+doElementPostProcessing (elementMap :: MMap.T (DiagramElement Resource) (Resource,Resource))
(elementPostProcessing :: DiagramElement Resource -> Resource -> Resource -> <Proc,ReadGraph,WriteGraph> ()) = do
- list = sortByCluster (Map.entries elementMap) (\(a,(source,target)) -> target)
+ list = sortByCluster (MMap.entries elementMap) (\(a,(source,target)) -> target)
iter (\(a,(source,target)) -> elementPostProcessing a source target) list
translateDiagrams (sourceModel :: Model)
(elementPostProcessing :: DiagramElement Resource -> Resource -> Resource -> <Proc,ReadGraph,WriteGraph> ())
(sourceDiagrams :: [Diagram]) = do
- elementMap = Map.create() :: Map.T (DiagramElement Resource) (Resource,Resource)
+ elementMap = MMap.create () :: MMap.T (DiagramElement Resource) (Resource,Resource)
// Join map contains all joins of the model
joinMap = createJoinMap ()
(compositeType :: Resource)
(f :: Diagram -> <ReadGraph> [(DiagramElement Resource,Resource)])
(joinMap :: Dynamic -> <WriteGraph> Resource)
- (elementMap :: Map.T (DiagramElement Resource) (Resource,Resource))
+ (elementMap :: MMap.T (DiagramElement Resource) (Resource,Resource))
(diagramPostProcessing :: Diagram -> Diagram -> <Proc,ReadGraph,WriteGraph> ())
(sourceDiagram :: Diagram) = do
disableDependencies
getTargetDiagram (targetModel :: Model) (sourceDiagram :: Diagram) =
(possibleDiagram targetModel $ pathOf sourceDiagram) :: Maybe Diagram
-store :: Map.T (DiagramElement Resource) (Resource,Resource) -> (DiagramElement Resource) -> Resource -> Resource -> <Proc,WriteGraph,ReadGraph> ()
+store :: MMap.T (DiagramElement Resource) (Resource,Resource) -> (DiagramElement Resource) -> Resource -> Resource -> <Proc,WriteGraph,ReadGraph> ()
store elementMap a b c = do
- Map.put elementMap a (b,c)
+ MMap.put elementMap a (b,c)
()
getTargetComponent (targetDiagram :: Diagram) (sourceComponent :: Resource) =
(compositeType :: Resource)
(f :: Diagram -> <ReadGraph> [(DiagramElement Resource,Resource)])
(joinMap :: Dynamic -> <WriteGraph> Resource)
- (elementMap :: Map.T (DiagramElement Resource) (Resource,Resource)) = do
+ (elementMap :: MMap.T (DiagramElement Resource) (Resource,Resource)) = do
spec = makeSpec targetModel sourceDiagram folderType compositeType
elementSpecs = f sourceDiagram
in1 = (filter (not . isReferring) elementSpecs + filter isReferring elementSpecs)
package org.simantics.scenegraph.g2d.events;
import java.awt.Component;
+import java.awt.GraphicsEnvironment;
import java.awt.dnd.DnDConstants;
import java.awt.dnd.DragGestureEvent;
import java.awt.dnd.DragGestureListener;
import org.simantics.scenegraph.g2d.events.MouseEvent.MouseDragBegin;
import org.simantics.scenegraph.g2d.events.adapter.AWTMouseEventAdapter;
import org.simantics.scenegraph.g2d.events.command.CommandEvent;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
/**
* Delivers events (mouse, key, focus, command, time) to scene graph nodes that
*/
public class NodeEventHandler implements IEventHandler {
+ private static final Logger LOGGER = LoggerFactory.getLogger(NodeEventHandler.class);
+
private static final boolean DEBUG_EVENTS = false;
private static final boolean DEBUG_HANDLER_SORT = false;
*/
protected G2DSceneGraph sg;
- /**
- * For proper initiation of native DnD operations within this AWT-based
- * scenegraph system.
- */
- protected DragSource ds = new DragSource();
-
public NodeEventHandler(G2DSceneGraph sg) {
this.sg = sg;
}
}
public void setRootPane(Component rootPane) {
+ if (GraphicsEnvironment.isHeadless()) {
+ LOGGER.info("Disabling DragSource in headless environments");
+ return;
+ }
+ final DragSource ds = new DragSource();
final DragSourceListener dsl = new DragSourceListener() {
@Override
public void dropActionChanged(DragSourceDragEvent dsde) {
try {
String absoluteModuleName = ModuleUtils.resolveAbsolutePath(moduleName, relativeImport.moduleName);
ImportDeclaration absoluteImport = new ImportDeclaration(
+ relativeImport.location,
absoluteModuleName, relativeImport.localName,
relativeImport.reexport, relativeImport.spec);
- absoluteImport.location = relativeImport.location;
absoluteImports.add(absoluteImport);
} catch (InvalidModulePathException e) {
errorLog.log(relativeImport.location, e.getMessage());
localEnd = begin-end;
return location(begin+localBegin, begin+localEnd);
}
+
+ public static String toString(long location) {
+ if(location == NO_LOCATION)
+ return "NO LOCATION";
+ else
+ return beginOf(location) + "-" + endOf(location);
+ }
}
return Types.metaVar(Kinds.STAR);
}
if(alias != null) {
- if(parameters.length != alias.getArity()) {
+ int arity = alias.getArity();
+ if(parameters.length < arity) {
context.getErrorLog().log(location, "Wrong number of parameters are given to the type alias. Expected " +
- alias.getArity() + " parameters, got " + parameters.length + " parameters.");
+ arity + " parameters, got " + parameters.length + " parameters.");
return Types.metaVar(Kinds.metaVar());
}
- Type[] parameterTypes = new Type[parameters.length];
- for(int i=0;i<parameters.length;++i)
+ Type[] parameterTypes = new Type[arity];
+ for(int i=0;i<arity;++i)
parameterTypes[i] = parameters[i].toType(context, Kinds.metaVar());
- return alias.body.replace(alias.parameters, parameterTypes);
+ Type result = alias.body.replace(alias.parameters, parameterTypes);
+ for(int i=arity;i<parameters.length;++i)
+ result = Types.apply(result, parameters[i].toType(context, Kinds.metaVar()));
+ return result;
}
}
this.spec = DEFAULT_SPEC;
}
+ public ImportDeclaration(long location, String moduleName, String localName, boolean reexport, ImportSpec spec) {
+ this(moduleName, localName, reexport);
+ this.location = location;
+ }
+
public ImportDeclaration(String moduleName, String localName, boolean reexport, ImportSpec spec) {
if(spec == null)
throw new NullPointerException();
import org.simantics.scl.compiler.errors.DoesNotExist;
import org.simantics.scl.compiler.errors.Failable;
import org.simantics.scl.compiler.errors.Failure;
+import org.simantics.scl.compiler.errors.Locations;
import org.simantics.scl.compiler.errors.Success;
import org.simantics.scl.compiler.module.ImportDeclaration;
import org.simantics.scl.compiler.module.Module;
import org.simantics.scl.compiler.types.Types;
import gnu.trove.map.hash.THashMap;
+import gnu.trove.map.hash.TObjectLongHashMap;
import gnu.trove.procedure.TObjectObjectProcedure;
import gnu.trove.set.hash.THashSet;
THashMap<String, ModuleEntry> result = new THashMap<String, ModuleEntry>();
Collection<ImportFailure> failures = null;
- THashSet<String> originalImports = new THashSet<String>();
+ TObjectLongHashMap<String> originalImports = new TObjectLongHashMap<String>();
ArrayList<ImportDeclaration> stack = new ArrayList<ImportDeclaration>(imports.length);
for(ImportDeclaration import_ : imports) {
stack.add(import_);
- originalImports.add(import_.moduleName);
+ originalImports.put(import_.moduleName, import_.location);
}
while(!stack.isEmpty()) {
ImportDeclaration import_ = stack.remove(stack.size()-1);
stack.addAll(compilationResult.getResult().getDependencies());
if(originalImport) {
String deprecation = compilationResult.getResult().getDeprecation();
- if(deprecation != null && compilationContext != null)
- compilationContext.errorLog.logWarning(import_.location, "Deprecated module " + import_.moduleName + (deprecation.isEmpty() ? "." : ": " + deprecation));
+ if(deprecation != null && compilationContext != null) {
+ long location = originalImport ? originalImports.get(import_.moduleName) : Locations.NO_LOCATION;
+ compilationContext.errorLog.logWarning(location, "Deprecated module " + import_.moduleName + (deprecation.isEmpty() ? "." : ": " + deprecation));
+ }
}
}
else {
-import "StandardLibrary" hiding (contains)
+module {
+ deprecated = "Use module MMap instead."
+}
-importJava "gnu.trove.map.hash.THashMap" where
- data T a b
-
- @JavaName "<init>"
- create :: () -> <Proc> T a b
- put :: T a b -> a -> b -> <Proc> Maybe b
- get :: T a b -> a -> <Proc> Maybe b
- @JavaName get
- unsafeGet :: T a b -> a -> <Proc> b
+import "MMap" as MMap
+
+type T = MMap.T
+
+create :: () -> <Proc> T a b
+create = MMap.create
+
+put :: T a b -> a -> b -> <Proc> Maybe b
+put = MMap.put
+
+get :: T a b -> a -> <Proc> Maybe b
+get = MMap.get
+
+unsafeGet :: T a b -> a -> <Proc> b
+unsafeGet = MMap.unsafeGet
- contains :: T a b -> a -> <Proc> Boolean
- size :: T a b -> <Proc> Integer
+contains :: T a b -> a -> <Proc> Boolean
+contains = MMap.containsKey
+
+size :: T a b -> <Proc> Integer
+size = MMap.size
-importJava "org.simantics.scl.osgi.map.HashMapUtils" where
- entries :: T a b -> <Proc> [(a,b)]
+entries :: T a b -> <Proc> [(a,b)]
+entries = MMap.entries
fromList :: [(a,b)] -> <Proc> T a b
-fromList entries = do
- result = create ()
- for entries (\(k,v) -> do put result k v; ())
- result
\ No newline at end of file
+fromList = MMap.fromEntryList
try {
String absoluteModuleName = ModuleUtils.resolveAbsolutePath(moduleName, relativeImport.moduleName);
absoluteImports.add(new ImportDeclaration(
+ relativeImport.location,
absoluteModuleName, relativeImport.localName,
relativeImport.reexport, relativeImport.spec));
} catch (InvalidModulePathException e) {