light9 Changeset - c0f7fc86f89b

Changeset - c0f7fc86f89b

Parent rev.

Child rev.

[Not reviewed]

default

0 1 0

drewp@bigasterisk.com - 12 years ago 2013-06-15 06:09:57
drewp@bigasterisk.com

fix up hardware sliders in KC. big mess now
Ignore-this: 28956846058bf05ad44d9eeea2796c75

1 file changed with 23 insertions and 12 deletions:

bin/keyboardcomposer

0 comments (0 inline, 0 general)

bin/keyboardcomposer

➞

Show inline comments

@@ @@ -43,97 +43,96 @@ class DummySliders: @@
 class SubScale(Scale, Fadable):
     def __init__(self, master, *args, **kw):
         self.scale_var = kw.get('variable') or DoubleVar()
         kw.update({'variable' : self.scale_var,
                    'from' : 1, 'to' : 0, 'showvalue' : 0,
                    'sliderlength' : 15, 'res' : 0.01,
                    'width' : 40, 'troughcolor' : 'black', 'bg' : 'grey40',
                    'highlightthickness' : 1, 'bd' : 1,
                    'highlightcolor' : 'red', 'highlightbackground' : 'black',
                    'activebackground' : 'red'})
         Scale.__init__(self, master, *args, **kw)
         Fadable.__init__(self, var=self.scale_var, wheel_step=0.05)
         self.draw_indicator_colors()
     def draw_indicator_colors(self):
         if self.scale_var.get() == 0:
             self['troughcolor'] = 'black'
         else:
             self['troughcolor'] = 'blue'
 class SubmasterBox(Frame):
     """
     this object owns the level of the submaster (the rdf graph is the
     real authority)
     """
     def __init__(self, master, sub, session):
+    def __init__(self, master, sub, session, col, row):
         self.sub = sub
         self.session = session
         self.col, self.row = col, row
         bg = sub.graph.value(sub.uri, L9.color, default='#000000')
         rgb = webcolors.hex_to_rgb(bg)
         hsv = colorsys.rgb_to_hsv(*[x/255 for x in rgb])
         darkBg = webcolors.rgb_to_hex(tuple([x * 255 for x in colorsys.hsv_to_rgb(
             hsv[0], hsv[1], .3)]))
         Frame.__init__(self, master, bd=1, relief='raised', bg=bg)
         self.name = sub.name
         self.slider_var = DoubleVar()
         self.pauseTrace = False
         self.scale = SubScale(self, variable=self.slider_var, width=20)
         self.namelabel = Label(self, font="Arial 7", bg=darkBg,
             fg='white', pady=0)
         self.sub.graph.addHandler(self.updateName)
         self.namelabel.pack(side=TOP)
         levellabel = Label(self, textvariable=self.slider_var, font="Arial 7",
             bg='black', fg='white', pady=0)
         levellabel.pack(side=TOP)
         self.scale.pack(side=BOTTOM, expand=1, fill=BOTH)
         for w in [self, self.namelabel, levellabel]:
             dragSourceRegister(w, 'copy', 'text/uri-list', sub.uri)
         self._slider_var_trace = self.slider_var.trace('w', self.slider_changed)
         sub.graph.addHandler(self.updateLevelFromGraph)
         # initial position
-#        self.send_to_hw(sub.name, col + 1) # needs fix
+        # stil need? dispatcher.send("send_to_hw", sub=sub.uri, hwCol=col + 1)
     def cleanup(self):
         self.slider_var.trace_vdelete('w', self._slider_var_trace)
     def slider_changed(self, *args):
         self.scale.draw_indicator_colors()
         if self.pauseTrace:
             return
         self.updateGraphWithLevel(self.sub.uri, self.slider_var.get())
         # dispatcher.send("level changed") # in progress
         ###self.send_levels() # use dispatcher?
         # needs fixing: plan is to use dispatcher or a method call to tell a hardware-mapping object who changed, and then it can make io if that's a current hw slider
         #if rowcount == self.current_row:
         #    self.send_to_hw(sub.name, col + 1)
         dispatcher.send("send_to_hw", sub=self.sub.uri, hwCol=self.col + 1,
                         boxRow=self.row)
     def updateGraphWithLevel(self, uri, level):
         """in our per-session graph, we maintain SubSetting objects like this:
            ?session :subSetting [a :SubSetting; :sub ?s; :level ?l]
         """
         # move to syncedgraph patchMapping
         self.sub.graph.patchMapping(context=self.session,
                                     subject=self.session,
                                     predicate=L9['subSetting'],
                                     nodeClass=L9['SubSetting'],
                                     keyPred=L9['sub'], newKey=uri,
                                     valuePred=L9['level'], newValue=Literal(level))
     def updateLevelFromGraph(self):
         """read rdf level, write it to subbox.slider_var"""
         # move this to syncedgraph readMapping
         graph = self.sub.graph
         for setting in graph.objects(self.session, L9['subSetting']):
             if graph.value(setting, L9['sub']) == self.sub.uri:
                 self.pauseTrace = True # don't bounce this update back to server
                 try:
