Xdesk/tkgui/FX3.py

import json
import time
import sys

import tkinter as tk
from tkinter import font

import traceback
import _thread as thread

sys.path.insert(0,"/opt/LibreLight/Xdesk/")
import lib.meta as meta

import dialog
DIALOG = dialog.Dialog()

GLOBAL_old_btn_nr = -1
GLOBAL_mode_on = -1

def refresh_exec_btn(btn_nr):
    global GLOBAL_old_btn_nr 
    nr2= GLOBAL_old_btn_nr
    print()
    print(" refresh_exec_btn:",btn_nr)
    
    time.sleep(0.5)
    nr = btn_nr #+1 #-1
    b = gui.elem_exec[nr]

    print("---")
    gui._refresh_exec_single(nr,b) #,METAS):
    if nr2 >= 0 and nr2 != nr:
        b = gui.elem_exec[nr2]
        gui._refresh_exec_single(nr2,b) #,METAS):

    GLOBAL_old_btn_nr = nr

gui=None
def dialog_cfg_open(btn_nr,META):
    print("META",META)
    cfg = META["CFG"]
    label = META["LABEL"]
    button = cfg["BUTTON"]
    DIALOG._cb = dialog_cb_cfg(btn_nr+1)
    DIALOG.ask_exec_config(str(btn_nr+1),button=button,label=label,cfg=cfg)
    #print("INFO",meta.commands.elem)

def dialog_label_open(btn_nr,META):
    print("META",META)
    cfg    = META["CFG"]
    label  = META["LABEL"]
    button = cfg["BUTTON"]
    DIALOG._cb = dialog_cb_label(btn_nr+1)
    #DIALOG.ask_exec_config(str(btn_nr+1),button=button,label=label,cfg=cfg)
    DIALOG.askstring("LABEL","LABEL EXE:"+str(btn_nr+1),initialvalue=label)
    #print("INFO",meta.commands.elem)

def dialog_cb_cfg(exec_nr): #DAILOG CONFIG CALLBACK
    def _Dcb(*args):
        print("dialog_cb_cfg:",args)
        msg=json.dumps([{"event":"EXEC-CFG","EXEC":exec_nr,"VALUE":255,"DATA":args[0]}]).encode("utf-8")
        cprint("  SEND DIALOG.cb",msg,color="green")
        cmd_client.send(msg)

        thread.start_new_thread(refresh_exec_btn,(exec_nr,))
    return _Dcb

def dialog_cb_label(exec_nr): #DAILOG CONFIG CALLBACK
    def _Dcb(*args):
        cprint("dialog_cb_label:",args,"EXEC_NR:",exec_nr)
        if not args:
            cprint("  dialog_cb args_error !",color="red")
            return
        if args[0] is None:
            cprint("  dialog_cb cancel !",color="red")
            return 
        if "Value" in args[0]:
            DATA = {"Label":args[0]["Value"]}

        msg=json.dumps([{"event":"EXEC-LABEL","EXEC":exec_nr,"VALUE":255,"DATA":DATA}]).encode("utf-8")
        cprint("  SEND DIALOG.cb",msg,color="green")
        cmd_client.send(msg) # send new meta-data

        msg=json.dumps([{"event":"LABEL","EXEC":exec_nr,"VALUE":255,"DATA":{}}]).encode("utf-8")
        cmd_client.send(msg) # diable LABEL mode

        thread.start_new_thread(refresh_exec_btn,(exec_nr,))
    return _Dcb

DIALOG._cb = dialog_cb_cfg(-3)
#d = dialog.Dialog()
#d.ask_exec_config(str(nr+1),button=button,label=label,cfg=cfg)


import __main__ as MAIN

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

import tool.git as git
#CAPTION += git.get_all()

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

