Xdesk/tkgui/FX3.py

#!/usr/bin/python3

import json
import time
import sys
import copy
import os
import tkinter as tk
import traceback
import _thread as thread

sys.path.insert(0,"/opt/LibreLight/Xdesk/")

gui=None

INIT_OK = 1
IS_GUI = 0

import __main__ as MAIN
import lib.meta as meta
import tool.git as git

CAPTION = "FX3"
title = CAPTION
title += git.get_all()

from lib.cprint import cprint

import lib.libtk as libtk
import lib.libtk2 as libtk2
import lib.zchat as chat

import lib.mytklib as mytklib
import lib.tkevent as tkevent

#import tkgui.draw as draw
import tool.movewin as movewin
movewin.check_is_started("FX3","/opt/LibreLight/Xdesk/tkgui/FX3.py")


console = chat.Client() #port=50001)
def jsend(jdatas):
    jtxt = jdatas
    #jtxt = json.dumps(jtxt)
    #jtxt = jtxt.encode()
    console.send( jtxt ) #b"\00 ")


def _add_space(frame,r,c):
    b = tk.Canvas(frame,bg="black", height=2,bd=0,width=6,highlightthickness=0) #,bd="black")
    b.grid(row=r, column=c, sticky=tk.W+tk.E)
    r+=1
    c=0
    return r,c

def basic():
    for i in range(4):

        k = "GRP:1" #.format(i+1)
        MAIN.meta.fx3_grid[k].val("POS")
        k = "ATTR:1" #.format(i+1)
        MAIN.meta.fx3_grid[k].val("-")
        k = "ATTR:2" #.format(i+1)
        MAIN.meta.fx3_grid[k].val("-")
        k = "ATTR:3" #.format(i+1)
        MAIN.meta.fx3_grid[k].val("-")
        k = "ATTR:4" #.format(i+1)
        MAIN.meta.fx3_grid[k].val("-")



        k = "SIZE:{}".format(i+1)
        MAIN.meta.fx3_grid[k].val(255)
        MAIN.meta.fx3_grid[k].data["init_value"] = 255
        MAIN.meta.fx3_grid[k].data["max"] = 512
        MAIN.meta.fx3_grid[k].data["cycle"] = [0,127,255]

        k = "SPEED:{}".format(i+1)
        MAIN.meta.fx3_grid[k].val(10)
        MAIN.meta.fx3_grid[k].data["init_value"] = 10
        MAIN.meta.fx3_grid[k].data["max"] = 255
        MAIN.meta.fx3_grid[k].data["cycle"] = [0,5,25,30,100,255]

        k = "OFFSET:{}".format(i+1)
        MAIN.meta.fx3_grid[k].val(100)
        MAIN.meta.fx3_grid[k].data["init_value"] = 100
        MAIN.meta.fx3_grid[k].data["inc"] = 25

        k = "WIDTH:{}".format(i+1)
        MAIN.meta.fx3_grid[k].val(25)
        MAIN.meta.fx3_grid[k].data["init_value"] = 25
        MAIN.meta.fx3_grid[k].data["max"] = 100
        MAIN.meta.fx3_grid[k].data["inc"] = 5

        k = "START:{}".format(i+1)
        MAIN.meta.fx3_grid[k].val(0)
        MAIN.meta.fx3_grid[k].data["init_value"] = 0
        MAIN.meta.fx3_grid[k].data["max"] = 255
        MAIN.meta.fx3_grid[k].data["inc"] = 5

        k = "SHUFFLE:{}".format(i+1)
        MAIN.meta.fx3_grid[k].val(0)
        MAIN.meta.fx3_grid[k].data["init_value"] = 0
        MAIN.meta.fx3_grid[k].data["max"] = 2

        k = "DIR:{}".format(i+1)
        MAIN.meta.fx3_grid[k].val(1)
        MAIN.meta.fx3_grid[k].data["init_value"] = 1
        MAIN.meta.fx3_grid[k].data["max"] = 1

        k = "INVERT:{}".format(i+1)
        MAIN.meta.fx3_grid[k].val(1)
        MAIN.meta.fx3_grid[k].data["init_value"] = 1
        MAIN.meta.fx3_grid[k].data["max"] = 1

        k = "BASE:{}".format(i+1)
        MAIN.meta.fx3_grid[k].val(1)
        MAIN.meta.fx3_grid[k].data["init_value"] = 0
        MAIN.meta.fx3_grid[k].data["max"] = 1
        MAIN.meta.fx3_grid[k].data["min"] = -1
