refactor: FX3, live:FADE/DELAY, OptionBuffer.. ValueBuffer..

_LibreLightDesk.py

@@ -2538,7 +2538,7 @@ if __run_main:
 
 
     # =======================================================================
-    if 0:
+    if 1:
         name="FX3" #"TK-EXEC"
         def sdl_starter():
             cmd="/usr/bin/python3 /opt/LibreLight/Xdesk/tkgui/FX3.py " #&"
@@ -2562,19 +2562,20 @@ if __run_main:
         if libwin.split_window_show(geo_list,_filter=name):
             window_manager.top(name)
     # =======================================================================
-    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_fx_3 #(master,w.tk)
-    data = []
-    cb_ok = None
+    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_fx_3 #(master,w.tk)
+        data = []
+        cb_ok = None
 
-    c = libtk.window_create_buffer(args=args,cls=cls,data=data,cb_ok=cb_ok,gui=master,scroll=0)
-    window_manager.new(None,name,wcb=c)
-    if libwin.split_window_show(geo_list,_filter=name):
-        window_manager.top(name)
+        c = libtk.window_create_buffer(args=args,cls=cls,data=data,cb_ok=cb_ok,gui=master,scroll=0)
+        window_manager.new(None,name,wcb=c)
+        if libwin.split_window_show(geo_list,_filter=name):
+            window_manager.top(name)
 
 
     # =======================================================================

lib/execlib.py

@@ -84,6 +84,9 @@ def reshape_exec(data ,value=None,xfade=0,flash=0,ptfade=0,DELAY=None):
         out.append(line)
         if DELAY is not None:
             delay+=DELAY #0.02
+
+    #for j in out: # info
+    #    print("reshape_exec",j)
     return out
 
 

lib/meta.py

@@ -1,72 +1,263 @@
 #!/usr/bin/python3
 
-class ValueBuffer():
-    def __init__(self,val=2,_min=0,_max=255,_inc=1):
-        self._value = val
-        self._init_value = val
-        self._on = 1
-        self._inc = _inc
-        self._min=_min
-        self._max=_max
-        print(self,val)
-    def check(self):
-        #print(":::",self,self._value,self._min,self._max)
-        if self._value < self._min:
-            self._value = self._min
-            print(self,"MIN !")
-        if self._value > self._max:
-            self._value = self._max
-            print(self,"MAX !")
-
-    def dec(self,value=None):
-        if value is None:
-            value = self._inc
-        if type(value) is float:
-            value = round(value,4)
-        self._value -= value
-        self.check()
-        return self._value
-
-    def inc(self,value=None):
-        if value is None:
-            value = self._inc
-        if type(value) is float:
-            value = round(value,4)
-        self._value += value
-        self.check()
-        return self._value
-
-    def val(self,value=None):
-        if value is None:
-            return float(self._value)
-
-        if type(value) is float:
-            self._value = round(value,4)
-        self._value = value
-        self.check()
-        return float(self._value)
-    def reset(self):
-        self._value = self._init_value
-        self.check()
+def ValueBuffer_create_data(val=2,_min=0,_max=255,_inc=1,cycle=[0,127,255]):
+    data = {}
+    data["value"] = val
+    data["init_value"] = val
+    data["state"] = 1
+    data["inc"] = _inc
+    data["min"] = _min
+    data["max"] = _max
+    data["cycle"] = cycle
+    data["cycle_idx"] = 0
+    data["format"] = "<format>{}"
+    data["name"] = "<name>"
+    return data
+
+def Buffer_clean(data,default={}):
+    print( "ValueBuffer_clean(data)" )
+    a = ValueBuffer_create_data()
+    for k,v in a.items():
+        print("  ",id(data),[k,v])
+        if k not in data:
+            print("ValueBuffer_clear key does not exist; adding key ",[k]," !")
+            data[k] = v
+
+def ValueBuffer_clean(data):
+    default=ValueBuffer_create_data()
+    return Buffer_clean(data,default)
+
+def ValueBuffer_check(data):
+    ValueBuffer_clean(data)
+    #print(":::",data["value"],data["min"],data["max"])
+    if data["value"] < data["min"]:
+        data["value"] = data["min"]
+        print("MIN !")
+    if data["value"] > data["max"]:
+        data["value"] = data["max"]
+        print("MAX !")
+
+def ValueBuffer_cycle(data): # middel mouse click
+    ValueBuffer_clean(data)
+    _len = len(data["cycle"])
+    idx=data["cycle_idx"]
+    if idx >= _len:
+        idx = _len-1
+    else:
+        idx += 1
+    data["cycle_idx"]=idx
+    data["value"] = data["cycle"][idx]
+    ValueBuffer_check(data)
+    return data["value"]
+
+def ValueBuffer_dec(data,value=None): #Mouse Wheel down
+    ValueBuffer_clean(data)
+    if value is None:
+        value = data["inc"]
+    if type(value) is float:
+        value = round(value,4)
+    data["value"] -= value
+    ValueBuffer_check(data)
+    return data["value"]
+
+def ValueBuffer_inc(data,value=None): #Mouse Wheel up
+    ValueBuffer_clean(data)
+    if value is None:
+        value = data["inc"]
+    if type(value) is float:
+        value = round(value,4)
+    data["value"] += value
+    ValueBuffer_check(data)
+    return data["value"]
+
+def ValueBuffer_val(data,value=None): # get or set value
+    ValueBuffer_clean(data)
+    if value is None:
+        return float(data["value"])
+
+    if type(value) is float:
+        data["value"] = round(value,4)
+    data["value"] = value
+    ValueBuffer_check(data)
+    return float(data["value"])
+
+def ValueBuffer_reset(data): # right click
+    ValueBuffer_clean(data)
+    data["value"] = data["init_value"]
+    ValueBuffer_check(data)
+    return 1
+
+def ValueBuffer_on(data): # left click
+    ValueBuffer_clean(data)
+    data["state"] = 1
+
+def ValueBuffer_off(data): # left click
+    ValueBuffer_clean(data)
+    data["state"] = 0
+
+def ValueBuffer_toggle(data):
+    ValueBuffer_clean(data)
+    v = data["state"]
+    if v:v = 0
+    else:v = 1
+    data["state"] = v
+    return v
+    
+def ValueBuffer_invert(data):
+    ValueBuffer_clean(data)
+    data["value"] *=-1
+    ValueBuffer_check(data)
+
+def ValueBuffer_is(data):
+    ValueBuffer_clean(data)
+    if data["state"]:
         return 1