INIT_OK = 1
IS_GUI = 0
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


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 _draw_fx3(frame,c,r,gui,mode="FX"):
    ct  = MAIN.meta.fx3 #moves
    prm = MAIN.meta.fx3_prm

    for comm in ct.labels:
        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
        if "PAN/TILT" in comm: 
            b = tk.Button(frame,bg="grey", text=str(comm),width=6,height=1)
        else:
            b = tk.Button(frame,bg="lightgrey", text=str(comm),width=6,height=1)
        if 1:#comm not in ct.elem:
            #comm = comm.replace("\n","")
            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)
        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"
        elif comm[:3] == "xMO:":
            b["text"] = comm 
            b["bg"] = "lightgreen"
        elif comm.startswith( "xSIZE:"):
            b["text"] = "SIZE:\n{:0.0f}".format(prm["SIZE"])
            b["bg"] = "lightgreen"
        elif comm.startswith( "xSPEED:"):
            b["text"] = "SPEED:\n{:0.0f}".format(prm["SPEED"])
            b["bg"] = "lightgreen"
        elif comm.startswith("xSTART:"):
            b["bg"] = "lightgreen"
            b["text"] = "START:\n{:0.0f}".format(prm["START"])
        elif comm.startswith( "xOFFSET:"):
            b["bg"] = "lightgreen"
            b["text"] = "OFFSET:\n{:0.0f}".format(prm["OFFSET"])
        elif comm[:3] == "xBASE:":
            b["bg"] = "lightgreen"
            b["text"] = "BASE:\n{}".format(prm["BASE"])
        elif comm[0] == "M":
            b["text"] = comm 
            b["bg"] = "lightgrey"

        if 1:
            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(fx_func,v)
                b["text"] = v
                if comm.startswith("TYPE:"): 
                    b["bg"] = "orange"
                    b.config(activebackground="#dd0")
                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"):
    if mode=="FX-MAIN":
        ct  = MAIN.meta.fx_main
        prm = MAIN.meta.fx_prm_main
    elif mode=="FX-MOVE":
        ct  = MAIN.meta.fx_moves
        prm = MAIN.meta.fx_prm_move
    elif mode=="FX":
        ct  = MAIN.meta.fx_cfg
        prm = MAIN.meta.fx_prm
    elif mode=="FX-GENERIC":
        ct  = MAIN.meta.fx_generic
        prm = MAIN.meta.fx_prm #_generic
    elif mode=="FX-COLOR":
        ct  = MAIN.meta.fx_color
        prm = MAIN.meta.fx_color #_generic
    else:
        ct = Elem_Container()
        ct.labels =["err"]
        prm = ["err"]

    for comm in ct.labels:
        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
        if "PAN/TILT" in comm: 
            b = tk.Button(frame,bg="grey", text=str(comm),width=6,height=2)
        else:
            b = tk.Button(frame,bg="lightgrey", text=str(comm),width=6,height=2)
        if 1:#comm not in ct.elem:
            #comm = comm.replace("\n","")
            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)
        if comm == "REC-FX":
            b["bg"] = "grey"
        elif comm == "FX OFF":
            b["bg"] = "magenta"
        elif comm[:3] == "FX:" or comm[:3] == "2D:":
            b["text"] = comm
            b["bg"] = "#ffbf00"
        elif comm[:3] == "MO:":
            b["text"] = comm 
            b["bg"] = "lightgreen"
        elif comm.startswith( "SIZE:"):
            b["text"] = "SIZE:\n{:0.0f}".format(prm["SIZE"])
            b["bg"] = "lightgreen"
        elif comm.startswith( "SPEED:"):
            b["text"] = "SPEED:\n{:0.0f}".format(prm["SPEED"])
            b["bg"] = "lightgreen"
        elif comm.startswith("START:"):
            b["bg"] = "lightgreen"
            b["text"] = "START:\n{:0.0f}".format(prm["START"])
        elif comm.startswith( "OFFSET:"):
            b["bg"] = "lightgreen"
            b["text"] = "OFFSET:\n{:0.0f}".format(prm["OFFSET"])
        elif comm[:3] == "BASE:":
            b["bg"] = "lightgreen"
            b["text"] = "BASE:\n{}".format(prm["BASE"])
        elif comm[0] == "M":
            b["text"] = comm 
            b["bg"] = "lightgrey"

        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_fx3(gui,xframe,data=[]):
    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

    thread.start_new_thread(mytklib.tk_btn_bg_loop,(b,))
    # ------------------------------


    _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_fx(frame,c,r,gui,mode="FX-COLOR")

    r,c=_add_space(frame,r,c)
    c,r = _draw_fx3(frame,c,r,gui,mode="FX-3")
