Xdesk/tkgui/FX3.py

#!/usr/bin/python3

import json
import time
import sys
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")


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"] = 0

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

def circle():
    #basic()

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

    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 = "TYPE:1" 
    MAIN.meta.fx3_grid[k].val("SIN")
    k = "TYPE:2" 
    MAIN.meta.fx3_grid[k].val("COS")


def size(val=255):
    for i in range(4):
        k = "SIZE:{}".format(i+1)
        print("  ",k,val)
        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)
        print("  ",k,val)
        MAIN.meta.fx3_grid[k].val(val)
    __refresh_fx3(_filter="SPEED")

def rgb():
    #basic()
    k = "GRP:1" 
    MAIN.meta.fx3_grid[k].val("RGB")
    k = "GRP:2" 
    MAIN.meta.fx3_grid[k].val("RGB")
    k = "GRP:3" 
    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 = "TYPE:1" 
    MAIN.meta.fx3_grid[k].val("FD")
    k = "TYPE:2" 
    MAIN.meta.fx3_grid[k].val("STATIC")
    k = "TYPE:3" 
    MAIN.meta.fx3_grid[k].val("STATIC")
    __refresh_fx3()

def clear():
    basic()
    k = "GRP:1" 
    MAIN.meta.fx3_grid[k].val(" ")
    k = "GRP:2" 
    MAIN.meta.fx3_grid[k].val(" ")
    k = "GRP:3" 
    MAIN.meta.fx3_grid[k].val(" ")

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

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


circle()

def _refresh_fx3x(): #frame,c,r,gui,mode="FX"):
    time.sleep(5)
    while 1:
        print("Ö " *22)
        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

            v2 = MAIN.meta.fx3_grid[comm].val()
            v1 = b["text"]
            if "ATTR" in comm or "GRP" in comm:
                print([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":
                    circle()
                elif xcomm == "RED":
                    rgb()
                elif xcomm == "MINI":
                    size(10)
                elif xcomm == "SMALL":
                    size(25)
                elif xcomm == "NORMAL":
                    size(50)
                elif xcomm == "BIG":
                    size(100)
                elif xcomm == "SLOW":
                    speed(5)
                elif xcomm == "MID":
                    speed(25)
                elif xcomm == "FAST":
                    speed(100)
                elif xcomm == "TURBO":
                    speed(200)

                xcb(event) #,data)
            return XXX

        _cb = tkevent.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 == "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")

            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)

        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_SINGLE",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)


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