import louie as dispatcher 

from twisted.python.util import sibpath

from rdflib import URIRef

from rdflib import Graph

import rdflib

import logging

log = logging.getLogger()

import run_local

from light9 import showconfig, prof

from light9.curvecalc.zoomcontrol import Zoomcontrol

from light9.curvecalc.curve import Curveset

from light9.curvecalc.musicaccess import Music, currentlyPlayingSong

from light9.wavelength import wavelength

from light9.uihelpers import toplevelat

from light9.namespaces import L9

from light9.curvecalc.subterm import read_all_subs, savekey, graphPathForSubterms

from light9.curvecalc.subtermview import add_one_subterm

from light9.curvecalc.output import Output

def makeGraph():

    graphOrig = showconfig.getGraph()

    graph = Graph() # a copy, since we're going to add subs into it

    for s in graphOrig:

        mainwin = wtree.get_object("MainWindow")

        mainwin.connect("destroy", gtk.main_quit)

        wtree.connect_signals(self)

        mainwin.show_all()

        mainwin.connect("delete-event", lambda *args: reactor.crash())

        mainwin.set_title("curvecalc - %s" % graph.label(song))

        self.add_subterms_for_song(song, curveset, subterms,

                                   wtree.get_object("subterms")

                                   )

        self.makeStatusLines(wtree.get_object("status"))

        #zc = Zoomcontrol(root)

    def onSave(self, *args):

        savekey(song, subterms, curveset)

    def add_subterms_for_song(self, song, curveset, subterms, master):

        for st in self.graph.objects(song, L9['subterm']):

            log.info("song %s has subterm %s", song, st)

            add_one_subterm(self.graph,

                self.curveview.add_point(p)

        self.curveview.update_curve()

class Curveview(object):

    """

    graphical curve widget only. Please pack .widget

    """

    def __init__(self, curve, knobEnabled=False, isMusic=False, **kw):

        """knobEnabled=True highlights the previous key and ties it to a

        hardware knob"""

        self.widget = goocanvas.Canvas()

        self.widget.set_size_request(-1, 130)

        self.root = self.widget.get_root_item()

        self.redrawsEnabled = False

        self.curve = curve

        self.knobEnabled = knobEnabled

        self._isMusic = isMusic

        self._time = 0

        self.last_mouse_world = None

        self.selected_points=[] # idx of points being dragged

        # self.bind("<Enter>",self.focus)

        dispatcher.connect(self.input_time, "input time")

        # canvas doesnt have keyboard focus, so i can't easily change the

        # cursor when ctrl is pressed

        #        def curs(ev):

        #            print ev.state

        #        self.bind("<KeyPress>",curs)

        #        self.bind("<KeyRelease-Control_L>",lambda ev: curs(0))

        if 0:

            self.tag_bind(line,"<Control-ButtonPress-1>",self.new_point_at_mouse)

    def _draw_handle_points(self,visible_idxs,visible_points):

        for i,p in zip(visible_idxs,visible_points):

            rad=3

            worldp = p

            p = self.screen_from_world(p)

            if worldp[1] == 0:

                rad += 3

            #self.tag_bind('handle%d' % i, "<Key-d>",

            #              lambda ev, i=i: self.remove_point_idx(i))

            self.dots[i]=dot

        def delpoint(ev):

            # had a hard time tag_binding to the points, so i trap at

            # the widget level (which might be nice anyway when there

            # are multiple pts selected)

            if self.selected_points:

                self.remove_point_idx(*self.selected_points)

        self.highlight_selected_dots()

    def find_index_near(self,x,y):

        tags = self.gettags(self.find_closest(x, y))

        try:

            handletags = [t for t in tags if t.startswith('handle')]

            return int(handletags[0][6:])

        except IndexError:

            raise ValueError("no point found")

    def new_point_at_mouse(self, ev):

                newsel.append(sp)

            for ii in range(len(idxs)):

                if ii > i:

                    ii -= 1

                newidxs.append(idxs[ii])

            self.selected_points[:] = newsel

            idxs[:] = newidxs

        self.update_curve()

    def highlight_selected_dots(self):

        for i,d in self.dots.items():

            if i in self.selected_points:

                self.itemconfigure(d,fill='red')

            else:

                self.itemconfigure(d,fill='blue')

    def dotpress(self,ev,dotidx):

        self.print_state("dotpress")

        if dotidx not in self.selected_points:

            self.selected_points=[dotidx]

        self.highlight_selected_dots()

        self.last_mouse_world = self.world_from_screen(ev.x, ev.y)

        self.last_mouse_world = None

        self.dragging_dots = False

class CurveRow(object):

    """

    one of the repeating curve rows (including widgets on the left)

    please pack self.box

    """

    def __init__(self, name, curve, slider, knobEnabled):

        self.box = gtk.HandleBox()

        cols = gtk.HBox()

        self.box.add(cols)

        controls = gtk.Frame()

        controls.set_size_request(115, -1)

        controls.set_shadow_type(gtk.SHADOW_OUT)

        cols.pack_start(controls, expand=False)

        self.setupControls(controls, name, curve, slider)

        self.curveView = Curveview(curve, knobEnabled=knobEnabled,

                                   isMusic=name in ['music', 'smooth_music'])