@@ @@ -215,74 +214,75 @@ class KeyboardComposer(Frame, SubClient) @@
         self.submasters.findSubs() # trigger graph load, but we read
                                    # from get_all_subs, below
         rowcount = -1
         col = 0
         last_group = None
         # there are unlikely to be any subs at startup because we
         # probably haven't been called back with the graph data yet
         withgroups = sorted((self.graph.value(sub.uri, L9['group']),
                              self.graph.value(sub.uri, L9['order']),
                              sub)
             for sub in self.submasters.get_all_subs())
         log.info("withgroups %s", withgroups)
         for group, order, sub in withgroups:
             group = self.graph.value(sub.uri, L9['group'])
             if col == 0 or group != last_group:
                 row = self.make_row(group)
                 rowcount += 1
                 col = 0
             subbox = SubmasterBox(row, sub, self.session)
+            subbox = SubmasterBox(row, sub, self.session, col, rowcount)
             subbox.place(relx=col / 8, rely=0, relwidth=1 / 8, relheight=1)
             self.subbox[sub.uri] = self.slider_table[(rowcount, col)] = subbox
             self.setup_key_nudgers(subbox.scale)
             col = (col + 1) % 8
             last_group = group
     def toggle_slider_connectedness(self):
         self.use_hw_sliders = not self.use_hw_sliders
         if self.use_hw_sliders:
             self.sliders.reopen()
         else:
             self.sliders.close()
         self.change_row(self.current_row)
         self.rows[self.current_row].focus()
     def connect_to_hw(self, hw_sliders):
         if hw_sliders:
             try:
                 self.sliders = Sliders(self)
             except IOError:
                 log.info("no hardware sliders")
                 self.sliders = DummySliders()
                 self.use_hw_sliders = False
             dispatcher.connect(self.send_to_hw, 'send_to_hw')
         else:
             self.sliders = DummySliders()
     def make_key_hints(self):
         keyhintrow = Frame(self)
         col = 0
         for upkey, downkey in zip(nudge_keys['up'],
                                   nudge_keys['down']):
             # what a hack!
             downkey = downkey.replace('semicolon', ';')
             upkey, downkey = (upkey.upper(), downkey.upper())
             # another what a hack!
             keylabel = Label(keyhintrow, text='%s\n%s' % (upkey, downkey),
                 width=1, font=('Arial', 10), bg='red', fg='white', anchor='c')
             keylabel.pack(side=LEFT, expand=1, fill=X)
             col += 1
         keyhintrow.pack(fill=X, expand=0)
         self.keyhints = keyhintrow
     def setup_key_nudgers(self, tkobject):
         for d, keys in nudge_keys.items():
@@ @@ -328,81 +328,92 @@ class KeyboardComposer(Frame, SubClient) @@
             # we changed interactively, the user is out of bounds and
             # needs to be brought back in
             if fromGraph:
                 return
             raise
         self.unhighlight_row(old_row)
         self.highlight_row(self.current_row)
         self.keyhints.pack_configure(before=row)
         if not fromGraph:
             self.graph.patchObject(self.session, self.session, L9['currentRow'],
                                    Literal(self.current_row))
         for col in range(1, 9):
             try:
                 subbox = self.slider_table[(self.current_row, col - 1)]
                 self.sliders.valueOut("button-upper%d" % col, True)
             except KeyError:
                 # unfilled bottom row has holes (plus rows with incomplete
                 # groups
                 self.sliders.valueOut("button-upper%d" % col, False)
                 self.sliders.valueOut("slider%d" % col, 0)
                 continue
             self.send_to_hw(subbox.name, col)
             self.send_to_hw(sub=subbox.sub.uri, hwCol=col,
                             boxRow=self.current_row)
     def got_nudger(self, number, direction, full=0):
         try:
             subbox = self.slider_table[(self.current_row, number)]
         except KeyError:
             return
         if direction == 'up':
             if full:
                 subbox.scale.fade(1)
             else:
                 subbox.scale.increase()
         else:
             if full:
                 subbox.scale.fade(0)
             else:
                 subbox.scale.decrease()
     def hw_slider_moved(self, col, value):
         value = int(value * 100) / 100
         try:
             subbox = self.slider_table[(self.current_row, col)]
         except KeyError:
             return # no slider assigned at that column
-        subbox.scale.set(value)
+        subbox.slider_var.set(value)
-    def send_to_hw(self, subUri, hwNum):
+    def send_to_hw(self, sub, hwCol, boxRow):
         if isinstance(self.sliders, DummySliders):
             return
         v = round(127 * self.slider_vars[subUri].get())
         chan = "slider%s" % hwNum
         assert isinstance(sub, URIRef), repr(subUri)
         if boxRow != self.current_row:
             return
         try:
             level = self.get_levels()[sub]
         except KeyError:
             log.warn("%r not in %r", sub, self.get_levels())
             raise
         v = round(127 * level)
         chan = "slider%s" % hwCol
         # workaround for some rounding issue, where we receive one
         # value and then decide to send back a value that's one step
         # lower.  -5 is a fallback for having no last value.  hopefully
         # we won't really see it
         if abs(v - self.sliders.lastValue.get(chan, -5)) <= 1:
             return
         self.sliders.valueOut(chan, v)
     def make_row(self, group):
         """group is a URI or None"""
         row = Frame(self, bd=2, bg='black')
         row.subGroup = group
         def onDrop(ev):
             self.change_group(sub=URIRef(ev.data), row=row)
             return "link"
         dropTargetRegister(row, onDrop=onDrop, typeList=['*'],
                            hoverStyle=dict(background="#555500"))
         row.pack(expand=1, fill=BOTH)
         self.setup_key_nudgers(row)
         self.rows.append(row)
         return row

0 comments (0 inline, 0 general)