modelverse/interface/graphical/main.py

from Tkinter import *
from PIL import Image, ImageTk
import tkSimpleDialog

import urllib
import urllib2
import json

import time

sys.path.append("interface/HUTN")
sys.path.append("wrappers")
from modelverse import *

address = "http://127.0.0.1:8001"
taskname = str(random.random())
MAX_WIDTH = 500
MAX_HEIGHT = 500
MM_RENDERED = "MM_rendered_graphical"

init()
login("admin", "admin")

root = Tk()
canvas = Canvas(root, width=MAX_WIDTH, height=MAX_HEIGHT, bg="white")

selected_model = StringVar(root)
selected_mapper = StringVar(root)

mm_buttons = []
available_models = model_list()
available_mappers = []
model_options = OptionMenu(root, selected_model, *[i[0] for i in available_models])
mapper_options = OptionMenu(root, selected_mapper, "", *available_mappers)


def visualize(model):
    print("Visualizing model: " + str(model))
    cache = {}
    hierarchy = {}
    parent = {}

    def findXY(element_id):
        print(cache[element_id])
        x = cache[element_id]["x"]
        y = cache[element_id]["y"]

        while element_id in parent:
            # Has a parent (group), so increment the XY values and keep going
            element_id = parent[element_id]
            x += cache[element_id]["x"]
            y += cache[element_id]["y"]

        return x, y

    for element in model:
        # Determine type of element
        cache[element["id"]] = element
        t = element["type"]

        if t == "contains":
            # Cache the containment links as well
            parent[element["__target"]] = element["__source"]

    # Caches filled, so go over all elements, ignoring groups, and draw them relative to their enclosing groups
    for element in model:
        t = element["type"]
        if t in ["Rectangle", "Ellipse", "Line", "Text", "Figure"]:
            x, y = findXY(element["id"])

        if t == "Rectangle":
            fillColour = element["fillColour"]
            width = element["width"]
            height = element["height"]
            lineWidth = element["lineWidth"]
            lineColour = element["lineColour"]
            print("Coordinates: " + str((x, y, x+width, y+height)))
            canvas.create_rectangle(x, y, x+width, y+height, fill=fillColour, outline=lineColour)
        elif t == "Ellipse":
            fillColour = element["fillColour"]
            width = element["width"]
            height = element["height"]
            lineWidth = element["lineWidth"]
            lineColour = element["lineColour"]
            canvas.create_ellipse(x, y, x+width, y+height, fill=fillColour, outline=lineColour)
        elif t == "Line":
            targetX = element["targetX"]
            targetY = element["targetY"]
            lineWidth = element["lineWidth"]
            lineColour = element["lineColour"]
            canvas.create_line(x, y, targetX, targetY, fill=lineColour, width=lineWidth)
        elif t == "Text":
            lineWidth = element["lineWidth"]
            lineColour = element["lineColour"]
            text = element["text"]
            canvas.create_text(x, y, fill=lineColour, text=text)
        elif t == "Figure":
            # Fetch associated SVG figure
            raise NotImplementedError()

def reset_optionmenu(optionmenu, options, var):
    menu = optionmenu.children["menu"]
    menu.delete(0, "end")
    var.set("")
    for option in options:
        menu.add_command(label=option, command=lambda value=option: var.set(value))

reset_optionmenu(mapper_options, [], selected_mapper)

def read_available_mappers(instance_model):
    # Get instance model's type first, as transformations are defined on the type
    models = dict(model_list())
    type_model = models[instance_model]
    print("Found type model: " + type_model)
    print("Found MM_Rendered model: " + MM_RENDERED)

    # Switch to the core to find all information on megamodel relations
    model_modify("core")

    all_elems = [n for n, t in element_list() if t in ["Model", "ModelTransformation"]]
    all_attrs = {i: read_attrs(i) for i in all_elems}
    model_map = {all_attrs[i]["name"]: i for i in all_attrs}
    print("Got model_map: " + str(model_map))
    a = set([read_association_source(i) for i in read_incoming(model_map[MM_RENDERED], "transformOutput")])
    b = set([read_association_source(i) for i in read_incoming(model_map[type_model], "transformInput")])
    model_exit()

    print("All mappers for this tool: " + str(a))
    print("All transformations for this model: " + str(b))
    mappers = [all_attrs[i]["name"] for i in a & b]
    print("Overlap: " + str(mappers))
    return mappers

class PromptDialog(tkSimpleDialog.Dialog):
    def __init__(self, master, query):
        self.query = query
        tkSimpleDialog.Dialog.__init__(self, master)

    def body(self, master):
        self.entries = []
        for i, q in enumerate(self.query):
            Label(master, text=q).grid(row=i, column=0)
            self.entries.append(Entry(master))
            self.entries[-1].grid(row=i, column=1)
        return self.entries[0]

    def apply(self):
        self.result = {self.query[i]: self.entries[i].get() for i in range(len(self.entries))}

def create_element(t):
    def create_elem():
        print("Create element of type " + str(t))
    return create_elem

def render_model():
    try:
        model_exit()
    except InvalidMode:
        pass
    rendered = model_render(selected_model.get(), selected_mapper.get())

    #TODO visualize rendered model
    print("Rendering model: " + rendered)
    import json
    visualize(json.loads(rendered))

def open_model():
    try:
        model_exit()
    except InvalidMode:
        pass
    print("Opening model: " + selected_model.get())
    available_mappers = read_available_mappers(selected_model.get())
    reset_optionmenu(mapper_options, available_mappers, selected_mapper)

    model_modify(selected_model.get())

    print(types_full())
    available_types = [i[0] for i in types_full() if i[1] == "Class"]

    global mm_buttons
    for button in mm_buttons:
        button.destroy()

    mm_buttons = []
    for i, t in enumerate(available_types):
        mm_buttons.append(Button(root, text=t, command=lambda : create_element(t)))
        mm_buttons[-1].grid(row=1, column=i)

def instantiate_model():
    try:
        model_exit()
    except InvalidMode:
        pass
    d = PromptDialog(root, ["Name:"])
    if d.result is not None:
        name = str(d.result["Name:"])
        print("Creating new model named " + name)
        model_add(name, selected_model.get())
        reset_optionmenu(available_models, model_list())
        selected_model.set(name)
        open_model()

def verify_model():
    try:
        # Exit if necessary
        model_exit()
    except InvalidMode:
        pass
    print(verify(selected_model.get()))

bound_functions = {
    "open": open_model,
    "render": render_model,
    "instantiate": instantiate_model,
    "verify": verify_model,
    }

buttons = []

buttons.append(model_options)
buttons.append(mapper_options)

for k, v in bound_functions.items():
    buttons.append(Button(root, text=k, command=v))

for i, b in enumerate(buttons):
    b.grid(row=0, column=i)

canvas.grid(row=2,column=0,columnspan=len(buttons))

def left_clicked():
    pass

def middle_clicked():
    pass

def right_clicked():
    pass

canvas.bind("<Button-1>", left_clicked)
canvas.bind("<Button-2>", middle_clicked)
canvas.bind("<Button-3>", right_clicked)

root.mainloop()