import tool.movewin as movewin
#movewin.check_is_started(CAPTION,_file_path)
movewin.check_is_started("FX3","/opt/LibreLight/Xdesk/tkgui/FX3.py")

_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 Refresher(): # DUMMY
    def __init__(self,*arg,**args):
        print(self,"__init__",arg,args)
    def reset(*arg,**args):
        print(self,"reset",arg,args)

class Command():
    def __init__(self):
        self.elem = {}

class MANAGER(): # DUMMY
    def __init__(self,*arg,**args):
        print(self,"__init__",arg,args)
        #self.refresh_fix = Refresher()
        #self.commands = Command()
    def refresh_fix(self,*arg,**args):# = Refresher()
        print(self,"refresh_fix",arg,args)
    def exec_go(self,nr,*arg,**args): #val=None,xfade=None,event=None,button="",ptfade=None):
        if _global_key_lock:
            return
        #def exec_go(nr,xfade=None,val=0):
        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")
        cprint("SEND MASTER.EXEC_GO:",msg,color="green")
        cmd_client.send(msg)

def refresh_fix(*arg,**args): # DUMMY
    print("refresh_fix",arg,args)

class Refresher_fix(): # DUMMY
    def __init__(self,*arg,**args):
        print(self,"init",arg,args)
    def reset(self,*arg,**args):
        print(self,"reset",arg,args)

refresher_fix =  Refresher_fix()

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

manager = MANAGER() # MASTER() #{}
modes = Modes()

import tkinter as tk
class Exec(): # DUMMY
    def __init__(self):
        self.val_exec = {}
        for i in range(512):
            k=i #"ABC-{}".format(i+1)
            self.val_exec[k] = {"NAME":"XX"}