-    def on(self):
-        self._on = 1
+    return 0
+
+def ValueBuffer_format(data):
+    ValueBuffer_clean(data)
+    fm = data["format"]
+    print(fm,data)
+    try:
+        if "{val" in fm and "{state" in fm:
+            return fm.format(val=data["value"],state=data["state"])
+        if "{val" in fm:
+            return fm.format(val=data["value"])
+        if "{state" in fm:
+            return fm.format(state=data["state"])
+        return 
+    except Exception as e:
+        print(fm,data)
+        raise e
 
-    def off(self):
-        self._on = 0
 
+# warp function to object
+class ValueBuffer():
+    def __init__(self,val=2,_min=0,_max=255,_inc=1,cycle=[0,127,255]):
+        self.data = ValueBuffer_create_data(val=val,_min=_min,_max=_max,_inc=_inc,cycle=cycle)
+    def cycle(self): # middel mouse click
+        return ValueBuffer_cycle(self.data)
+    def check(self):
+        return ValueBuffer_check(self.data)
+    def dec(self,value=None): #Mouse Wheel down
+        return ValueBuffer_dec(self.data,value)
+    def inc(self,value=None): #Mouse Wheel up
+        return ValueBuffer_inc(self.data,value)
+    def val(self,value=None): # get or set value
+        return ValueBuffer_val(self.data,value)
+    def reset(self): # right click
+        return ValueBuffer_reset(self.data)
+    def on(self): # left click
+        return ValueBuffer_on(self.data)
+    def off(self): # left click
+        return ValueBuffer_off(self.data)
+    def toggle(self):
+        return ValueBuffer_toggle(self.data)
+    def invert(self):
+        return ValueBuffer_invert(self.data)
     def _is(self):
-        if self._on:
-            return 1
-        return 0
+        return ValueBuffer_is(self.data)
+    def format(self):
+        return ValueBuffer_format(self.data)
+
+
+def create_default_FadeBuffer():
+    return ValueBuffer(val=2,_min=0,_max=20,_inc=0.1)  
+
+def create_default_DelayBuffer():
+    return ValueBuffer(val=0.04,_min=-1,_max=1,_inc=0.01,cycle=[0.1,0.2,0.3,0.4,0.5])  
+
 
-FADE = ValueBuffer(val=2,_min=0,_max=10,_inc=0.1)  #2 #0.1 #1.13
-DELAY = ValueBuffer(val=0.04,_min=-1,_max=1,_inc=0.01)  
+FADE = create_default_FadeBuffer() 
+FADE.data["name"]   = "FADE"
+FADE.data["format"] = "FADE:\n{val:0.2f}"
+
+DELAY = create_default_DelayBuffer()
+DELAY.data["name"]   = "DELAY"
+DELAY.data["format"] = "DELAY:\n{val:0.2f}"
 DELAY.off()
 
-FADE_move = ValueBuffer(val=4.0)  #2 #0.1 #1.13
-FADE_move_delay = ValueBuffer(val=0.2,_min=-10,_max=10,_inc=0.1)  
+FADE_move = create_default_FadeBuffer() 
+FADE_move.data["name"]   = "FADE_move"
+FADE_move.data["format"] = "PAN/TILT\nFADE:{val:0.2f}"
+FADE_move.data["init_value"] = 4.0
+FADE_move.reset()
+
+FADE_move_delay = create_default_DelayBuffer()
+FADE_move.data["name"]   = "FADE_move_delay"
+FADE_move.data["format"] = "PAN/TILT\nD:{val:0.2f}"
+
+def OptionBuffer_create_data(val="",options=None):
+    if not options:
+        options = ["option1","option2"]
+    data = {}
+    data["options"]  = options
+    data["init_idx"] = 0
+    data["idx"]      = 0
+    data["wrap"]     = 0 #start from begining
+    
+    OptionBuffer_set_init(data,val)
+    return data
+
+def OptionBuffer_set_init(data,val):
+    idx=0
+    if val in data:
+        idx = data.index(val)
+    data["init_idx"] = idx
+
+
+def ValueBuffer_clean(data):
+    default=OptionBuffer_create_data()
+    return Buffer_clean(data,default)
 
