class DummySliders:

    def valueOut(self, name, value):

        pass

    def close(self):

        pass

    def reopen(self):

        pass

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

    def draw_indicator_colors(self):

        if self.scale_var.get() == 0:

            self['troughcolor'] = 'black'

        else:

            self['troughcolor'] = 'blue'

class SubmasterBox(tk.Frame):

    """

    this object owns the level of the submaster (the rdf graph is the

    real authority)

        self.graph.addHandler(self.updateName)

        self.namelabel.pack(side=tk.TOP)

        self.levellabel = tk.Label(self,

                                   textvariable=self.slider_var,

                                   font="Arial 6",

                                   bg='black',

                                   fg='white',

                                   pady=0)

        self.levellabel.pack(side=tk.TOP)

        self.scale.pack(side=tk.BOTTOM, expand=1, fill=tk.BOTH)

        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

        dispatcher.send("send_to_hw",

                        sub=self.sub,

                        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.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.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):

    def __init__(self,

                 root: tk.Tk,

                 graph: SyncedGraph,

                 session: URIRef,

                 hw_sliders=True):

        tk.Frame.__init__(self, root, bg='black')

        SubClient.__init__(self)

        self.graph = graph

        self.session = session

        self.subbox: Dict[URIRef, SubmasterBox] = {}  # sub uri : SubmasterBox

        row.pack(expand=1, fill=tk.BOTH)

        self.setup_key_nudgers(row)

        self.rows.append(row)

        return row

    def change_group(self, sub, row):

        """update this sub's group, and maybe other sub groups as needed, so

        this sub displays in this row"""

        group = row.subGroup

        self.graph.patchObject(context=self.session,

                               subject=sub,

                               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,

                    # should be counting from when you bumped up from 0

                    noteTime=now)

                outputSettings.append(out)

        return DeviceSettings.fromList(_graph, outputSettings)

    def save_current_stage(self, subname):

        log.info("saving current levels as %s", subname)

        with self.graph.currentState() as g:

            ds = self.get_output_settings(_graph=g)

        effect = L9['effect/%s' % subname]

        ctx = URIRef(showconfig.showUri() + '/effect/' + subname)