gtk2reactor.install()

from twisted.internet import reactor

import time, textwrap, os, optparse, gtk, linecache, signal, traceback, json

from urlparse import parse_qsl

import louie as dispatcher 

from rdflib import URIRef, Graph, Literal, RDF, RDFS

import logging

log = logging.getLogger()

import run_local

from light9 import showconfig, prof, networking

from light9.curvecalc.curve import Curveset

from light9.curvecalc import curveview 

from light9.curvecalc.musicaccess import Music, currentlyPlayingSong

from light9.wavelength import wavelength

from light9.namespaces import L9

from light9.curvecalc.subterm import savekey, graphPathForSubterms

from light9.curvecalc.subtermview import add_one_subterm

from light9.curvecalc.output import Output

from light9.gtkpyconsole import togglePyConsole

from light9.rdfdb.syncedgraph import SyncedGraph

class SubtermExists(ValueError):

    pass

class Main(object):

        self.curveset, self.subterms, self.music = curveset, subterms, music

        self.lastSeenInputTime = 0

        wtree = self.wtree = gtk.Builder()

        wtree.add_from_file("light9/curvecalc/curvecalc.glade")

        mainwin = wtree.get_object("MainWindow")

        mainwin.connect("destroy", self.onQuit)

        wtree.connect_signals(self)

        gtk.rc_parse("theme/marble-ice/gtk-2.0/gtkrc")

        gtk.rc_parse_string("""style "default" {font_name = "sans 7"}""")

        if self.opts.reload:

            self.refreshTheme()

        mainwin.show_all()

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

        def updateTitle():

            # song will soon be a lookup on this curvecalc session

        graph.addHandler(updateTitle)

        mainwin.parse_geometry("1x1-0+0")

        # this is the only one i found that would set the size right,

        # but it's a minimum size, which i don't really want

        mainwin.set_size_request(1678, 922)

        wtree.get_object("subterms").connect("add", self.onSubtermChildAdded)

        graph.addHandler(self.add_subterms_for_song)

        self.refreshCurveView()       

        if (uri, RDF.type, L9.Subterm) in self.graph:

            raise SubtermExists("already have a subterm named %r" % newname)

        self.graph.add((uri, RDF.type, L9.Subterm))

        self.graph.add((uri, RDFS.label, Literal(newname)))

        self.graph.add((self.song, L9['subterm'], uri))

        if withCurve:

            self.curveset.new_curve(newname)

    def add_subterms_for_song(self):

        master = self.wtree.get_object("subterms")

        [master.remove(c) for c in master.get_children()]

            add_one_subterm(self.graph,

                            self.graph.value(st, L9['sub']),

                            self.curveset,

                            self.subterms,

                            master,

                            self.graph.value(st, L9['expression']))

        master.show_all()

    def refreshTheme(self):

        gtk.rc_reparse_all()

        reactor.callLater(1, self.refreshTheme)

    def onZoomAll(self, item):

        dispatcher.send("show all")

    def onPlayPause(self, item):

        # since the X coord in a curveview affects the handling, one

        # of them may be able to pick this up

        results = dispatcher.send("onPlayPause")

        times = [t for listener, t in results if t is not None]

        self.music.playOrPause(t=times[0] if times else None)

    def onSave(self, *args):

    def makeStatusLines(self, master):

        """various labels that listen for dispatcher signals"""

        for row, (signame, textfilter) in enumerate([

            ('input time', lambda t: "%.2fs"%t),

            ('output levels',

             lambda levels: textwrap.fill("; ".join(["%s:%.2f"%(n,v)

                                                     for n,v in

                                                     levels.items()[:2]

                                                     if v>0]),70)),

            ('update period', lambda t: "%.1fms"%(t*1000)),

            ('update status', lambda x: str(x)),

                # this is scheduled after some tk shuffling, to

                # try to minimize the number of times we redraw

                # the curve at startup. If tk is very slow, it's

                # ok. You'll just get some wasted redraws.

                self.curvesetView.goLive()

            except Exception:

                print "reload failed:"

                traceback.print_exc()

        if self.opts.reload:

            reactor.callLater(1, self.refreshCurveView)

def main():

    startTime = time.time()

    parser = optparse.OptionParser()

    parser.set_usage("%prog [opts] [songURI]")

    parser.add_option("--sliders", action='store_true',

                      help='use hardware sliders')

    parser.add_option("--skip-music", action='store_true',

                      help="ignore music and smooth_music curve files")

    parser.add_option("--debug", action="store_true",

                      help="log at DEBUG")

    parser.add_option("--reload", action="store_true",

                      help="live reload of themes and code")

    parser.add_option("--startup-only", action='store_true',

                      help="quit after loading everything (for timing tests)")

    opts, args = parser.parse_args()

    logging.basicConfig(format="%(asctime)s %(levelname)-5s %(name)s %(filename)s:%(lineno)d: %(message)s")

    log.setLevel(logging.DEBUG if opts.debug else logging.INFO)

    log.debug("startup: music %s", time.time() - startTime)

    music = Music()

    graph = SyncedGraph("curvecalc")

    curveset = Curveset(sliders=opts.sliders)

    subterms = []

    log.debug("startup: output %s", time.time() - startTime)

    out = Output(subterms, music)

    dispatcher.send("show all")

    if opts.startup_only:

        log.debug("quitting now because of --startup-only")

        return

    from twisted.web import server, resource

    class Hover(resource.Resource):

        isLeaf = True

        def render_GET(self, request):

            if request.path == '/hoverTime':

                results = dispatcher.send("onPlayPause")

                times = [t for listener, t in results if t is not None]

                if not times:

                    request.setResponseCode(404)

                    return "not hovering over any time"

            raise NotImplementedError()

    reactor.listenTCP(networking.curveCalc.port,

                      server.Site(Hover()))

    prof.run(reactor.run, profile=False)

prof.run(main, profile=False)

        self.sliderCurve = {} # slider number (1 based) : curve name

        self.sliderNum = {} # reverse

        if sliders:

            self.sliders = Sliders(self.hw_slider_in, self.hw_knob_in, 

                                   self.hw_knob_button)

            dispatcher.connect(self.curvesToSliders, "curves to sliders")

            dispatcher.connect(self.knobOut, "knob out")

            self.lastSliderTime = {} # num : time

            self.sliderSuppressOutputUntil = {} # num : time

            self.sliderIgnoreInputUntil = {}

        else:

            self.sliders = None

    def sorter(self, name):

        return (not name in ['music', 'smooth_music'], name)

    def load(self,basename, skipMusic=False):

        """find all files that look like basename-curvename and add

        curves with their contents

        This fires 'add_curve' dispatcher events to announce the new curves.

        """

        for filename in sorted(glob.glob("%s-*"%basename), key=self.sorter):

            curvename = filename[filename.rfind('-')+1:]

            if skipMusic and curvename in ['music', 'smooth_music']:

                continue

            c=Curve()

            c.load(filename)

            curvename = curvename.replace('-','_')

            self.add_curve(curvename,c)

        try:

            self.markers.load("%s.markers" % basename)

        except IOError:

            print "no marker file found"

    def save(self,basename):

        """writes a file for each curve with a name

        like basename-curvename"""

        for name,cur in self.curves.items():

            cur.save("%s-%s" % (basename,name))

        self.markers.save("%s.markers" % basename)

            return

        self.update_time_bar(val)

    def update_time_bar(self, t):

        if not getattr(self, 'timelineLine', None):

            self.timelineGroup = goocanvas.Group(parent=self.root)

            self.timelineLine = goocanvas.Polyline(

                parent=self.timelineGroup,

                points=goocanvas.Points([(0,0), (0,0)]),

                line_width=2, stroke_color='red')

        self._time = t

        if self.knobEnabled:

            self.delete('knob')

            prevKey = self.curve.point_before(t)

            if prevKey is not None:

                pos = self.screen_from_world(prevKey)

                self.create_oval(pos[0] - 8, pos[1] - 8,

                                 pos[0] + 8, pos[1] + 8,

                                 outline='#800000',

                                 tags=('knob',))

                dispatcher.send("knob out", value=prevKey[1], curve=self.curve)

        if t2-t1<30:

            for t in range(int(t1),int(t2)+1):

                tic(t,str(t))

        tic(introPad, str(introPad))

        endtimes = dispatcher.send("get max time")

        if endtimes:

            endtime = endtimes[0][1]

            tic(endtime, "end %.1f"%endtime)

            tic(endtime - postPad, "post %.1f" % (endtime - postPad))

    def _draw_one_tic(self,t,label):

        ht = self.size.height

        goocanvas.polyline_new_line(self.curveGroup,

                                    x, ht,

                                    x, ht - 20,

                                    line_width=.5,

                                    stroke_color='gray70')

        goocanvas.Text(parent=self.curveGroup,

                       fill_color="white",

                       anchor=gtk.ANCHOR_SOUTH,

                       font="ubuntu 7",

                       x=x+3, y=ht-20,

                       text=label)

    def _draw_line(self, visible_points, area=False):

        linepts=[]

        step=1

        linewidth = 1.5

        maxPointsToDraw = self.size.width / 2

        if len(visible_points) > maxPointsToDraw:

            step = int(len(visible_points) / maxPointsToDraw)

            linewidth = .8

        for p in visible_points[::step]:

            linepts.append((int(x) + .5, int(y) + .5))

        if self.curve.muted:

            fill = 'grey34'

        else:

            fill = 'white'

        if area:

            base = base + linewidth / 2

            goocanvas.Polyline(parent=self.curveGroup,

                               points=goocanvas.Points(

                                   [(linepts[0][0], base)] +

                                   linepts +

                                   [(linepts[-1][0], base)]),

                               close_path=True,

                               line_width=0,

                               fill_color="green",

                               )

        self.pl = goocanvas.Polyline(parent=self.curveGroup,

                                     points=goocanvas.Points(linepts),

                                     line_width=linewidth,

                                     stroke_color=fill,

                                     )

    def _draw_handle_points(self,visible_idxs,visible_points):

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

            rad=3

            worldp = p

            dot = goocanvas.Rect(parent=self.curveGroup,

                                 x=int(p[0] - rad) + .5,

                                 y=int(p[1] - rad) + .5,

                                 width=rad * 2, height=rad * 2,

                                 stroke_color='gray90',

                                 fill_color='blue',

                                 line_width=1,

                                 #tags=('curve','point', 'handle%d' % i)

                                 )

            if worldp[1] == 0:

                rad += 3

        glo['smoove'] = smoove

        def aft(t, x, smooth=0):

            left = x - smooth / 2

            right = x + smooth / 2

            if left < t < right:

                return smoove((t - left) / (right - left))

            return t > x

        glo['aft'] = lambda x, smooth=0: aft(t, x, smooth)

        def chan(name):

            return Submaster.Submaster(

        glo['chan'] = chan

        def smooth_random(speed=1):

            """1 = new stuff each second, <1 is slower, fade-ier"""

            x = (t * speed) % len(self._smooth_random_items)

            x1 = int(x)

            x2 = (int(x) + 1) % len(self._smooth_random_items)

            y1 = self._smooth_random_items[x1]

            y2 = self._smooth_random_items[x2]

            return y1 + (y2 - y1) * ((x - x1))

        def notch_random(speed=1):

        # we prevent any exceptions from escaping, since they cause us to

        # stop sending levels

        try:

            if isinstance(subexpr_eval, Submaster.Submaster):

                # if the expression returns a submaster, just return it

                return subexpr_eval

            else:

                # otherwise, return our submaster multiplied by the value 

                # returned

                return self.submaster * subexpr_eval

        except Exception, e:

            dispatcher.send("expr_error", sender=self.subexpr, exc=str(e))

    def __repr__(self):

        return "<Subterm %s %s>" % (self.submaster, self.subexpr)

def graphPathForSubterms(song):

    return showconfig.subtermsForSong(showconfig.songFilenameFromURI(song)) + ".n3"

def createSubtermGraph(song, subterms):

    """rdf graph describing the subterms, readable by add_subterms_for_song"""

    graph = Graph()

    for subterm in subterms:

        uri = URIRef(song + "/subterm/" + subterm.submaster.name)

        graph.add((song, L9['subterm'], uri))

        graph.add((uri, RDF.type, L9['Subterm']))

        graph.add((uri, RDFS.label, Literal(subterm.submaster.name)))

        graph.add((uri, L9['sub'], L9['sub/%s' % subterm.submaster.name]))

        graph.add((uri, L9['expression'], Literal(subterm.subexpr.expr)))

    return graph

def savekey(song, subterms, curveset):

    g = createSubtermGraph(song, subterms)

    g.serialize(graphPathForSubterms(song), format="nt")

    curveset.save(basename=os.path.join(showconfig.curvesDir(),

                                        showconfig.songFilenameFromURI(song)))

        self.redrawzoom()

    def see_time_until_end(self, t=None):

        """defaults to current time"""

        if t is None:

            t = self.lastTime

        self.start = t - 2

        self.end = self.maxtime

        self.redrawzoom()

        self.lastTime = val

        self.time.set_property("points",

                               goocanvas.Points([(x, 0),

                                                 (x, self.size.height)]))

    def press(self,ev,attr):

        self.adjustingattr = attr

    def release(self, widget, ev):

        if hasattr(self,'adjustingattr'):

            del self.adjustingattr

        if hasattr(self,'lastx'):

            del self.lastx

    def t_for_can(self,x):

        a, b = self.mintime, self.maxtime

        return (x - 20) / (self.size.width - 30) * (b - a) + a

    def redrawzoom(self,*args):

        """redraw pieces based on start/end"""

        self.size = self.widget.get_allocation()

        dispatcher.send("zoom changed")

        if not hasattr(self,'created'):

            return

        y1, y2 = 3, self.size.height - 3

        lip = 6

        self.leftbrack.set_property("points", goocanvas.Points([

            (scan + lip, y1),

            (scan, y1),

            (scan, y2),

            (scan + lip, y2)]))

        self.rightbrack.set_property("points", goocanvas.Points([

            (ecan - lip, y1),

            (ecan, y1),

            (ecan, y2),

            (ecan - lip, y2)]))

        self.shade.set_properties(