+def OptionBuffer_check(data):
+    _len = len(data["options"]) 
+    if data["wrap"]:
+        if data["idx"] >= _len:
+            data["idx"] = 0
+        if data["idx"] < 0:
+            data["idx"] = _len-1 
+    else: 
+        if data["idx"] >= _len:
+            data["idx"] = _len-1
+        if data["idx"] < 0:
+            data["idx"] = 0
+
+    
+def OptionBuffer_reset(data):
+    ValueBuffer_clean(data)
+    data["idx"] = data["init_idx"]
+    OptionBuffer_check(data)
+
+def OptionBuffer_inc(data):
+    ValueBuffer_clean(data)
+    data["idx"] += 1
+    OptionBuffer_check(data)
+
+def OptionBuffer_dec(data):
+    ValueBuffer_clean(data)
+    data["idx"] -= 1
+    OptionBuffer_check(data)
+
+def OptionBuffer_val(data):
+    ValueBuffer_clean(data)
+    OptionBuffer_check(data)
+    idx= data["idx"]
+    return data["options"][idx]
+
+class OptionBuffer():
+    def __init__(self,val="",options=[]):
+        self.data = OptionBuffer_create_data(val="",options=options)
+    def reset(self):
+        return OptionBuffer_reset(self.data)
+    def inc(self):
+        return OptionBuffer_inc(self.data)
+    def dec(self):
+        return OptionBuffer_dec(self.data)
+    def val(self,val=""):
+        return OptionBuffer_val(self.data)
+    def set_init(self,val):
+        return OptionBuffer_set_init(self.data,val)
 
 class Elem_Container():
     def __init__(self):
@@ -75,9 +266,33 @@ class Elem_Container():
         self.val = {}
         self.elem = {}
 
+ATTR_GRP = {}
+ATTR_GRP["POS"] = ["PAN","TILT"]
+ATTR_GRP["RGB"] = ["RED","GREEN","BLUE","AMBER","WHITE"]
+#ATTR_GRP["CMY"] = ["CYAN","MAGENTA","YELLOW"]
+ATTR_GRP["BEAM"] = ["FOCUS","ZOOM","IRIS"] # GOBO1
+
+def Optionbuffer_create_ATTR_GRP(val=""):
+    options = list(ATTR_GRP.keys())
+    return OptionBuffer(val,options)
+
+FX_FUNC = ["SIN","COS","RAMP","RAMP2","FD","ON","STATIC"]
+def Optionbuffer_create_FX_FUNC(val=""):
+    options = FX_FUNC
+    return OptionBuffer(val,options)
+
+def Optionbuffer_create_ATTR(attr_grp="",val=""):
+    options = ["none1","none2"]
+    if attr_grp in ATTR_GRP:
+        options = ATTR_GRP[attr_grp]
+    return OptionBuffer(val,options)
+
+fx_func_grp = Optionbuffer_create_ATTR_GRP()
+fx_func_attr = Optionbuffer_create_ATTR("POS")
+fx_func_func = Optionbuffer_create_FX_FUNC()
+
 fx_prm_main = {}
 fx_prm_move = {"SIZE":40,"SPEED":8,"OFFSET":100,"BASE":"0","START":0,"MODE":0,"MO":0,"DIR":1,"INVERT":0,"WING":2,"WIDTH":100}
-fx_prm_3 = {"SIZE":40,"SPEED":8,"OFFSET":100,"BASE":"0","START":0,"MODE":0,"MO":0,"DIR":1,"INVERT":0,"WING":2,"WIDTH":100}
 
 live_prm = Elem_Container()
 live_prm.labels = ["FADE","DELAY","PAN/TILT\nFADE","PAN/TILT\nDELAY","-","-"]
@@ -91,6 +306,9 @@ fx_modes = ["RED","GREEN","BLUE","MAG","YELLOW","CYAN"]
 fx_mo    = ["fade","on","rnd","ramp","ramp2","cosinus","sinus","static"]
 
 
+
+
+
 # MASTER --------
 setup = Elem_Container()
 #setup.labels = ["SAVE\nSHOW","LOAD\nSHOW","NEW\nSHOW","SAVE\nSHOW AS","SAVE &\nRESTART","DRAW\nGUI","PRO\nMODE"]
@@ -103,25 +321,39 @@ fx_moves.labels =[
         "FX:CIR","FX:PAN","FX:TILT", "WIDTH:\n100","DIR:\n0","INVERT:\n0","\n",
         "SHUFFLE:\n0","SIZE:\n","SPEED:\n","START:\n","OFFSET:\n","\n"
         ]