basic()

def get_fx3_grid():
    fx3_grid = MAIN.meta.fx3_grid # OptionBuffer()
    out = []
    for k,v in fx3_grid.items(): # re-order fx3_grid to command
        vv = v.val()
        kk,ii = k.split(":")
        ii = int(ii)-1
        if len(out) <= ii: #extand list
            out.append({}) 
        out[ii][kk] = vv 
    return out

def reshape_grid_to_jdata(grid_data1):
    grid_data2 = {}
    for i in grid_data1: 
        attr = i["ATTR"].strip()
        if attr:
            grid_data2[attr] = {"event":"FX3","MODE":"FX","DMX":-11,"DMX-FINE":-99,"FIX":"","ATTR":"","VALUE":None,"FX2":i} 
    return grid_data2

def patch_order_by_fix(patch):
    out={}
    for p in patch:
        ID = p["FIX"]
        out[ID] = p
        #print("patch_order",[ID,p])
    return out

def update_dmx_adresses(grid_data2): 
    patch = get_patch() 
    patch = patch_order_by_fix(patch)
    out=[]
    for i in grid_data2:
        ID = i["FIX"]
        attr = i["ATTR"]
        #print("address",[ID,attr,i,ID in patch])
        if ID in patch:
            v = patch[ID]
            if attr in v["ATTR"]:
                dmx = v["ATTR"][attr]
                i["DMX"]=dmx

            attr += "-FINE"
            if attr in v["ATTR"]:
                dmx = v["ATTR"][attr]
                i["DMX-FINE"]=dmx

        #cprint("333-- FX3:",i,color="yellow")
    return grid_data2

def extract_fixture_list(grid_data3):
    print()
    out = {}
    for k,v in enumerate(grid_data3):
        print("calc_off",k,v)
        if v["FIX"] not in out:
            out[v["FIX"]] = 0
        else:
            out[v["FIX"]] += 1
    return out

def correct_base(grid_data3):
    for k,v in enumerate(grid_data3):
        print("BASE:",[k,v])
        if type(v["FX2"]["BASE"]) not in [int,float]:
            continue

        if v["FX2"]["BASE"] < 0:
            v["FX2"]["BASE"] = "-"
        elif v["FX2"]["BASE"] > 0:
            v["FX2"]["BASE"] = "+"
        else:
            v["FX2"]["BASE"] = "0"

def calculate_offset(grid_data3):
    fix = extract_fixture_list(grid_data3)
    offset = {}
    offset_len = len(fix)-1

    print()
    for i,f in enumerate(fix):

        for k,v in enumerate(grid_data3):
            if f != v["FIX"]:
                continue

            _offset = v["FX2"]["OFFSET"]
            attr = v["ATTR"]
            if attr not in offset:
                offset[attr] = 0
                offset[attr] +=  _offset/offset_len

            nof = round( offset[attr]*i,2 ) # ID
            v["FX2"]["OFFSET"] = nof
            print("x_offset: ",k,v["FIX"],v["ATTR"],offset,nof)

def merge_grid_and_programmer(programmer,grid_data2):
    out=[]

    for k,v in enumerate(programmer):
        attr = v["ATTR"]
        ID = v["ID"]
        print("v",v)
        if attr in grid_data2:
            tmp = copy.deepcopy(grid_data2[attr])
            print(" ",tmp)
            _offset = tmp["FX2"]["OFFSET"]
            tmp["ATTR"] = attr
            tmp["FIX"] = ID
            out.append(tmp)
    return out

def log(x,name="log",color="yellow"):
    print()
    if type(x) in [dict]: #,OrderedDict]:
        for k,v in x.items():
            cprint(name,[k,v],color=color)
    else:
        for k,v in enumerate(x):
            cprint(name,[k,v],color=color)

