#!/usr/bin/env python2.4

# Based on:
#   <http://www.maemo.org/platform/docs/pymaemo/python_maemo_howto.html>

#
# Author: follower@rancidbacon.com
#
# License: GPL 2.0
#

#
# State: Proof of concept
#

import gtk
import gobject
import hildon

import math

import logging; logging.getLogger().setLevel(logging.DEBUG)


## From:
#
#   <http://maemo.org/lxr/source/hildon-libs/hildon-widgets/hildon-defines.h>
# (Should really be in `hildon` module or somewhere.)
#
HILDON_HARDKEY_UP         = gtk.keysyms.Up
HILDON_HARDKEY_LEFT       = gtk.keysyms.Left
HILDON_HARDKEY_RIGHT      = gtk.keysyms.Right
HILDON_HARDKEY_DOWN       = gtk.keysyms.Down
HILDON_HARDKEY_SELECT     = gtk.keysyms.Return
HILDON_HARDKEY_HOME       = gtk.keysyms.F5
HILDON_HARDKEY_ESC        = gtk.keysyms.Escape
HILDON_HARDKEY_FULLSCREEN = gtk.keysyms.F6
HILDON_HARDKEY_INCREASE   = gtk.keysyms.F7
HILDON_HARDKEY_DECREASE   = gtk.keysyms.F8
HILDON_HARDKEY_MENU       = gtk.keysyms.F10
##

        

class MyApp(hildon.Program):
    def __init__(self):
        hildon.Program.__init__(self)

        self.window = hildon.Window()
        
        self.window.connect("destroy", self.onQuit)

        
        self.add_window(self.window)


        self.window.connect("key-press-event", self.onKeyPress)

        # This and related fullscreen code is from:
        #   <http://maemo.org/platform/docs/pymaemo/python_maemo_howto.html>
        self.window.connect("window-state-event", self.onWindowStateChange)
        self.windowIsFullscreen = False # Not in full screen mode initially.

        self.hbox = gtk.HBox()
        self.window.add(self.hbox)

        #self.ebox = gtk.DrawingArea() #gtk.EventBox() #gtk.Label("foo")
        self.ebox =  gtk.EventBox()

        self.darea = gtk.DrawingArea()
        self.darea.set_size_request(400, 300)

        #print(dir(self.darea.draw))

        self.ebox.add(self.darea)
        #self.hbox.pack_start(self.darea)

        self.darea.connect("expose-event", self.darea_expose_cb)

        #self.ebox.set_events(gtk.gdk.BUTTON_PRESS_MASK)

        #self.ebox.set_events(gtk.gdk.ALL_EVENTS_MASK)

        self.ebox.set_events(gtk.gdk.MOTION_NOTIFY)

        self.hbox.pack_start(self.ebox)

        self.label = gtk.Label("")
        self.label.set_markup("<big><big><big><big>0</big></big></big></big>")
        self.label.set_property('angle', 270)
        
        self.hbox.pack_start(self.label)


        #self.ebox.connect("event", self.onEvent)

        #self.ebox.connect("button-press-event", self.onButtonPress)

        self.ebox.connect("motion-notify-event", self.onMotion)
        

        #logging.debug(self.ebox.get_events())


        #print dir(self.ebox)

        #self.window.add(self.ebox)


    def onEvent(self, widget, event, *args):
        """
        """
        logging.debug("%s" % event.type)

    def onMotion(self, widget, event, *args):
        """
        """
        #logging.debug("%s" % event.type)
        #logging.debug("%s" % event.state)
        #logging.debug("%s, %s" % (event.x, event.y))

        x = event.x
        y = event.y

        xC = 210
        yC = 210

        # From: <http://groups.google.com/group/comp.graphics.algorithms/msg/bad181169b097679>
        #print ((x**2 + y**2) < 200**2) and not ((x**2 + y**2) < 75**2)
        #print 200**2 > ((x-xC)**2 + (y-yC)**2) > 75**2

        if (200**2 > ((x-xC)**2 + (y-yC)**2) > 75**2):
            self.timeout = 1
            if not self.highlight:
                self.draw_wheel(210, 210, True)
                self.highlight = True

                gobject.timeout_add(200, self.unhighlight)

            # TODO: Fix zero div errors
            angle = math.degrees(math.atan((y-yC)/(x-xC))) 

            # TODO: Do this properly, math teachers everywhere are turning
            #       in graves
            fudge = {}
            fudge[(True, True)] = 0
            fudge[(False, True)] = 180 
            fudge[(False, False)] = 180 
            fudge[(True, False)] = 360 

            fudgef = fudge[((abs(x-xC) == x-xC), (abs(y-yC) == y-yC))]
            
            angle += fudgef

            #print angle

            if self.oldAngle is not None:
                adiff = angle-self.oldAngle

                # TODO: Bleh...
                if (adiff > 180):
                    adiff-=360
                elif (adiff < -180):
                    adiff+=360

                #print angle, adiff
                self.onScroll(adiff)
                    
            self.oldAngle = angle


                                    
        else:
            self.highlight = False
            self.draw_wheel(210, 210)


        #logging.debug("%s" % dir(event))

    def unhighlight(self):
        """
        """
        if not self.timeout:
            self.highlight = False
            self.draw_wheel(210, 210)

            self.oldAngle = None
            return False
            
        self.timeout = 0
        return True


    count = 0
    
    def onScroll(self, offset):
        """
        """
        self.count += int(offset * 5)

        self.label.set_markup("<big><big><big><big>%d</big></big></big></big>"
                              % self.count)
        
        #self.label.queue_draw()
        #self.window.window.process_updates(True)

        
        

    def draw_wheel(self, centerX, centerY, highlight = False):
        """
        """

        if highlight:
            fill = True
        else:
            fill = False

        self.gc.set_foreground(self.style.white)
        self.draw_circle(centerX, centerY, 200, True)

        self.gc.set_foreground(self.style.black)

        #fg = self.style.fg[gtk.STATE_NORMAL]

