class SubScale(tk.Scale, Fadable):

    def __init__(self, master, *args, **kw):

        self.scale_var = kw.get('variable') or tk.DoubleVar()

        kw.update({

            'variable': self.scale_var,

            'from': 1,

            'to': 0,

            'showvalue': 0,

            'sliderlength': 15,

            'width': 40,

            'troughcolor': 'black',

            'bg': 'grey40',

            'highlightthickness': 1,

            'bd': 1,

            'highlightcolor': 'red',

            'highlightbackground': 'black',

            'activebackground': 'red'

        })

        tk.Scale.__init__(self, master, *args, **kw)

        Fadable.__init__(self, var=self.scale_var, wheel_step=0.05)

        self.draw_indicator_colors()

        for w in [self, self.namelabel, self.levellabel]:

            dragSourceRegister(w, 'copy', 'text/uri-list', sub)

        self._slider_var_trace = self.slider_var.trace('w', self.slider_changed)

        self.graph.addHandler(self.updateLevelFromGraph)

        # initial position

        # stil need? dispatcher.send("send_to_hw", sub=sub.uri, hwCol=col + 1)

    def getVal(self) -> float:

        return self._val

    def setVal(self, newVal: float) -> None:

        if self.dead:

            return

        try:

            self.scale.set(newVal)

            self.levellabel.config(text=str(newVal))

        except Exception:

            log.warn("disabling handlers on broken subbox")

            self.dead = True

    def cleanup(self):

        self.slider_var.trace_vdelete('w', self._slider_var_trace)

    def slider_changed(self, *args):

        self._val = self.scale.get()

        self.scale.draw_indicator_colors()

        if self.pauseTrace:

            return

        self.updateGraphWithLevel(self.sub, self.getVal())

        # 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

    def updateLevelFromGraph(self):

        """read rdf level, write it to subbox.slider_var"""

        # move this to syncedgraph readMapping

        graph = self.graph

        for setting in graph.objects(self.session, L9['subSetting']):

            if graph.value(setting, L9['sub']) == self.sub:

                self.pauseTrace = True  # don't bounce this update back to server

                try:

                    self.setVal(graph.value(setting, L9['level']).toPython())

                finally:

                    self.pauseTrace = False

    def updateName(self):

        if self.scale is None:

            return

        def shortUri(u):

            return '.../' + u.split('/')[-1]

        try:

            self.namelabel.config(

                text=self.graph.label(self.sub) or shortUri(self.sub))

        except Exception:

            log.warn("disabling handlers on broken subbox")

            self.scale = None

class KeyboardComposer(tk.Frame, SubClient):

                               predicate=L9['group'],

                               newObject=group)

    def highlight_row(self, row):

        row = self.rows[row]

        row['bg'] = 'red'

    def unhighlight_row(self, row):

        row = self.rows[row]

        row['bg'] = 'black'

    def get_levels(self):

    def get_output_settings(self, _graph=None):

        _graph = _graph or self.graph

        outputSettings = []

        for setting in _graph.objects(self.session, L9['subSetting']):

            effect = _graph.value(setting, L9['sub'])

            strength = _graph.value(setting, L9['level'])

            if strength:

                now = time.time()

                out, report = self.effectEval[effect].outputFromEffect(

                    [(L9['strength'], strength)],

                    songTime=now,