class tk_event_fx():
    """ global input event Handeler for short cut's ... etc
    """
    def __init__(self,fix,elem,attr=None,data=None,mode=None):
        self.fix = fix
        self.data = data # gui / master
        self.attr = attr
        self.elem = elem
        self.mode = mode
        self.ATTR_GRP = ""

    def command_fx3(self,event,mode=""):
        prm = []
        ct  = ""
        print(" --", self.attr)
        fx3_grid = MAIN.meta.fx3_grid # OptionBuffer()
        if self.attr == "START":

            grid_data1 = get_fx3_grid()

            out = []
            FIX=3001

            grid_data2 = reshape_grid_to_jdata(grid_data1)
            #log(grid_data2,name="0:")

            programmer=get_programmer()
            #log(programmer,name="A:")
            
            grid_data3 = merge_grid_and_programmer(programmer,grid_data2)
            #log(grid_data3,name="B:")

            calculate_offset(grid_data3)
            correct_base(grid_data3)

            out = update_dmx_adresses(grid_data3)
            #log(out,name="C:")

            msg=json.dumps(out).encode("utf-8")
            cprint("SEND FX3:",color="green")
            for i in out:
                cprint(" ", i,color="green")
            #cmd_client.send(msg)
            jsend(msg)

        if self.attr not in fx3_grid:
            fx_data = {}
            if self.attr == "CIRCLE":
                for k,v in fx3_grid.items():
                    if k.startswith("ATTR"):
                        print(self.attr,k,v)
            if self.attr == "PLAY":
                for k,v in fx3_grid.items():
                    vv = v.val()
                    k_name , k_nr = k.split(":")
                    if k_nr not in fx_data:
                        fx_data[k_nr] = {}
                    fx_data[k_nr][k_name] = vv
                    #print("**",k,vv,v)
                    
                for k,v in fx_data.items():
                    print("fx33",k,v)
                    if "ATTR" in v and v["ATTR"] != " ":
                        print("HH",k,v)

            print()
            return
        fx_func = MAIN.meta.OptionBuffer()
        if self.attr.startswith("ATTR:"):
            col = self.attr.split(":")[1]
            fx_func1 = fx3_grid["GRP:"+str(col)]
            GRP = fx_func1.val()
            if GRP != self.ATTR_GRP:
                self.ATTR_GRP = GRP
                fx_func1.val(GRP)
                fx3_grid[self.attr] = MAIN.meta.Optionbuffer_create_ATTR(GRP)
            fx_func = fx3_grid[self.attr] 
            print(fx_func.data)
            fx_func.data["wrap"] = 1
        else: 
            fx_func = fx3_grid[self.attr]
            fx_func.data["wrap"] = 1

        print("func",fx_func,fx_func.val())

        if event.num == 3:
            fx_func.reset()
        elif event.num == 4:
            fx_func.inc()
        elif event.num == 5:
            fx_func.dec()
        v=fx_func.val()
        #print(v)
        #print(self.elem)
        self.elem["text"] = v
        return


    def command(self,event,mode=""):       
        cprint("tkevent.tk_event_fx.command")
        cprint(" ",self.mode)
        prm = None
        ct = None
        if self.mode == "FX-3":
            return self.command_fx3(event,mode=mode)

    def cb(self,event):
        cprint("tkevent.EVENT_fx.cb:",self.attr,self.mode,event,color='yellow')
        cprint(["type",event.type,"num",event.num])
        try:
            change = 0

            if self.mode.startswith("FX"):
                self.command(event)
                return 0

        except Exception as e:
            cprint("== cb EXCEPT",e,color="red")
            cprint("Error on line {}".format(sys.exc_info()[-1].tb_lineno),color="red")
            cprint(''.join(traceback.format_exception(None, e, e.__traceback__)),color="red")
        return 1 


