Added fake MV handler

interface/CBD/main.py

@@ -1,8 +1,12 @@
 from Tkinter import *
+import tkSimpleDialog
+import urllib
+import urllib2
 
 JUMP = 40
 MAX_WIDTH = 20 * JUMP
 MAX_HEIGHT = 20 * JUMP
+address = "http://127.0.0.1:8001"
 
 root = Tk()
 
@@ -11,6 +15,109 @@ canvas.pack()
 
 name = 0
 
+class FakeLayer():
+    def __init__(self, address):
+        self.types = {}
+        self.sources = {}
+        self.targets = {}
+        self.attrs = {}
+
+    def read_available_attributes(self, name):
+        if self.types[name] == "const":
+            return ["value"]
+        else:
+            return []
+
+    def read_attribute(self, name, attr):
+        return self.attr.get(name, {}).get(attr, None)
+
+    def set_attribute(self, name, attr, value):
+        self.attrs[name][attr] = value
+
+    def instantiate_block(self, name, block_type):
+        self.types[name] = block_type
+
+    def instantiate_link(self, name, link_type, source, target):
+        self.types[name] = link_type
+        self.sources[name] = source
+        self.targets[name] = target
+        self.attrs[name] = {}
+
+    def simulate(self):
+        pass
+
+    def step(self):
+        pass
+
+    def pause(self):
+        pass
+
+attribute = []
+available_attrs = []
+simulation = []
+
+def poll(address):
+    while 1:
+        returnvalue = urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "get_output", "username": "CBD_env"}))).read()
+        if returnvalue.startswith("AVL"):
+            available_attrs.append(returnvalue)
+        elif returnvalue.startswith("ATR"):
+            attribute.append(returnvalue)
+        elif returnvalue.startswith("SIM"):
+            simulation.append(returnvalue)
+
+class MvLayer():
+    def __init__(self, address):
+        import threading
+
+        self.address = address
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"CBD_env"', "username": "user_manager"}))).read()
+        threading.Thread(target=poll, args=[address])
+
+    def read_available_attributes(self, name):
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"read_available_attributes"', "username": "CBD_env"}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % name, "username": "CBD_env"}))).read()
+
+        while not available_attrs:
+            time.sleep(0.1)
+        return available_attrs.pop(0)
+
+    def read_attribute(self, name, attr):
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"read_attribute"', "username": "CBD_env"}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % name, "username": "CBD_env"}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % attr, "username": "CBD_env"}))).read()
+
+        while not attribute:
+            time.sleep(0.1)
+        return attribute.pop(0)
+
+    def set_attribute(self, name, attr, value):
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"set_attribute"', "username": "CBD_env"}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % name, "username": "CBD_env"}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % attr, "username": "CBD_env"}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % value, "username": "CBD_env"}))).read()
+
+    def instantiate_block(self, name, block_type):
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"instantiate"', "username": "CBD_env"}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (block_type), "username": "CBD_env"}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (name), "username": "CBD_env"}))).read()
+
+    def instantiate_link(self, name, link_type, source, target):
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"instantiate"', "username": "CBD_env"}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (link_type), "username": "CBD_env"}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (name), "username": "CBD_env"}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (source), "username": "CBD_env"}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (target), "username": "CBD_env"}))).read()
+
+    def simulate(self):
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"simulate"', "username": "CBD_env"}))).read()
+
+    def step(self):
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"step"', "username": "CBD_env"}))).read()
+
+    def pause(self):
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"pause"', "username": "CBD_env"}))).read()
+
 def lower(value):
     return value / JUMP * JUMP
 
@@ -24,23 +131,44 @@ class InterfaceCore():
     mode = ""
     drawn = set()
     refs = dict()
+    mappings = {"+": "AdditionBlock",
+                "-": "NegationBlock",
+               }
+
+    #mv = MvLayer(address)
+    mv = FakeLayer(address)
 
     def set_mode(self, mode):
         self.mode = mode
 
     def clicked(self, event):
-        if self.mode == "":
-            print("Please select a block first")
+        if self.mode not in ["+", "-"]:
+            print("Cannot create something not guaranteed to be block type!")
         else:
-            x = event.x
-            y = event.y
-            r = canvas.create_rectangle(lower(x), lower(y), upper(x), upper(y), fill="white")
-            t = canvas.create_text(avg(lower(x), upper(x)), avg(lower(y), upper(y)), text=self.mode, fill="black")
-            global name
-            b = (lower(x), lower(y), upper(x), upper(y), str(name))
-            self.drawn.add(b)
-            self.refs[str(name)] = [r, t]
-            name += 1
+            if self.find((event.x, event.y)):
+                # Something already there, so don't add, but modify
+                lname = self.find((event.x, event.y))
+
+                attrs = self.mv.read_available_attributes(lname)
+                if not attrs:
+                    print("No attrs to manage!")
+
+                for attr in attrs:
+                    old_value = self.mv.read_attribute(lname, attr)
+                    new_value = tkSimpleDialog.askstring("Attribute modification", attr, initialvalue=old_value)
+                    self.mv.set_attribute(lname, attr, new_value)
+
+            else:
+                global name
+                x = event.x
+                y = event.y
+                self.mv.instantiate_block(str(name), self.mappings[self.mode])
+                r = canvas.create_rectangle(lower(x), lower(y), upper(x), upper(y), fill="white")
+                t = canvas.create_text(avg(lower(x), upper(x)), avg(lower(y), upper(y)), text=self.mode, fill="black")
+                b = (lower(x), lower(y), upper(x), upper(y), str(name))
+                self.drawn.add(b)
+                self.refs[str(name)] = [r, t]
+                name += 1
 
     def find(self, location):
         x, y = location
@@ -61,7 +189,13 @@ class InterfaceCore():
         print("Connect from %s to %s" % (source, target))
 
         if source and target:
-            canvas.create_line(start[0], start[1], end[0], end[1], fill="black", arrow=LAST)
+            if self.mode not in ["Link", "IC"]:
+                print("Cannot create something not guaranteed to be link type!")
+            else:
+                global name
+                self.mv.instantiate_link(str(name), self.mode, source, target)
+                self.refs[str(name)] = [canvas.create_line(start[0], start[1], end[0], end[1], fill="black", arrow=LAST)]
+                name += 1
 
 core = InterfaceCore()
 
@@ -71,6 +205,9 @@ def addition():
 def negation():
     core.set_mode("-")
 
+def link():
+    core.set_mode("Link")
+
 def clicked(event):
     core.clicked(event)
 
@@ -81,9 +218,24 @@ def draw(event):
 def release(event):
     core.draw(start_location, (event.x, event.y))
 
+def simulate():
+    core.mv.simulate()
+
+def step():
+    core.mv.step()
+
+def pause():
+    core.mv.pause()
+
 Button(root, text="+", command=addition).pack()
 Button(root, text="-", command=negation).pack()
 
+Button(root, text="Link", command=link).pack()
+
+Button(root, text="SIM", command=simulate).pack()
+Button(root, text="STEP", command=step).pack()
+Button(root, text="PAUSE", command=pause).pack()
+
 core.canvas = canvas
 
 for i in range(JUMP, MAX_HEIGHT, JUMP):