##         if highlight:
##             self.gc.set_foreground(self.style.black)
##         else:
##             self.gc.set_foreground(self.style.white)
            
        self.draw_circle(centerX, centerY, 200, fill)


##         if highlight:
##             self.gc.set_foreground(self.style.white)
##         else:
##             pass

        if highlight:
            self.gc.set_foreground(self.style.white)
        else:
            self.gc.set_foreground(self.style.black)
            
        self.draw_circle(centerX, centerY, 75, fill)

        #self.gc.set_foreground(fg)

        self.gc.set_foreground(self.style.black)
        

        

    def darea_expose_cb(self, area, event):
        """
        """
        logging.debug("exposed")
        self.style = self.darea.get_style()
        self.gc = self.style.fg_gc[gtk.STATE_NORMAL]

        #self.darea.window.draw_points(self.gc,
        #                              [(40, 40), (90, 90), (150, 150)])

        #self.draw_arcs(125,125)

        self.highlight = False
        self.oldAngle = None

        self.draw_wheel(210, 210)

        return True


    def draw_circle(self, x, y, radius, fill = False):
        """
        """
        diameter = radius * 2
        self.darea.window.draw_arc(self.gc, fill,
                                   x - radius, y - radius,
                                   diameter, diameter,
                                   0, 360*64)
        


    def draw_arcs(self, x, y):
        #self.darea.window.draw_arc(self.gc, False, x, y, 150, 150,
        #                          0, 360*64)
        self.draw_circle(x, y, 75)
        self.darea.window.draw_arc(self.gc, False, x-125, y-125, 400, 400,
                                  0, 360*64)        
        #self.darea.window.draw_arc(self.gc, True, x+30, y+20, 10, 10,
        #                          0, 360*64)
        #self.darea.window.draw_arc(self.gc, True, x+50, y+20, 10, 10,
        #                          0, 360*64)
        #self.darea.window.draw_arc(self.gc, True, x+30, y+10, 30, 50,
        #                          210*64, 120*64)
        #self.pangolayout.set_text("Arcs")
        #self.area.window.draw_layout(self.gc, x+5, y+80, self.pangolayout)
        return

        

    def run(self):
        self.window.show_all()

        gtk.main()


    def onQuit(self, exitArg):
        """
        """
        gtk.main_quit(exitArg)


    def onWindowStateChange(self, widget, event, *args):
        """
        """
        if event.new_window_state & gtk.gdk.WINDOW_STATE_FULLSCREEN:
            self.windowIsFullscreen = True
        else:
            self.windowIsFullscreen = False           
     

    def onKeyPress(self, widget, event, *args):
        """
        """
        
        logging.debug("onKeyPress : %d" % event.keyval)

        if event.keyval == HILDON_HARDKEY_FULLSCREEN:
            if self.windowIsFullscreen:
                self.window.unfullscreen()
            else:
                self.window.fullscreen()


    def onButtonPress(self, widget, event, *args):
        """
        """
        logging.debug("onButtonPress : %d" % event.button)


if __name__ == "__main__":
    app = MyApp()
    app.run()