def motion(code="circle"):
    #basic()

    k = "GRP:1" #.format(i+1)
    MAIN.meta.fx3_grid[k].val("POS")
    MAIN.meta.change_grp(name=k,val="POS")
    k = "GRP:2" #.format(i+1)
    MAIN.meta.fx3_grid[k].val("POS")
    MAIN.meta.change_grp(name=k,val="POS")

    k = "GRP:3" #.format(i+1)
    MAIN.meta.fx3_grid[k].val(" ")
    MAIN.meta.change_grp(name=k,val=" ")
    k = "GRP:4" #.format(i+1)
    MAIN.meta.fx3_grid[k].val(" ")
    MAIN.meta.change_grp(name=k,val=" ")
    
    
    k = "ATTR:1" #.format(i+1)
    MAIN.meta.fx3_grid[k].val("PAN")
    k = "ATTR:2" #.format(i+1)
    MAIN.meta.fx3_grid[k].val("TILT")
    k = "ATTR:3" #.format(i+1)
    MAIN.meta.fx3_grid[k].val(" ")
    k = "ATTR:4" #.format(i+1)
    MAIN.meta.fx3_grid[k].val(" ")

    k = "TYPE:1" 
    MAIN.meta.fx3_grid[k].val("sinus")
    k = "TYPE:2" 
    MAIN.meta.fx3_grid[k].val("cosinus")

    k = "WIDTH:1" 
    MAIN.meta.fx3_grid[k].val(255)
    k = "WIDTH:2" 
    MAIN.meta.fx3_grid[k].val(255)
    
    k = "BASE:1" 
    MAIN.meta.fx3_grid[k].val(0)
    k = "BASE:2" 
    MAIN.meta.fx3_grid[k].val(0)

    if code == "circle":

        k = "SIZE:1" 
        MAIN.meta.fx3_grid[k].val(100)
        k = "SIZE:2" 
        MAIN.meta.fx3_grid[k].val(100)


    if code == "pan":

        k = "SIZE:1" 
        MAIN.meta.fx3_grid[k].val(100)
        k = "SIZE:2" 
        MAIN.meta.fx3_grid[k].val(0)

    if code == "tilt":

        k = "SIZE:1" 
        MAIN.meta.fx3_grid[k].val(0)
        k = "SIZE:2" 
        MAIN.meta.fx3_grid[k].val(100)


def size(val=255):
    for i in range(4):
        k = "SIZE:{}".format(i+1)
        kt = "TYPE:{}".format(i+1)
        print("  ",k,val)
        if MAIN.meta.fx3_grid[kt].val() not in ["STATIC","-"]:
            MAIN.meta.fx3_grid[k].val(val)
    __refresh_fx3(_filter="SIZE")

def speed(val=255):
    for i in range(4):
        k = "SPEED:{}".format(i+1)
        kt = "TYPE:{}".format(i+1)
        print("  ",k,val)
        if MAIN.meta.fx3_grid[kt].val() not in ["STATIC","-"]:
            MAIN.meta.fx3_grid[k].val(val)
    __refresh_fx3(_filter="SPEED")

def dim(code="dim"):

    for i in range(1,4+1):
        k = "GRP:" +str(i)
        MAIN.meta.change_grp(name=k,val="BEAM")
        MAIN.meta.fx3_grid[k].val("BEAM")
        k = "ATTR:"+str(i) 
        MAIN.meta.fx3_grid[k].val(" ")

        k = "TYPE:"+str(i) 
        MAIN.meta.fx3_grid[k].val("static")
        k = "WIDTH:"+str(i) 
        MAIN.meta.fx3_grid[k].val(50)
        k = "BASE:"+str(i) 
        MAIN.meta.fx3_grid[k].val(-1)
        k = "SIZE:"+str(i) 
        MAIN.meta.fx3_grid[k].val(0)

    k = "ATTR:1"
    MAIN.meta.fx3_grid[k].val("DIM")


    if code == "dim":
        k = "TYPE:1" 
        MAIN.meta.fx3_grid[k].val("fade")
        k = "SIZE:1" 
        MAIN.meta.fx3_grid[k].val(255)

def rgb(code="red"):
    #basic()
    for i in range(1,4+1):
        k = "GRP:" +str(i)
        MAIN.meta.change_grp(name=k,val="RGB")
        MAIN.meta.fx3_grid[k].val("RGB")

    k = "ATTR:1"
    MAIN.meta.fx3_grid[k].val("RED")
    k = "ATTR:2"
    MAIN.meta.fx3_grid[k].val("GREEN")
    k = "ATTR:3" 
    MAIN.meta.fx3_grid[k].val("BLUE")
    k = "ATTR:4" 
    MAIN.meta.fx3_grid[k].val("WHITE")

    for i in range(1,4+1):
        k = "TYPE:"+str(i) 
        MAIN.meta.fx3_grid[k].val("static")
        k = "WIDTH:"+str(i) 
        MAIN.meta.fx3_grid[k].val(50)
        k = "BASE:"+str(i) 
        MAIN.meta.fx3_grid[k].val(-1)
        k = "SIZE:"+str(i) 
        MAIN.meta.fx3_grid[k].val(0)

    if code == "red":
        k = "TYPE:1" 
        MAIN.meta.fx3_grid[k].val("fade")
        k = "SIZE:1" 
        MAIN.meta.fx3_grid[k].val(255)
    if code == "green":
        k = "TYPE:2" 
        MAIN.meta.fx3_grid[k].val("fade")
        k = "SIZE:2" 
        MAIN.meta.fx3_grid[k].val(255)
    if code == "blue":
        k = "TYPE:3" 
        MAIN.meta.fx3_grid[k].val("fade")
        k = "SIZE:3" 
        MAIN.meta.fx3_grid[k].val(255)
    if code == "magenta":
        k = "TYPE:1" 
        MAIN.meta.fx3_grid[k].val("fade")
        k = "TYPE:3" 
        MAIN.meta.fx3_grid[k].val("fade")
        k = "SIZE:1" 
        MAIN.meta.fx3_grid[k].val(255)
        k = "SIZE:3" 
        MAIN.meta.fx3_grid[k].val(255)

    __refresh_fx3()