-fx_3 = Elem_Container()
-fx_3.labels =[
-        "FX:ATTR","PAN","TILT","ATTR3","ATTR4","\n",
-        "TYPE:","SIN","COS"," "," ","\n",
-        "WIDTH:","25","25","25","25","\n",
-        "SIZE:","255","255","255","255","\n",
-        "SPEED:","10","10","10","10","\n",
-        "OFFSET:","100","100","100","100","\n",
-        "START:","0","0","0","0","\n",
-        "SHUFFLE:","0","0","0","0","\n",
-        "DIR:","1","1","1","1","\n",
-        "INVERT:","1","1","1","1","\n",
-        " ","\n",
-        " ","PLAY","STOP","OFF","\n",
-        "  ","CIRCL","PAN","TILT","FLAY","\n",
-        " ","RED","GREEN","BLUE","MAGENTA","\n",
-        "\n",
-        ]
-        #, "FX:SIN","FX:COS","FX:RAMP","FX:RAMP2","FX:FD","FX:ON","BASE:\n-"] #,"FX:RND" ]
+fx3 = Elem_Container()
+fx3_prm = {}
+fx3_grid = {}
+#{"SIZE":40,"SPEED":8,"OFFSET":100,"BASE":"0","START":0,"MODE":0,"MO":0,"DIR":1,"INVERT":0,"WING":2,"WIDTH":100}
+fx3_grid_cfg = {}
+fx3_grid_cfg["GRP:"]   = Optionbuffer_create_ATTR_GRP
+fx3_grid_cfg["ATTR:"]  = Optionbuffer_create_ATTR #("POS")
+fx3_grid_cfg["TYPE:"]  = Optionbuffer_create_FX_FUNC #()
+fx3_grid_cfg["WIDTH:"] = ValueBuffer #(val=2,_min=0,_max=20,_inc=0.1)  
+fx3_grid_cfg["SIZE:"]   = ValueBuffer 
+fx3_grid_cfg["SPEED:"]  = ValueBuffer 
+fx3_grid_cfg["OFFSET:"] = ValueBuffer 
+fx3_grid_cfg["START:"]  = ValueBuffer 
+fx3_grid_cfg["SHUFFLE:"] = ValueBuffer 
+fx3_grid_cfg["DIR:"]     = ValueBuffer 
+fx3_grid_cfg["INVERT:"]  = ValueBuffer 
+
+fx3.labels =[] 
+for i,f in fx3_grid_cfg.items():
+    x=[]
+    x.append(i)
+    for j in range(4):
+        k="{}{}".format(i,j+1)
+        x.append(k)
+        fx3_grid[k] = f()
+
+    x.append("\n")
+    print(":",x)
+    fx3.labels.extend(x)
+fx3.labels.extend(["\n"])
+fx3.labels.extend([" ","PLAY","STOP","OFF","\n"])
+fx3.labels.extend(["  ","CIRCL","PAN","TILT","FLAY","\n"])
+fx3.labels.extend([" ","RED","GREEN","BLUE","MAGENTA","\n"])
 
 fx_cfg = Elem_Container()
 fx_cfg.labels =[

lib/tkevent.py

@@ -180,18 +180,15 @@ class tk_event():
                 return 0
 
             if event.num == 1:
-                if ct._is():
-                    ct.off()# = 0
+                v = ct.toggle()
+                if v:
                     b["bg"] = "grey"
                     b.config(activebackground="grey")
                 else:
-                    ct.on()# = 1
                     b["bg"] = "green"
                     b.config(activebackground="lightgreen")
             elif event.num == 2:
-                #if "DELAY" in self.attr:
-                v = ct.val()
-                ct.val(v*-1) # invert
+                ct.invert()
             elif event.num == 3:
                 ct.reset()
             elif event.num == 4:
@@ -202,14 +199,15 @@ class tk_event():
             value = ct.val()
 
 
-            if self.attr == "FADE":
-                b["text"] = "FADE:\n{:0.2f}".format(value)
-            elif self.attr == "DELAY":
-                b["text"] = "DELAY:\n{:0.2f}".format(value)
-            elif "PAN/TILT\nFADE" in self.attr:
-                b["text"] = "PAN/TILT\nFADE:{:0.2f}".format(value)
-            elif "PAN/TILT\nDELAY" in self.attr:
-                b["text"] = "PAN/TILT\nD:{:0.2f}".format(value)
+            b["text"] = ct.format()
+            #if self.attr == "FADE":
+            #    b["text"] = "FADE:\n{:0.2f}".format(value)
+            #elif self.attr == "DELAY":
+            #    b["text"] = "DELAY:\n{:0.2f}".format(value)
+            #elif "PAN/TILT\nFADE" in self.attr:
+            #    b["text"] = "PAN/TILT\nFADE:{:0.2f}".format(value)
+            #elif "PAN/TILT\nDELAY" in self.attr:
+            #    b["text"] = "PAN/TILT\nD:{:0.2f}".format(value)
 
 
 
@@ -432,6 +430,7 @@ class tk_event_fx():
         self.attr = attr
         self.elem = elem
         self.mode = mode
+        self.ATTR_GRP = ""
 
     def fx(self,event):
         cprint("Xevent.fx",self.attr,self.fix,event)
@@ -508,277 +507,325 @@ class tk_event_fx():
         if self.mode == "FX-MOVE":
             prm = MAIN.meta.fx_prm_move
             ct = MAIN.meta.fx_moves 
+        if self.mode == "FX-3":
+            prm = [] #MAIN.meta.fx_prm
+            ct  = "" #MAIN.meta.fx_cfg
+            cprint("--",self,"FX-3",color="red")
+            print(" --", self.attr)
+            fx3_grid = MAIN.meta.fx3_grid # OptionBuffer()
+            if self.attr not in fx3_grid:
+                return
+
+            fx3_buf = fx3_grid[self.attr]
+            col = self.attr.split(":")[1]
+            print(fx3_buf)
+
+            if self.attr.startswith("ATTR:"):
+                fx_func1 = MAIN.meta.fx3_grid["GRP:"+str(col)]
+                GRP = fx_func1.val()
+                if GRP != self.ATTR_GRP:
+                    self.ATTR_GRP = GRP
+                    fx_func1.val(GRP)
+                    MAIN.meta.fx3_grid[self.attr] = MAIN.meta.Optionbuffer_create_ATTR(GRP)
+                fx_func = MAIN.meta.fx3_grid[self.attr] 
+                fx_func.data["wrap"] = 1
+                fx_func.inc()
+                v=fx_func.val()
+                print(v)
+                print(self.elem)
+                self.elem["text"] = v
+            else: #if self.attr.startswith("TYPE:"):
+                fx_func = MAIN.meta.fx3_grid[self.attr]
+                fx_func.data["wrap"] = 1
+                fx_func.inc()
+                v=fx_func.val()
+                print(v)
+                print(self.elem)
+                self.elem["text"] = v
+            return
 
         if 1:
             if self.attr.startswith("SIZE:"):#SIN":
                 #global MAIN.meta.fx_prm
                 k = "SIZE"
+                p = prm[k]
                 if event.num == 1:
                     _stats = [0,30,100,255]
-                    if prm[k] in _stats:
-                        idx = _stats.index(prm[k])+1
+                    if p in _stats:
+                        idx = _stats.index(p)+1
                         if idx > len(_stats)-1: #rotate
                             idx = 0
-                        prm[k] = _stats[idx]
+                        p = _stats[idx]
                     else:
-                        prm[k] = _stats[1]
+                        p = _stats[1]
                 elif event.num == 3:
-                    prm[k] =100
+                    p =100
                 elif event.num == 4:
-                    if prm[k] <= 0:
-                        prm[k] = 1
-                    prm[k] +=5
+                    if p <= 0:
+                        p = 1
+                    p +=5
                 elif event.num == 5:
-                    prm[k] -=5
-                #prm[k] =int(prm[k])
+                    p -=5
+                #p =int(p)
                 
-                if prm[k] > 4000:
-                    prm[k] = 4000
-                if prm[k] < 0:
-                    prm[k] =0
-                if prm[k] == 6: #bug
-                    prm[k] =5
-                ct.elem[self.attr]["text"] = "SIZE:\n{:0.0f}".format(prm[k])
+                if p > 4000:
+                    p = 4000
+                if p < 0:
+                    p =0
+                if p == 6: #bug
+                    p =5
+                ct.elem[self.attr]["text"] = "SIZE:\n{:0.0f}".format(p)
                 cprint("  ",prm)
             elif self.attr.startswith("SPEED:"):#SIN":
                 #global prm
                 k = "SPEED"
+                p = prm[k]
                 if event.num == 1:
                     _stats = [0,5,25,30,100,255]
-                    if prm[k] in _stats:
-                        idx = _stats.index(prm[k])+1
+                    if p in _stats:
+                        idx = _stats.index(p)+1
                         if idx > len(_stats)-1: #rotate
                             idx = 0
-                        prm[k] = _stats[idx]
+                        p = _stats[idx]
                     else:
-                        prm[k] = 0
+                        p = 0
                 elif event.num == 3:
-                    prm[k] = 10
+                    p = 10
                 elif event.num == 4:
-                    if prm[k] <= 0:
-                        prm[k] = 0.06
-                    elif prm[k] < 5:
-                        prm[k] *=1.2
+                    if p <= 0:
+                        p = 0.06
+                    elif p < 5:
+                        p *=1.2
                     else:
-                       prm[k] +=5 #1.1
+                       p +=5 #1.1
                 elif event.num == 5:
-                    if prm[k] <= 5:
-                        prm[k] *=0.8
+                    if p <= 5:
+                        p *=0.8
                     else:
-                        prm[k] -= 5 #1.1
-                #prm[k] =int(prm[k])
+                        p -= 5 #1.1
+                #p =int(p)
                 
-                if prm[k] > 4000:
-                    prm[k] = 4000
-                if prm[k] < 0.05:
-                    prm[k] =0
-                if prm[k] > 5 and prm[k] < 10: #bug
-                    prm[k] =5
-
-                if prm[k] < 0:
-                    ct.elem[self.attr]["text"] = "SPEED:\noff".format(prm[k])
+                if p > 4000:
+                    p = 4000
+                if p < 0.05:
+                    p =0
+                if p > 5 and p < 10: #bug
+                    p =5
+
+                if p < 0:
+                    ct.elem[self.attr]["text"] = "SPEED:\noff".format(p)
                 else:
-                    ct.elem[self.attr]["text"] = "SPEED:\n{:0.02f}".format(prm[k])
+                    ct.elem[self.attr]["text"] = "SPEED:\n{:0.02f}".format(p)
                 cprint("  ",prm)
             elif self.attr.startswith("START:"):#SIN":
                 #global prm
                 k = "START"
+                p = prm[k]
                 if event.num == 1:
                     pass
                 elif event.num == 2:
                     pass
                 elif event.num == 4:
-                    if prm[k] <= 0:
-                        prm[k] = 1
-                    prm[k] += 5 #1.1
+                    if p <= 0:
+                        p = 1
+                    p += 5 #1.1
                 elif event.num == 5:
-                    prm[k] -= 5 #1.1
-                #prm[k] =int(prm[k])
+                    p -= 5 #1.1
+                #p =int(p)
                 
-                if prm[k] > 4000:
-                    prm[k] = 4000
-                if prm[k] < 5:
-                    prm[k] =0
-                if prm[k] == 6: #bug
-                    prm[k] =5
-
-                ct.elem[self.attr]["text"] = "START:\n{:0.0f}".format(prm[k])
+                if p > 4000:
+                    p = 4000
+                if p < 5:
+                    p =0
+                if p == 6: #bug
+                    p =5
+
+                ct.elem[self.attr]["text"] = "START:\n{:0.0f}".format(p)
                 cprint("  ",prm)
             elif self.attr.startswith("WIDTH:"):#SIN":
                 #global prm
                 k = "WIDTH"
+                p = prm[k]
                 if event.num == 1:
                     _stats = [0,25,50,75,10]
-                    if prm[k] in _stats:
-                        idx = _stats.index(prm[k])+1
+                    if p in _stats:
+                        idx = _stats.index(p)+1
                         if idx > len(_stats)-1: #rotate
                             idx = 0
-                        prm[k] = _stats[idx]
+                        p = _stats[idx]
                     else:
-                        prm[k] = 25
+                        p = 25
                 elif event.num == 2:
-                    prm[k] = 50
+                    p = 50
                 elif event.num == 3:
-                    prm[k] = 100
+                    p = 100
                 elif event.num == 4:
-                    if prm[k] <= 0:
-                        prm[k] = 1
-                    elif prm[k] == 50:
-                        prm[k] = 100
-                    elif prm[k] == 5:
-                        prm[k] = 25
-                    elif prm[k] == 25:
-                        prm[k] = 50
+                    if p <= 0:
+                        p = 1
+                    elif p == 50:
+                        p = 100
+                    elif p == 5:
+                        p = 25
+                    elif p == 25:
+                        p = 50
                     else:
-                        prm[k] += 5 #*=1.1
+                        p += 5 #*=1.1
                 elif event.num == 5:
-                    if prm[k] == 10:
-                        prm[k] = 5
-                    elif prm[k] == 25:
-                        prm[k] = 10
-                    elif prm[k] == 50:
-                        prm[k] = 25
-                    elif prm[k] == 100:
-                        prm[k] = 50
+                    if p == 10:
+                        p = 5
+                    elif p == 25:
+                        p = 10
+                    elif p == 50:
+                        p = 25
+                    elif p == 100:
+                        p = 50
                     #else:
-                    #    prm[k] -=5 #/=1.1
+                    #    p -=5 #/=1.1
                     
-                #prm[k] =int(prm[k])
+                #p =int(p)
                 
-                if prm[k] < 0:
-                    prm[k] = 0
-                if prm[k] > 100:
-                    prm[k] = 100
-                if prm[k] == 6: #bug
-                    prm[k] =5
-                if prm[k] > 25 and prm[k] < 50: #bug
-                    prm[k] =50
-                if prm[k] > 50 and prm[k] < 75: #bug
-                    prm[k] =75
-                if prm[k] > 75 and prm[k] < 100: #bug
-                    prm[k] =100
-
-                ct.elem[self.attr]["text"] = "WIDTH:\n{:0.0f}".format(prm[k])
+                if p < 0:
+                    p = 0
+                if p > 100:
+                    p = 100
+                if p == 6: #bug
+                    p =5
+                if p > 25 and p < 50: #bug
+                    p =50
+                if p > 50 and p < 75: #bug
+                    p =75
+                if p > 75 and p < 100: #bug
+                    p =100
+
+                ct.elem[self.attr]["text"] = "WIDTH:\n{:0.0f}".format(p)
                 cprint("  ",prm)
             elif self.attr.startswith("DIR:"):#SIN":
                 #global prm
                 k = "DIR"
+                p = prm[k]
                 if event.num == 1:
-                    prm[k] = 1
+                    p = 1
                 elif event.num == 3:
-                    prm[k] = -1
+                    p = -1
                 elif event.num == 4:
-                    prm[k] = 1
+                    p = 1
                 elif event.num == 5:
-                    prm[k] =-1
-                txt = prm[k] 
-                ct.elem[self.attr]["text"] = "DIR:\n{}".format(prm[k])
+                    p =-1
+                txt = p 
+                ct.elem[self.attr]["text"] = "DIR:\n{}".format(p)
                 cprint("  ",prm)
             elif self.attr.startswith("SHUFFLE:"):#SIN":
                 #global prm
                 k = "SHUFFLE"
+                print("OOO", [self.mode,k , prm] )
+                p = prm[k]
                 if event.num == 1:
-                    prm[k] = 0
+                    p = 0
                 elif event.num == 3:
-                    prm[k] = 1
+                    p = 1
                 elif event.num == 4:
-                    prm[k] = 1
+                    p = 1
                 elif event.num == 5:
-                    prm[k] =0
-                if prm[k] == 6: #bug ?
-                    prm[k] =5
-                ct.elem[self.attr]["text"] = k+":\n{}".format(prm[k])
+                    p =0
+                if p == 6: #bug ?
+                    p =5
+                ct.elem[self.attr]["text"] = k+":\n{}".format(p)
                 cprint("  ",prm)
             elif self.attr.startswith("INVERT:"):#SIN":
                 #global prm
                 k = "INVERT"
+                p = prm[k]
                 if event.num == 1:
-                    prm[k] = 0
+                    p = 0
                 elif event.num == 3:
-                    prm[k] = 1
+                    p = 1
                 elif event.num == 4:
-                    prm[k] = 1
+                    p = 1
                 elif event.num == 5:
-                    prm[k] =0
-                if prm[k] == 6: #bug ?
-                    prm[k] =5
-                ct.elem[self.attr]["text"] = k+":\n{}".format(prm[k])
+                    p =0
+                if p == 6: #bug ?
+                    p =5
+                ct.elem[self.attr]["text"] = k+":\n{}".format(p)
                 cprint("  ",prm)
             elif self.attr.startswith("2D-X:"):#SIN":
                 #global prm
                 k = "2D-X"
+                p = prm[k]
                 if event.num == 1:
-                    prm[k] = 1
+                    p = 1
                 elif event.num == 3:
-                    prm[k] = 2
+                    p = 2
                 elif event.num == 4:
-                    prm[k] += 1
+                    p += 1
                 elif event.num == 5:
-                    prm[k] -=1
-                if prm[k] > 100:
-                    prm[k] = 100
-                if prm[k] < 1:
-                    prm[k] =1
+                    p -=1
+                if p > 100:
+                    p = 100
+                if p < 1:
+                    p =1
                     
-                txt = prm[k] 
-                ct.elem[self.attr]["text"] = "2D-X:\n{}".format(prm[k])
+                txt = p 
+                ct.elem[self.attr]["text"] = "2D-X:\n{}".format(p)
                 cprint("  ",prm)
             elif self.attr.startswith("WING:"):#SIN":
                 #global prm
                 k = "WING"
+                p = prm[k]
                 if event.num == 1:
-                    prm[k] = 1
+                    p = 1
                 elif event.num == 3:
-                    prm[k] = 2
+                    p = 2
                 elif event.num == 4:
-                    prm[k] += 1
+                    p += 1
                 elif event.num == 5:
-                    prm[k] -=1
-                if prm[k] > 100:
-                    prm[k] = 100
-                if prm[k] < 1:
-                    prm[k] =1
+                    p -=1
+                if p > 100:
+                    p = 100
+                if p < 1:
+                    p =1
                     
-                txt = prm[k] 
-                ct.elem[self.attr]["text"] = "WING:\n{}".format(prm[k])
+                txt = p 
+                ct.elem[self.attr]["text"] = "WING:\n{}".format(p)
                 cprint("  ",prm)
             elif self.attr.startswith("OFFSET:"):#SIN":
                 #global prm
                 k = "OFFSET"
+                p = prm[k]
                 if event.num == 1:
-                    prm[k] = 50
+                    p = 50
                 elif event.num == 2:
-                    prm[k] *= 2
+                    p *= 2
                 elif event.num == 3:
-                    prm[k] = 100
+                    p = 100
                 elif event.num == 4:
-                    if prm[k] <= 0:
-                        prm[k] = 1
-                    prm[k] +=5 #*=1.1
+                    if p <= 0:
+                        p = 1
+                    p +=5 #*=1.1
                 elif event.num == 5:
-                    prm[k] -=5 #/=1.1
-                #prm[k] =int(prm[k])
+                    p -=5 #/=1.1
+                #p =int(p)
                 
-                #if prm[k] > 512:
-                #    prm[k] = 512
-                if prm[k] < 5:
-                    prm[k] =0
-                if prm[k] == 6: #bug
-                    prm[k] =5
-
-                ct.elem[self.attr]["text"] = "OFFSET:\n{:0.0f}".format(prm[k])
+                #if p > 512:
+                #    p = 512
+                if p < 5:
+                    p =0
+                if p == 6: #bug
+                    p =5
+
+                ct.elem[self.attr]["text"] = "OFFSET:\n{:0.0f}".format(p)
                 cprint("  ",prm)
             elif self.attr.startswith("BASE:"):
                 k = "BASE"
+                p = prm[k]
                 if event.num == 1:
-                    prm[k] = "-"
+                    p = "-"
                 elif event.num == 3:
-                    prm[k] = "0"
+                    p = "0"
                 elif event.num == 4:
-                    prm[k] = "+"
+                    p = "+"
                 elif event.num == 5:
-                    prm[k] = "0"
-                ct.elem[self.attr]["text"] = "BASE:\n{}".format(prm[k])
+                    p = "0"
+                ct.elem[self.attr]["text"] = "BASE:\n{}".format(p)
             elif self.attr.startswith("2D:"):#SIN":
                 self.fx(event)
             elif self.attr.startswith("FX:"):#SIN":

tkgui/FX3.py

@@ -101,7 +101,7 @@ sys.path.insert(0,"/opt/LibreLight/Xdesk/")
 import tool.git as git
 #CAPTION += git.get_all()
 
-CAPTION = "EXEC-BTN"
+CAPTION = "FX3"
 title = CAPTION
 title += git.get_all()
 
@@ -119,69 +119,6 @@ import lib.tkevent as tkevent
 
 #import tkgui.draw as draw
 
-def draw_exec(gui,xframe,EXEC):
-    
-    i=0
-    c=0
-    r=0
-    root = xframe
-    
-    frame = tk.Frame(root,bg="black")
-    frame.pack(fill=tk.X, side=tk.TOP)
-
-    gui.elem_exec = {}
-    i=0
-    for k in EXEC.val_exec:
-        if i%(10*8)==0 or i ==0:
-            c=0
-            b = tk.Canvas(frame,bg="black", height=4,bd=0,width=6,highlightthickness=0) #,bd="black")
-            b.grid(row=r, column=c, sticky=tk.W+tk.E)
-            r+=1
-            c=0
-            b = tk.Button(frame,bg="lightblue", text="EXEC " )
-            b.grid(row=r, column=c, sticky=tk.W+tk.E)
-            c+=1
-            b = tk.Button(frame,bg="lightblue", text="BANK " + str(int(i/(8*8))+1) )
-            b.grid(row=r, column=c, sticky=tk.W+tk.E)
-            c+=1
-            b = tk.Button(frame,bg="lightblue", text="NAME"  )
-            b.grid(row=r, column=c, sticky=tk.W+tk.E)
-            c+=7
-            if i == 0:
-                b = tk.Button(frame,bg="darkgrey", text="HELP",command=libtk.online_help("librelight:20-exec")) #"0&do=index"))
-                b.grid(row=r, column=c, sticky=tk.W+tk.E)
-            r+=1
-            c=0
-        i+=1
-        v=0
-        label = ""
-
-        sdata=EXEC.val_exec[k]
-        BTN="go"
-        if "CFG" in sdata:#["BUTTON"] = "GO"
-            if "BUTTON" in sdata["CFG"]:
-                BTN = sdata["CFG"]["BUTTON"]
-
-
-        txt=str(k+1)+":"+str(BTN)+":"+str(len(sdata)-1)+"\n"+label
-
-        b = mytklib.ExecButton(frame,text=txt)
-
-        b.bind("<Button>",       tkevent.tk_event(fix=0,elem=b,attr=k,data=gui,mode="EXEC").cb)
-        b.bind("<ButtonRelease>",tkevent.tk_event(fix=0,elem=b,attr=k,data=gui,mode="EXEC").cb)
-        
-        if k not in gui.elem_exec:
-            gui.elem_exec[k] = b
-        b.grid(row=r, column=c, sticky=tk.W+tk.E)
-
-        b.config(text="xx"+str(i))
-        c+=1
-        if c >=10:
-            c=0
-            r+=1
-    time.sleep(0.1)
-    gui._refresh_exec()
-    print("##################################")
 
 def _add_space(frame,r,c):
     b = tk.Canvas(frame,bg="black", height=2,bd=0,width=6,highlightthickness=0) #,bd="black")
@@ -190,9 +127,9 @@ def _add_space(frame,r,c):
     c=0
     return r,c
 
-def _draw_fx_3(frame,c,r,gui,mode="FX"):
-    ct  = MAIN.meta.fx_3 #moves
-    prm = MAIN.meta.fx_prm_3
+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":
@@ -244,6 +181,14 @@ def _draw_fx_3(frame,c,r,gui,mode="FX"):
             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:
             b.grid(row=r, column=c, sticky=tk.W+tk.E)
         c+=1
@@ -335,7 +280,7 @@ def _draw_fx(frame,c,r,gui,mode="FX"):
     r+=1
     return c,r
 
-def draw_fx_3(gui,xframe,data=[]):
+def draw_fx3(gui,xframe,data=[]):
     frame_fx=xframe
     i=0
     c=0
@@ -360,10 +305,10 @@ def draw_fx_3(gui,xframe,data=[]):
     #c,r = _draw_fx(frame,c,r,gui,mode="FX-COLOR")
 
     r,c=_add_space(frame,r,c)
-    c,r = _draw_fx_3(frame,c,r,gui,mode="FX-3")
+    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("EXEC-BTN","/opt/LibreLight/Xdesk/tkgui/EXEC-BTN.py")
+movewin.check_is_started("FX3","/opt/LibreLight/Xdesk/tkgui/FX3.py")
 
 _global_short_key = 1
 root = None
@@ -427,7 +372,7 @@ class Modes(): # DUMMY
         #print("Modes.val",arg,args)
         pass
 
-manager = MASTER() #{}
+manager = MANAGER() # MASTER() #{}
 modes = Modes()
 
 import tkinter as tk
@@ -636,7 +581,7 @@ if 0:
     geo = libwin.filter_window_geo(geo_list,name)
     if geo:
         args.update(geo)
-    cls = draw_fx_3 #(manager,w.tk)
+    cls = draw_fx3 #(manager,w.tk)
     data = []
     cb_ok = None
 
@@ -656,7 +601,7 @@ if geo:
 root = tk.Tk()
 root.maxsize(830,2000)
 
-win_title="EXEC-BTN"
+win_title="FX3"
 store = movewin.load_all_sdl(win_title)
 print(store)
 W=850
@@ -683,7 +628,7 @@ except Exception as e:
 
 xframe = libtk.ScrollFrame(root,width=820,height=400,bd=1,bg="black",head=None,foot=None)
 #draw_exec(gui,xframe,EXEC)
-draw_fx_3(gui,xframe,EXEC)
+draw_fx3(gui,xframe,EXEC)
 root.title(title) #"TK-EXEC")
 
 root.bind("<Button>",libtk2.tk_event)#

tkgui/draw.py

@@ -428,69 +428,6 @@ def draw_enc(gui,xframe,data=[]):
     b.grid(row=r, column=c, sticky=tk.W+tk.E)
     c+=1
 
-def _draw_fx_3(frame,c,r,gui,mode="FX"):
-    ct  = MAIN.meta.fx_3 #moves
-    prm = MAIN.meta.fx_prm_3
-
-    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 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":
@@ -748,20 +685,25 @@ def draw_live(gui,xframe,data):
             continue
         v=0
         b = tk.Button(frame,bg="lightgrey", text=str(comm),width=6,height=2)
-
+        
+        vb = None # ValueBuffer
         if "FADE" == comm:
-            b["text"] = "FADE:\n{:0.2}".format(MAIN.meta.FADE.val())
+            vb = MAIN.meta.FADE
         if "DELAY" == comm:
-            b["text"] = "DELAY:\n{:0.2}".format(MAIN.meta.DELAY.val())
+            vb= MAIN.meta.DELAY
         if "PAN/TILT\nFADE" == comm:
-            b["text"] = "PAN/TILT\nFADE:{:0.2}".format(MAIN.meta.FADE_move.val())
+            vb = MAIN.meta.FADE_move
         if "PAN/TILT\nDELAY" == comm:
-            b["text"] = "PAN/TILT\nD:{:0.2}".format(MAIN.meta.FADE_move_delay.val())
             myTip = Hovertip(b,comm)
-            
+            vb = MAIN.meta.FADE_move_delay
+
+        if vb:
+            b["text"] = vb.format()
+
         if "FADE" in comm:
             b["bg"] = "green"
             b.config(activebackground="lightgreen")
+
         if comm:
             b.grid(row=r, column=c, sticky=tk.W+tk.E)