EXEC = Exec()
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_exec(self,*arg,**args):
        #print("EXEC_Gui._refresh_exec",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_exec_single(nr,b,METAS)
            #time.sleep(0.001)

        print( "refres_exec:",time.time()-start )

    def _refresh_exec_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_SINGLE",nr,b,data["LABEL"])
            except Exception as e:
                print("  ER1R mc...",e)

            METAS = self.METAS
        _bg = "grey"
        _ba = "grey"
        _bg = "grey"
        _fg = "#555" #darkgrey"
        _text = "0 N/V 0\n N/V"

        txt = "None/nNone"
        txt1 = "None/nNone"

        out = {} # default
        out["fx"] = ""
        out["bg"] = _bg # "grey"
        out["ba"] = _ba #"grey"
        out["fg"] = _fg
        out["text"] = _text #"? "+str(nr+1)

        META = {'LABEL': 'ERR',  'CFG': {}}
        META["CFG"] = {'FADE': 3.0, 'DEALY': 0, 'DELAY': 4.0, 'BUTTON': 'ON', 'HTP-MASTER': 100
                       ,'SIZE-MASTER': 100, 'SPEED-MASTER': 100, 'OFFSET-MASTER': 100, 'OUT-FADE': 10.0
                       ,'FIX-COUNT':0 ,'HAVE-FX':0,'HAVE-VAL':0
                     }
        
        try: 
            META = METAS[nr]
            label = "{} {} {}\n{}".format(nr+1,META["CFG"]["BUTTON"],META["CFG"]["FIX-COUNT"],META["LABEL"])
            out["text"] = str(label)
            if no_meta:
                print("     no_meta:",[label])

        except Exception as e:
            print("  ER4R",e,nr)
            time.sleep(0.001)
        try:
            txt1 = META["CFG"]["BUTTON"]
        except:
            pass

        if  META["CFG"]["FIX-COUNT"]: 
            _fg = "black"
            
        if  META["CFG"]["HAVE-VAL"]: 
            _fg = "black"
            _bg = "yellow"
            _ba = "#ffaa55"
            if "SEL" in txt1:
                #_bg = "blue"
                #_fg = "blue"
                _bg = "gold"
                _bg = "#77f"
            elif "ON" in txt1:
                _bg = "gold"
                _fg = "#040"
                _fg = "black"
            elif "GO" in txt1:
                _bg = "gold"
                _fg = "#555"
                _fg = "black"
            elif "FL" in txt1:
                _bg = "gold"

        out["fx"] = ""
        if  META["CFG"]["HAVE-FX"] >= 1:
            out["fx"] = META["CFG"]["HAVE-FX"] # show FX on EXEC-BTN

        if  META["CFG"]["HAVE-FX"] >= 1 and META["CFG"]["HAVE-VAL"] == 0:
            _bg = "cyan"

        if "FL" in txt1:
            _fg = "#00e"
        
        out["fg"] = _fg #= "#00e"
        out["bg"] = _bg #= "#00e"
        cfg = out 
        
        self.elem_meta[nr] = META
        #print(" -",nr, round(time.time()-start,4))
        
        b = self.elem_exec[nr]
        b.configure(fg=cfg["fg"],bg=cfg["bg"],activebackground=cfg["ba"],text=cfg["text"],fx=cfg["fx"])
        #print(" -",nr, round(time.time()-start,4))

    def exec_go(self,*arg,**args):
        print("Gui.exec_go",arg,args)

        btn_nr = arg[0]
        v=args["val"]
        if "CFG-BTN" in modes.modes:
            button = self.elem_exec[btn_nr]
            label = str(btn_nr) #self.elem_meta[nr] = META
            
            if v:
                META = self.elem_meta[btn_nr] 
                dialog_cfg_open(btn_nr,META)
            return #STOP

        if "LABEL" in modes.modes:
            button = self.elem_exec[btn_nr]
            label = str(btn_nr) #self.elem_meta[nr] = META
            
            if v:
                META = self.elem_meta[btn_nr] 
                dialog_label_open(btn_nr,META)
            return #STOP

        #REFRESH = 0
        #for k in ["REC","COPY","MOVE","DEL","REC-FX","LABEL"]:
        #    if k in modes.modes:
        #        REFRESH = 1

        print(" ",[arg,args])
        edata={}
        if "event" in args:
            edata =  libtk2.serialize_event(args["event"])
        print(" ",edata)

        num = -1
        MOUSE = ""
        out={"event": "EXEC","EXEC":btn_nr+1,"VAL":v,"NR-KEY":btn_nr}
        if "num" in edata:
            num = edata["num"]
            if num == 1:
                out["MOUSE"]="LEFT"
            if num == 3:
                out["MOUSE"]="RIGHT"

        msg=json.dumps([out]).encode("utf-8")

        if not _global_key_lock:
            cmd_client.send(msg)
        cprint("SEND GUI.EXEC_GO",msg,color="green")

        if v == 0: # release btn
            thread.start_new_thread(refresh_exec_btn,(btn_nr,))

gui  = Gui()
 



import lib.libwin as libwin

if 0:
    name="FX3"
    args = {"title":name,"master":0,"width":364,"height":418+30,"left":L1+10+W1,"top":TOP+302,"resize":1}
    geo = libwin.filter_window_geo(geo_list,name)
    if geo:
        args.update(geo)
    cls = draw_fx3 #(manager,w.tk)
    data = []
    cb_ok = None

    c = libtk.window_create_buffer(args=args,cls=cls,data=data,cb_ok=cb_ok,gui=manager,scroll=0)
    window_manager.new(None,name,wcb=c)
    if libwin.split_window_show(geo_list,_filter=name):
        window_manager.top(name)


name="EXEC"
pos_list = libwin.read_window_geo()
geo = libwin.filter_window_geo(pos_list,name)
args = {"title":name,"master":0,"width":600,"height":113,"left":30+5,"top":30+5+400*2+10}
if geo:
   args.update(geo)

root = tk.Tk()
root.maxsize(830,2000)

win_title="FX3"
store = movewin.load_all_sdl(win_title)
print(store)
W=850
H=460
POS=[10,10]
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+"exec.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_exec(gui,xframe,EXEC)
draw_fx3(gui,xframe,EXEC)
root.title(title) #"TK-EXEC")

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)

import os

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


def _refr_loop():
    time.sleep(3)
    while 1:
        gui._refresh_exec()
        time.sleep(3)

thread.start_new_thread(_refr_loop,())

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

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

thread.start_new_thread(_refr_loop2,())

root.mainloop()