def clear():
    basic()

    for i in range(1,4+1):
        k = "GRP:"+str(i) 
        MAIN.meta.fx3_grid[k].val(" ")
        k = "ATTR:"+str(i) 
        MAIN.meta.fx3_grid[k].val(" ")
        k = "TYPE:"+str(i) 
        MAIN.meta.fx3_grid[k].val(" ")


motion("circle")

def _refresh_fx3x(): #frame,c,r,gui,mode="FX"):
    time.sleep(5)
    while 1:
        print("Ö " *22)
        motion("circle")
        time.sleep(3)
        rgb()
        time.sleep(3)
        clear()
        time.sleep(3)
        print("Ö " *22)
        break

def __refresh_fx3(_filter=""):
    ct  = MAIN.meta.fx3 #moves
    prm = MAIN.meta.fx3_prm
    for comm in ct.labels:
        if comm not in ct.elem:
            continue

        b = ct.elem[comm]
        if comm in MAIN.meta.fx3_grid:
            if _filter and _filter != comm:
                continue
        
            #MAIN.meta.fx3_grid[comm].val("X")
            v2 = MAIN.meta.fx3_grid[comm].val()
            v1 = b["text"]
            #if "ATTR" in comm or "GRP" in comm:
            #    print([comm,v1,v2,b])
            if "ATTR" in comm:
                pass #MAIN.meta.fx3_grid[comm].val("PAN")
                #print(MAIN.meta.fx3_grid[comm].data)
            v2 = MAIN.meta.fx3_grid[comm].val()
            v1 = b["text"]
            if "ATTR" in comm or "GRP" in comm:
                pass #print("A",[comm,v1,v2,b])
            if str(v2) != str(v1):
                print(" change")
                #print([comm,b,v1,v2])
                b["text"] = str(v2)

def _refresh_fx3(): #frame,c,r,gui,mode="FX"):
    while 1:
        __refresh_fx3()
        time.sleep(2)

