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))

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()