import locale
locale.setlocale(locale.LC_NUMERIC, 'C')
import signal , time , sys , os, shutil
import pygtk
pygtk.require( '2.0' )
import gtk

import gobject
import time

import common.Config as Config
from   common.Util.CSoundClient import new_csound_client
from   common.Util.Profiler import TP

from   common.Util.InstrumentPanel import InstrumentPanel
from   Mini.miniTamTamMain import miniTamTamMain
from   common.Util.Trackpad import Trackpad
from   gettext import gettext as _
import commands
from sugar.activity import activity

class TamTamMini(activity.Activity):
    def __init__(self, handle):
        activity.Activity.__init__(self, handle)
        self.ensure_dirs()

        color = gtk.gdk.color_parse(Config.WS_BCK_COLOR)
        self.modify_bg(gtk.STATE_NORMAL, color)

        self.set_title('TamTam Mini')
        self.set_resizable(False)

        self.trackpad = Trackpad( self )

        self.preloadTimeout = None

        self.focusInHandler = self.connect('focus_in_event',self.onFocusIn)
        self.focusOutHandler = self.connect('focus_out_event',self.onFocusOut)
        self.connect('notify::active', self.onActive)
        self.connect('destroy', self.onDestroy)
        self.connect( "key-press-event", self.onKeyPress )
        self.connect( "key-release-event", self.onKeyRelease )


        self.instrumentPanel = InstrumentPanel( force_load = False )
        self.preloadList = [ self.instrumentPanel ]

        #load the sugar toolbar
        self.toolbox = activity.ActivityToolbox(self)
        self.set_toolbox(self.toolbox)

        self.activity_toolbar = self.toolbox.get_activity_toolbar()
        self.activity_toolbar.share.hide()
        self.activity_toolbar.keep.hide()

        self.toolbox.show()

        self.trackpad.setContext('mini')
        self.mini = miniTamTamMain(self)
        #self.modeList[mode].regenerate()
        if self.instrumentPanel in self.preloadList:
            self.instrumentPanel.load() # finish loading
        self.mini.setInstrumentPanel( self.instrumentPanel )

        self.set_canvas( self.mini )
 
        self.mini.onActivate(arg = None)
        self.show()

    def onPreloadTimeout( self ):
        if Config.DEBUG > 4: print "TamTam::onPreloadTimeout", self.preloadList

        t = time.time()
        if self.preloadList[0].load( t + 0.100 ): # finished preloading this object
            self.preloadList.pop(0)
            if not len(self.preloadList):
                if Config.DEBUG > 1: print "TamTam::finished preloading", time.time() - t
                self.preloadTimeout = False
                return False # finished preloading everything

        if Config.DEBUG > 4: print "TamTam::preload returned after", time.time() - t

        return True

    def onFocusIn(self, event, data=None):
        if Config.DEBUG > 3: print 'DEBUG: TamTam::onFocusOut in TamTam.py'
        csnd = new_csound_client()
        csnd.connect(True)
        if self.mode == 'synth':
            self.modeList[ self.mode ].updateSound()
            self.modeList[ self.mode ].updateTables()
        #csnd.load_instruments()

    def onFocusOut(self, event, data=None):
        if Config.DEBUG > 3: print 'DEBUG: TamTam::onFocusOut in TamTam.py'
        csnd = new_csound_client()
        csnd.connect(False)
        
    def onActive(self, widget = None, event = None):
        pass
        
    def onKeyPress(self, widget, event):
        if Config.DEBUG > 5: print 'DEBUG: TamTam::onKeyPress in TamTam.py'
        if event.state == gtk.gdk.MOD1_MASK:
            key = event.keyval
            if key == gtk.keysyms.j:
                self.set_mode("jam")
                return
            elif key == gtk.keysyms.m:
                self.set_mode('mini')
                return
            elif key == gtk.keysyms.s:
                self.set_mode('synth')
                return
            elif key == gtk.keysyms.w:
                self.set_mode('welcome')
                return
            elif key == gtk.keysyms.e:
                self.set_mode('edit')
                return
            elif key == gtk.keysyms.t:
                self.toolbox.show()
                return
            elif key == gtk.keysyms.y:
                self.toolbox.hide()
        if self.mode:
            self.modeList[ self.mode ].onKeyPress(widget, event)

    def onKeyRelease(self, widget, event):
        if Config.DEBUG > 5: print 'DEBUG: TamTam::onKeyRelease in TamTam.py'
        self.modeList[ self.mode ].onKeyRelease(widget, event)
        pass

    def onDestroy(self, arg2):
        if Config.DEBUG: print 'DEBUG: TamTam::onDestroy()'
        os.system('rm -f ' + Config.PREF_DIR + '/synthTemp*')

        for m in self.modeList:
            if self.modeList[m] != None:
                self.modeList[m].onDestroy()

        csnd = new_csound_client()
        csnd.connect(False)
        csnd.destroy()

        gtk.main_quit()

    def ensure_dir(self, dir, perms=0777, rw=os.R_OK|os.W_OK):
        if not os.path.isdir( dir ):
            try:
                os.makedirs(dir, perms)
            except OSError, e:
                print 'ERROR: failed to make dir %s: %i (%s)\n' % (dir, e.errno, e.strerror)
        if not os.access(dir, rw):
            print 'ERROR: directory %s is missing required r/w access\n' % dir

    def ensure_dirs(self):
        self.ensure_dir(Config.TUNE_DIR)
        self.ensure_dir(Config.SYNTH_DIR)
        self.ensure_dir(Config.SNDS_DIR)
        self.ensure_dir(Config.SCRATCH_DIR)

        if not os.path.isdir(Config.PREF_DIR):
            os.mkdir(Config.PREF_DIR)
            os.system('chmod 0777 ' + Config.PREF_DIR + ' &')
            for snd in ['mic1','mic2','mic3','mic4','lab1','lab2','lab3','lab4', 'lab5', 'lab6']:
                shutil.copyfile(Config.SOUNDS_DIR + '/' + snd , Config.SNDS_DIR + '/' + snd)
                os.system('chmod 0777 ' + Config.SNDS_DIR + '/' + snd + ' &')

    def read_file(self,file_path):
        self.metadata['tamtam_subactivity'] = 'mini'
        
    def write_file(self,file_path):
        f = open(file_path,'w')
        f.close()