def _draw_fx3(frame,c,r,gui,mode="FX"):
    ct  = MAIN.meta.fx3 #moves
    prm = MAIN.meta.fx3_prm

    for comm in ct.labels:
        print(" draw3",comm)
        if comm == "\n\n":
            b = tk.Label(frame,bg="black", text="-",font=space_font)
            b.grid(row=r, column=c,pady=0,padx=0, sticky=tk.W+tk.E)
            c=0
            r+=1
            continue

        if comm == "\n":
            c=0
            r+=1
            continue
        v=0
        b = tk.Button(frame,bg="lightgrey", text=str(comm),width=6,height=1)

        ct.elem[comm] = b
        ct.val[comm] = 0

        def _XXX(xcb,xcomm,xb):
            def XXX(event=None,**data):
                print("BTN:",xb["text"],xcomm)
                print("xXx "*22)
                print("XXX",event,data)
                if xcomm == "CIRCLE":
                    motion("circle")
                elif xcomm == "PAN":
                    motion("pan")
                elif xcomm == "TILT":
                    motion("tilt")
                elif xcomm == "DIM":
                    dim(code="dim")
                elif xcomm == "RED":
                    rgb("red")
                elif xcomm == "GREEN":
                    rgb("green")
                elif xcomm == "BLUE":
                    rgb("blue")
                elif xcomm == "MAGENTA":
                    rgb("magenta")
                elif xcomm == "MINI":
                    size(25)
                elif xcomm == "SMALL":
                    size(50)
                elif xcomm == "NORMAL":
                    size(100)
                elif xcomm == "BIG":
                    size(255)
                elif xcomm == "SLOW":
                    speed(5)
                elif xcomm == "MID":
                    speed(25)
                elif xcomm == "FAST":
                    speed(80)
                elif xcomm == "TURBO":
                    speed(160)

                xcb(event) #,data)
            return XXX

        _cb = tk_event_fx(fix=0,elem=b,attr=comm,data=gui,mode=mode).cb
        _comm = comm
        _b = b
        XXX = _XXX(_cb,_comm,_b)
        b.bind("<Button>",XXX) 
        #b.bind("<Button>",tkevent.tk_event_fx(fix=0,elem=b,attr=comm,data=gui,mode=mode).cb)

        if comm == "xREC-FX":
            b["bg"] = "grey"
        elif comm == "xFX OFF":
            b["bg"] = "magenta"
        elif comm[:3] == "xFX:" or comm[:3] == "x2D:":
            b["text"] = comm
            b["bg"] = "#ffbf00"

        if comm in ["SHUFFLE:","WING:","BASE:","START:","STOP","OFF"]:  # not implemented !
            b["fg"] = "#aaa"
            b.config(activebackground="#aaa")
            #b.config(activebackground="#bbb")

        if comm in ["SIZE:","WIDTH:","DIR:","WING:","ATTR:","TYPE:","SPEED:","OFFSET:"]: # OK
            b["bg"] = "#bbb"
            b.config(activebackground="#bbb")
            b.config(activeforeground="#bbb")
                    #activeForeground

        if comm == "START": 
            b["bg"] = "orange"
            b.config(activebackground="#dd0")

        if comm in MAIN.meta.fx3_grid:
            fx_func = MAIN.meta.fx3_grid[comm]
            fx_func.data["wrap"] = 1
            #fx_func.inc()
            v=fx_func.val()
            print("3>",[comm,fx_func,v])
            b["text"] = v
            if comm.startswith("TYPE:"): 
                #b["bg"] = "orange"
                #b.config(activebackground="#dd0")
                b["bg"] = "lightgreen"
                b.config(activebackground="#0d0")

            for a in ["SPEED:","SIZE:","START:","OFFSET:"]:
                if comm.startswith(a): 
                    b["bg"] = "lightgreen"
                    b.config(activebackground="#0d0")

        if comm:
            b.grid(row=r, column=c, sticky=tk.W+tk.E)
        c+=1
        if c >=6:
            c=0
            r+=1
    c=0
    r+=1
    return c,r

def _draw_fx(frame,c,r,gui,mode="FX"):
    ct  = None
    prm = None
    if mode=="FX-MAIN":
        ct  = MAIN.meta.fx_main
        prm = MAIN.meta.fx_prm_main

    print("-- draw")
    for comm in ct.labels:
        print(" draw",comm)
        if comm == "\n\n":
            b = tk.Label(frame,bg="black", text="-",font=space_font)
            b.grid(row=r, column=c,pady=0,padx=0, sticky=tk.W+tk.E)
            c=0
            r+=1
            continue

        if comm == "\n":
            c=0
            r+=1
            continue
        v=0
        b = tk.Button(frame,bg="lightgrey", text=str(comm),width=6,height=2)

        ct.elem[comm] = b
        ct.val[comm] = 0
        #b.bind("<Button>",tkevent.tk_event_fx(fix=0,elem=b,attr=comm,data=gui,mode=mode).cb)
        b.bind("<Button>",tk_event_fx(fix=0,elem=b,attr=comm,data=gui,mode=mode).cb)

        if comm == "REC-FX":
            b["bg"] = "grey"
        elif comm == "FX OFF":
            b["bg"] = "magenta"

        b.grid(row=r, column=c, sticky=tk.W+tk.E)

        c+=1
        if c >=6:
            c=0
            r+=1
    c=0
    r+=1
    return c,r

def draw_fx3(gui,xframe):
    frame_fx=xframe
    i=0
    c=0
    r=0
    
    frame = tk.Frame(frame_fx,bg="black")
    frame.pack(fill=tk.X, side=tk.TOP)
   
    # ------------------------------
    b = tk.Button(frame,bg="lightblue", text="FX3",width=6)
    b.grid(row=r, column=c, sticky=tk.W+tk.E)
    c+=1

    _add_space(frame,r,c)
    c,r = _draw_fx(frame,c,r,gui,mode="FX-MAIN")

    r,c=_add_space(frame,r,c)
    c,r = _draw_fx3(frame,c,r,gui,mode="FX-3")



_global_short_key = 1
root = None

cmd_client = chat.Client(port=30003)

try:
    import memcache
    mc = memcache.Client(['127.0.0.1:11211'], debug=0)
    #data = mc.get("MODES")
except:
    mc = None



class MANAGER_X(): # DUMMY
    def __init__(self,*arg,**args):
        print(self,"__init__",arg,args)

    def send(self,nr,*arg,**args): #val=None,xfade=None,event=None,button="",ptfade=None):
        if _global_key_lock:
            return

        print(self,"MASTER",nr,arg,args)
        btn_nr = nr
        v = args["val"]
        
        msg=json.dumps([{"event":"EXEC","EXEC":btn_nr+1,"VAL":v,"NR-KEY":btn_nr}]).encode("utf-8")
        msg=json.dumps([{"event":"XXX","YYY":1,"VAL":12}]).encode("utf-8")
        cprint("SEND MASTER._GO:",msg,color="green")
        cmd_client.send(msg)

import lib.manager as manager
master = manager.MANAGER() #{}


class Modes(): # DUMMY
    def __init__(self,*arg,**args):
        print("Modes.__init__",arg,args)
        self.modes = {}
    def val(self,*arg,**args):
        #print("Modes.val",arg,args)
        pass


class Gui(): # DUMMY
    def __init__(self):
        self.elem_exec = []
        self.elem_meta = [None]*512
        self.old_btn_nr = -1
        self.METAS = []
        for i in range(512):
            self.METAS.append({})

    def _load_meta(self,nr):
        data = {}
        try:
            data = mc.get("EXEC-META-"+str(nr)) 
            data = json.loads(data)
        except Exception as e:
            print("  ER1R mc...",e)
        return data 

    def _refresh_data(self,*arg,**args):
        start = time.time()

        METAS = []
        for i in range(512):
            nr = i #+1
            METAS.append( self._load_meta(nr) )

        self.METAS = METAS

        for nr,b in enumerate( self.elem_exec): #[nr]
            self._refresh_data_single(nr,b,METAS)

        print(__file__.split("/")[-1], "_refresh_data:",int((time.time()-start)*10)/10 )

    def _refresh_data_single(self,nr,b,METAS=None):
        start = time.time()
        no_meta = 0

        if not METAS:
            no_meta = 1
            try:
                data = mc.get("EXEC-META-"+str(nr)) #,json.dumps(index))
                data = json.loads(data)
                self.METAS[nr] = data #.append(data)
                #print(time.time())
                print("     _REFRESH_EXEC_sinusGLE",nr,b,data["LABEL"])
            except Exception as e:
                print("  ER1R mc...",e)

            METAS = self.METAS


#manager = MANAGER() 
#master = MANAGER() 
modes = Modes()
gui  = Gui()
 
root = tk.Tk()
root.maxsize(600,800)

win_title="FX3"
store = movewin.load_all_sdl(win_title)
print(store)
W=380
H=550
POS=[800,200]
if store:
    W = store[-4]
    H = store[-3]
    POS=[store[-2],store[-1]]


root.geometry('%dx%d+%d+%d' % (W, H, POS[0],POS[1]))
root.tk_setPalette(background='#bbb', foreground='black', activeBackground='#aaa', activeForeground="black")
defaultFont = tk.font.nametofont("TkDefaultFont")
defaultFont.configure(family="FreeSans", size=10, weight="bold")

# MAIN MENUE
try:
    ico_path = "/opt/LibreLight/Xdesk/icon/"
    root.iconphoto(False, tk.PhotoImage(file=ico_path+"scribble.png"))
except Exception as e:
    print(" Exception GUIWindowContainer.__init__",e)

xframe = libtk.ScrollFrame(root,width=820,height=400,bd=1,bg="black",head=None,foot=None)
draw_fx3(gui,xframe)

root.title(title) 

root.bind("<Button>",libtk2.tk_event)#
root.bind("<Key>",libtk2.tk_event)#,self.callback)
root.bind("<KeyRelease>",libtk2.tk_event)#,self.callback)
#root.bind("<FocusIn>",libtk2.tk_event)#, on_focus(self.args["title"],"In").cb)
#root.bind("<FocusOut>",libtk2.tk_event)#, on_focus(self.args["title"],"Out").cb)


_global_key_lock = 0
def focus_in(event=None):
    _global_short_key = 0 # protect key-press-repeat
    cmd = "xset -display :0.0 r off"
    print("FOCUS_IN1", cmd)
    os.system(cmd)
    time.sleep(0.3)
    print("FOCUS_IN2", cmd)
    os.system(cmd)
    _global_short_key = 1 # protect key-press-repeat
    time.sleep(0.3)
    _global_key_lock = 0

def focus_out(event=None):
    _global_key_lock = 1
    _global_short_key = 0
    cmd="xset -display :0.0 r rate 240 20"
    print("FOCUS_OUT", cmd)
    #os.system(cmd) # DISABLED 

root.bind("<FocusIn>", focus_in)
root.bind("<FocusOut>", focus_out)

import memcache
try:
    mc = memcache.Client(['127.0.0.1:11211'], debug=0)
except:
    mc = None

def get_programmer():
    if mc is None:
        return

    DATA=mc.get("fix")#cmd)
    out=[]
    for k,v in DATA.items():
        ok=0
        for kk,vv in v["ATTRIBUT"].items():
            if kk.startswith("_"):
                #print(":",k,v,kk,vv)
                continue
            if vv["ACTIVE"]:
                #print(":",k,v,kk,vv)
                #print(k,v,v["NAME"],kk,vv)
                tmp={"ID":k,"NAME":v["NAME"],"ATTR":kk,"NR":vv["NR"]} #,"FX3":vv["FX2"]}
                print("get_programmer:",tmp)
                out.append(tmp)
                ok=1
        if ok:
            print()
    return out

#import memcache
#import json
#mc = memcache.Client(['127.0.0.1:11211'], debug=0)
def get_patch():
    if mc is None:
        return
    index=mc.get("PATCH-INDEX") #index")#cmd)
    index=json.loads(index)
    out = []
    for v in index:
        #print()
        patch=mc.get("PATCH-"+str(v)) #index")#cmd)
        patch=json.loads(patch)
        u =  patch["UNIVERS"] #* 512
        d =  patch["DMX"]
        attr = {}
        for a in patch["ATTRIBUT"]:
            nr =patch["ATTRIBUT"][a]["NR"] 
            if nr <= 0:
                continue
            #print(v,u,d,nr,a)
            if a == "END":
                continue
            if a.startswith("_"):
                continue
            nr = nr + d + u*512
            attr[a] = nr-1
        tmp = {"FIX":v,"UNI":u,"DMX":d,"NR":nr,"ATTR":attr}
        out.append(tmp )
        #print("get_patch",tmp)
    
    return out



def _refr_loop():
    time.sleep(3)
    while 1:
        try:
            gui._refresh_data()
            time.sleep(3)
        except Exception as e:
            print("  ER5R refr_loop()...",e)
            time.sleep(3)
        time.sleep(0.1)

def _refr_loop2():
    time.sleep(3)
    while 1:
        try:
            global root,title
            data = mc.get("MODES")
            title2 = title +"  "+str(data)
            data = json.loads(data)
            #print("MODES",data)
            modes.modes = data

            if root:
                root.title(title2)
            if "S-KEY" in data:
                _global_short_key = 0
                if data["S-KEY"]:
                    _global_short_key = 1

            for k in data:
                #print("title",k)
                for kk in ["RESTART","PRO","EASY","EXIT"]:
                    if kk in str(k):
                        print("RESTART !!! EXIT !!")
                        time.sleep(0.1)
                        root.quit()
                        #sys.exit()

            fx3_line = {}
            for comm,v in MAIN.meta.fx3_grid.items():
                #print(":",comm,v.val())
                if comm.startswith("ATTR:"):
                    fx3_line[comm] = 1 

              
        except Exception as e:
            print("  ER7R mc...",e)
            time.sleep(3)
        time.sleep(0.1)

thread.start_new_thread(_refr_loop,())
thread.start_new_thread(_refr_loop2,())

thread.start_new_thread(_refresh_fx3,())
#thread.start_new_thread(_refresh_fx3x,())

root.mainloop()