path: root/Edit/MainWindow.py

import pygtk
pygtk.require( '2.0' )
import gtk 

import gobject
from GUI.Core.ThemeWidgets import *

import time

from Framework.Constants import Constants
from Framework.CSound.CSoundConstants import CSoundConstants
from Framework.Generation.Generator import GenerationParameters

from GUI.GUIConstants import GUIConstants
from GUI.GUIConstants import ModKeys
from GUI.Core.MixerWindow import MixerWindow
from GUI.Core.PageView import PageView
from GUI.Core.TuneView import TuneView
from GUI.Core.PageBankView import PageBankView
from GUI.Generation.GenerationParametersWindow import GenerationParametersWindow
from TrackInterface import TrackInterface
from TuneInterface import TuneInterface
from PositionIndicator import PositionIndicator

from Framework.Core.Profiler import TP

from Framework.Generation.Generator import generator1, variate

from Framework.NoteLooper import *

def note_from_CSoundNote( csnote ):
    note = {}
    note['onset'] = csnote.onset
    note['pitch'] = csnote.pitch
    note['amplitude'] = csnote.amplitude
    note['pan'] = csnote.pan
    note['duration'] = csnote.duration
    note['noteId'] = csnote.noteId
    note['trackId'] = csnote.trackId
    note['pageId'] = csnote.pageId
    note['fullDuration'] = csnote.fullDuration
    note['attack'] = csnote.attack
    note['decay'] = csnote.decay
    note['reverbSend'] = csnote.reverbSend
    note['filterType'] = csnote.filterType
    note['filterCutoff'] = csnote.filterCutoff
    note['tied'] = csnote.tied
    note['overlap'] = csnote.overlap
    note['instrumentFlag'] = csnote.instrumentFlag

    return note
#-----------------------------------
# The main TamTam window
#-----------------------------------
class MainWindow( gtk.EventBox ):

    def __init__( self, CSoundClient ):
        self.csnd = CSoundClient
        def formatRoundBox( box, fillcolor ):
            box.set_radius( 10 )
            box.set_border_width( 1 )
            box.set_fill_color( fillcolor )
            box.set_border_color( "#EEE" )
            return box

        def init_GUI():
            self.GUI = {}
            self.GUI["2main"] = gtk.HBox()
            
            def track_menu(trackId, lbl):
                instrumentMenuItem = gtk.MenuItem( lbl )
                instrumentMenu = gtk.Menu()
                instrumentMenuItem.set_submenu( instrumentMenu )
                
                instrumentNames = [ k for k in CSoundConstants.INSTRUMENTS.keys() if k[0:4] != 'drum' ] + ['drum1kit']
                instrumentNames.sort()
                for i in instrumentNames:
                    menuItem = gtk.MenuItem( i )
                    menuItem.connect_object( "activate", self.handleInstrumentChanged, ( trackId, i ) )
                    instrumentMenu.append( menuItem )
                    
                instrumentMenuBar = gtk.MenuBar()
                instrumentMenuBar.append( instrumentMenuItem )
                return instrumentMenuBar
            
            #-------------------------------------------------------------------------
            # left panel
            self.GUI["2leftPanel"] = gtk.VBox()
            # + edit panel
            self.GUI["2editPanel"] = gtk.HBox()
            # + + instrument panel
            self.GUI["2instrumentPanel"] = gtk.VBox()
            self.GUI["2instrumentPanel"].set_size_request( 80, -1 )
            # + + + instrument 1 box
            self.GUI["2instrument1Box"] = formatRoundBox( RoundHBox(), "#9FB" )
            self.GUI["2instrument1volumeAdjustment"] = gtk.Adjustment( 50, 0, 100, 1, 1, 0 )
            self.GUI["2instrument1volumeAdjustment"].connect( "value_changed", self.onTrackVolumeChanged, 0 )
            self.GUI["2instrument1volumeSlider"] = gtk.VScale( self.GUI["2instrument1volumeAdjustment"] )
            self.GUI["2instrument1Box"].pack_start( self.GUI["2instrument1volumeSlider"] )
            #self.GUI["2instrument1Button"] = gtk.Button("Inst 1")
            #self.GUI["2instrument1Box"].pack_start( self.GUI["2instrument1Button"] )
            self.GUI["2instrument1Box"].pack_start( track_menu(0,'?') )
            self.GUI["2instrumentPanel"].pack_start( self.GUI["2instrument1Box"] )
            # + + + instrument 2 box
            self.GUI["2instrument2Box"] = formatRoundBox( RoundHBox(), "#9FB" )
            self.GUI["2instrument2volumeAdjustment"] = gtk.Adjustment( 50, 0, 100, 1, 1, 0 )
            self.GUI["2instrument2volumeAdjustment"].connect( "value_changed", self.onTrackVolumeChanged, 1 )
            self.GUI["2instrument2volumeSlider"] = gtk.VScale( self.GUI["2instrument2volumeAdjustment"] )
            self.GUI["2instrument2Box"].pack_start( self.GUI["2instrument2volumeSlider"] )
            #self.GUI["2instrument2Button"] = gtk.Button("Inst 2")
            #self.GUI["2instrument2Box"].pack_start( self.GUI["2instrument2Button"] )
            self.GUI["2instrument2Box"].pack_start( track_menu(1,'?') )
            self.GUI["2instrumentPanel"].pack_start( self.GUI["2instrument2Box"] )
            # + + + instrument 3 box
            self.GUI["2instrument3Box"] = formatRoundBox( RoundHBox(), "#9FB" )
            self.volumeAdjustment = gtk.Adjustment( 50, 0, 100, 1, 1, 0 )
            self.GUI["2instrument3volumeAdjustment"] = gtk.Adjustment( 50, 0, 100, 1, 1, 0 )
            self.GUI["2instrument3volumeAdjustment"].connect( "value_changed", self.onTrackVolumeChanged, 2 )
            self.GUI["2instrument3volumeSlider"] = gtk.VScale( self.GUI["2instrument3volumeAdjustment"] )
            self.GUI["2instrument3Box"].pack_start( self.GUI["2instrument3volumeSlider"] )
            #self.GUI["2instrument3Button"] = gtk.Button("Inst 3")
            #self.GUI["2instrument3Box"].pack_start( self.GUI["2instrument3Button"] )
            self.GUI["2instrument3Box"].pack_start( track_menu(2,'?') )
            self.GUI["2instrumentPanel"].pack_start( self.GUI["2instrument3Box"] )
            # + + + instrument 4 box
            self.GUI["2instrument4Box"] = formatRoundBox( RoundHBox(), "#9FB" )
            self.GUI["2instrument4volumeAdjustment"] = gtk.Adjustment( 50, 0, 100, 1, 1, 0 )
            self.GUI["2instrument4volumeAdjustment"].connect( "value_changed", self.onTrackVolumeChanged, 3 )
            self.GUI["2instrument4volumeSlider"] = gtk.VScale( self.GUI["2instrument4volumeAdjustment"] )
            self.GUI["2instrument4Box"].pack_start( self.GUI["2instrument4volumeSlider"] )
            #self.GUI["2instrument4Button"] = gtk.Button("Inst 4")
            #self.GUI["2instrument4Box"].pack_start( self.GUI["2instrument4Button"] )
            self.GUI["2instrument4Box"].pack_start( track_menu(3,'?') )
            self.GUI["2instrumentPanel"].pack_start( self.GUI["2instrument4Box"] )
            # + + + drum box
            self.GUI["2drumBox"] = formatRoundBox( RoundHBox(), "#9FB" )
            self.GUI["2drumvolumeAdjustment"] = gtk.Adjustment( 50, 0, 100, 1, 1, 0 )
            self.GUI["2drumvolumeAdjustment"].connect( "value_changed", self.onTrackVolumeChanged, 4 )
            self.GUI["2drumvolumeSlider"] = gtk.VScale( self.GUI["2drumvolumeAdjustment"] )
            self.GUI["2drumBox"].pack_start( self.GUI["2drumvolumeSlider"] )
            self.GUI["2drumButton"] = gtk.Button("?")
            self.GUI["2drumBox"].pack_start( self.GUI["2drumButton"] )
            #self.GUI["2instrument1Box"].pack_start( track_menu(4,'?') )
            self.GUI["2instrumentPanel"].pack_start( self.GUI["2drumBox"] )
            self.GUI["2editPanel"].pack_start( self.GUI["2instrumentPanel"], False )
            # + + track interface
            self.trackInterface = TrackInterface( self.onTrackInterfaceNoteDrag )
            self.GUI["2editPanel"].pack_start( self.trackInterface )
            self.GUI["2leftPanel"].pack_start( self.GUI["2editPanel"] )
            # + tune box
            self.GUI["2tuneBox"] = formatRoundBox( RoundVBox(), "#9FB" )
            self.GUI["2tuneBox"].set_size_request( -1, 80 )
            self.GUI["2tuneScrolledWindow"] = gtk.ScrolledWindow()
            self.GUI["2tuneScrolledWindow"].set_policy( gtk.POLICY_ALWAYS, gtk.POLICY_NEVER )
            self.GUI["2tuneScrolledWindow"].set_shadow_type(gtk.SHADOW_NONE)
            self.tuneInterface = TuneInterface( self )
            self.GUI["2tuneScrolledWindow"].add_with_viewport( self.tuneInterface )
            self.GUI["2tuneBox"].pack_start( self.GUI["2tuneScrolledWindow"] )
            self.GUI["2leftPanel"].pack_start( self.GUI["2tuneBox"], False )
            # + tool panel
            self.GUI["2toolPanel"] = gtk.HBox()
            self.GUI["2toolPanel"].set_size_request( -1, 80 )
            # + + page box
            self.GUI["2pageBox"] = formatRoundBox( RoundHBox(), "#9FB" )
            self.GUI["2pageDeleteButton"] = gtk.Button("Delete")
            self.GUI["2pageDeleteButton"].connect( "clicked", lambda a1:self.removePages() )
            self.GUI["2pageBox"].pack_start( self.GUI["2pageDeleteButton"] )
            self.GUI["2pageNewButton"] = gtk.Button("New")
            self.GUI["2pageNewButton"].connect( "clicked", lambda a1:self.addPage() )
            self.GUI["2pageBox"].pack_start( self.GUI["2pageNewButton"] )
            self.GUI["2pageDuplicateButton"] = gtk.Button("Duplicate")
            self.GUI["2pageDuplicateButton"].connect( "clicked", lambda a1:self.duplicatePages() )
            self.GUI["2pageBox"].pack_start( self.GUI["2pageDuplicateButton"] )
            self.GUI["2toolPanel"].pack_start( self.GUI["2pageBox"], False )
            # + + transport box
            self.GUI["2transportBox"] = formatRoundBox( RoundHBox(), "#9FB" )
            #self.GUI["2pageBox"].set_size_request( 120, -1 )
            self.GUI["2generateButton"] = gtk.Button("Gen")
            self.GUI["2generateButton"].connect( "clicked", self.handleGenerate, None )
            self.GUI["2transportBox"].pack_start( self.GUI["2generateButton"] )
            self.GUI["2keyboardButton"] = gtk.Button("KB")
            self.GUI["2transportBox"].pack_start( self.GUI["2keyboardButton"] )
            self.GUI["2recordButton"] = gtk.Button("Rec")
            self.GUI["2transportBox"].pack_start( self.GUI["2recordButton"] )
            self.GUI["2playButton"] = gtk.ToggleButton("Play")
            self.GUI["2playButton"].connect( "toggled", self.handlePlay, "Page Play" )
            self.GUI["2transportBox"].pack_start( self.GUI["2playButton"] )
            self.GUI["2loopButton"] = gtk.Button("Loop")
            self.GUI["2transportBox"].pack_start( self.GUI["2loopButton"] )
            self.GUI["2toolPanel"].pack_start( self.GUI["2transportBox"] )
            # + + tool box
            self.GUI["2toolBox"] = formatRoundBox( RoundHBox(), "#9FB" )
            self.GUI["2toolPencilButton"] = gtk.Button("Pencil")
            self.GUI["2toolBox"].pack_start( self.GUI["2toolPencilButton"] )
            self.GUI["2toolPointerButton"] = gtk.Button("Pointer")
            self.GUI["2toolBox"].pack_start( self.GUI["2toolPointerButton"] )
            self.GUI["2toolPanel"].pack_start( self.GUI["2toolBox"] )
            self.GUI["2leftPanel"].pack_start( self.GUI["2toolPanel"], False )
            self.GUI["2main"].pack_start( self.GUI["2leftPanel"] )
            
            #------------------------------------------------------------------------
            # right panel
            self.GUI["2rightPanel"] = gtk.VBox()
            self.GUI["2rightPanel"].set_size_request( 80, -1 )
            # + mode panel
            self.GUI["2modePanel"] = gtk.HBox()
            self.GUI["2modePanel"].set_size_request( -1, 30 )
            # + + mode 1 box
            self.GUI["2mode1Box"] = formatRoundBox( RoundHBox(), "#9FB" )
            self.GUI["2mode1Button"] = gtk.Button("I")
            self.GUI["2mode1Box"].pack_start( self.GUI["2mode1Button"] )
            self.GUI["2modePanel"].pack_start( self.GUI["2mode1Box"] )
            # + + mode 3 box
            self.GUI["2mode3Box"] = formatRoundBox( RoundHBox(), "#9FB" )
            self.GUI["2mode3Button"] = gtk.Button("III")
            self.GUI["2mode3Box"].pack_start( self.GUI["2mode3Button"] )
            self.GUI["2modePanel"].pack_start( self.GUI["2mode3Box"] )
            self.GUI["2rightPanel"].pack_start( self.GUI["2modePanel"], False )
            # + title box
            self.GUI["2titleBox"] = formatRoundBox( RoundVBox(), "#9FB" )
            self.GUI["2titleImage"] = gtk.Image()
            self.GUI["2titleImage"].set_from_file( "Resources/Images/add.png" )
            self.GUI["2titleBox"].pack_start( self.GUI["2titleImage"] )
            self.GUI["2rightPanel"].pack_start( self.GUI["2titleBox"] )
            # + save box
            self.GUI["2saveBox"] = formatRoundBox( RoundVBox(), "#9FB" )
            self.GUI["2saveBox"].set_size_request( -1, 120 )
            self.GUI["2saveButton"] = gtk.Button("Save")
            self.GUI["2saveBox"].pack_start( self.GUI["2saveButton"] )
            self.GUI["2meshButton"] = gtk.Button("Mesh")
            self.GUI["2saveBox"].pack_start( self.GUI["2meshButton"] )
            self.GUI["2rightPanel"].pack_start( self.GUI["2saveBox"], False )
            self.GUI["2saveButton"].connect("clicked", self.handleSave, None )
            self.GUI["2meshButton"].connect("clicked", self.handleLoad, None )

            # + volume box
            self.GUI["2volumeBox"] = formatRoundBox( RoundHBox(), "#9FB" )
            self.GUI["2volumeAdjustment"] = gtk.Adjustment( 50, 0, 100, 1, 1, 0 )
            self.GUI["2volumeSlider"] = ImageVScale( "Resources/Images/sliderbutbleu.png", self.GUI["2volumeAdjustment"], 22 )
            self.GUI["2volumeBox"].pack_start( self.GUI["2volumeSlider"] )
            self.GUI["2tempoAdjustment"] = gtk.Adjustment( 50, 0, 100, 1, 1, 0 )
            self.GUI["2tempoSlider"] = ImageVScale( "Resources/Images/sliderbutbleu.png", self.GUI["2tempoAdjustment"], 22 )
            self.GUI["2volumeBox"].pack_start( self.GUI["2tempoSlider"] )
            self.GUI["2rightPanel"].pack_start( self.GUI["2volumeBox"] )
            self.GUI["2main"].pack_start( self.GUI["2rightPanel"], False )
            
            self.add( self.GUI["2main"] )
            
            self.addPage( 0, 4 ) # yeah! a page!
            
        def init_data( ):
            self._data = {}

            #[ volume, ... ]
            self._data['track_volume'] = [ Constants.DEFAULT_VOLUME ] * Constants.NUMBER_OF_TRACKS
            self._data['track_mute']   = [ 1.0 ] * Constants.NUMBER_OF_TRACKS

            #[ instrument index, ... ]
            track_inst = [
                    CSoundConstants.FLUTE,
                    CSoundConstants.KOTO,
                    CSoundConstants.GAM, 
                    CSoundConstants.GUIT,
                    CSoundConstants.DRUM1KIT ]
            if len(track_inst) != Constants.NUMBER_OF_TRACKS: raise 'error'

            self._data['track_inst'] = track_inst + [CSoundConstants.FLUTE] * (Constants.NUMBER_OF_TRACKS - len( track_inst) )
            #{ pageId: { [track 0 = note list], [track 2 = note list], ... ] }
            npages = 40
            nbeats = 4

            self._data['page_beats'] = [nbeats  for p in range(npages)]
            self._data['tempo'] = Constants.DEFAULT_TEMPO
            self._data['tune'] = []
            self._data['notebin'] = []
            self._noteId = {}
            self._noteIdBase = 0
            
            self._data["pages"] = []
            self._pageIdBase = 0

        # these helper functions do not 
        # run in any particular order.... 
        # TODO: give these functions better names, put them in execution order, cut hierarchy

        def setupGUI( ):
            
            self.volumeFunctions = {}

            self.generateParametersWindow = GenerationParametersWindow( self.generate, self.variate, self.handleCloseGenerateWindow )
            
            setupGlobalControls()
            setupPageControls()
            setupTrackControls()
            #setupMainView()

            #self.tuneView = TuneView( self.onTuneViewSelect )
            #self.pageBankView = PageBankView( self.onPageBankSelect, self.onPageBankDrop )
                    
            self.mainWindowBox = gtk.HBox( False, 5 )

            self.globalControlsBox = gtk.VBox( False )
     
            self.fpsText = gtk.Label( "" )
            self.globalControlsBox.pack_start( self.fpsText, False )
            self.globalControlsBox.pack_start( self.globalControlsFrame, True )

            self.mainWindowBox.pack_start( self.globalControlsBox, False )

            
            controlsBox = gtk.VBox( False, 5 )
            controlsBox.pack_start( self.trackControlsBox, False )
            #TODO: this Label is temporary!!
            controlsBox.pack_start( gtk.Label( "" ), True )
            controlsBox.pack_start( self.pageControlsBox, False )
            self.mainWindowBox.pack_start( controlsBox, False )
            
            self.trackPagesBox = gtk.VBox( False )
            #self.trackPagesBox.pack_start( self.mainView, True )
            #self.trackPagesBox.pack_start( self.tuneView, False )
            #self.trackPagesBox.pack_start( self.pageBankView, False, True, 5 )
            
            self.mainWindowBox.pack_start( self.trackPagesBox )
            
            #self.add( self.mainWindowBox )

        # contains TAM-TAM and OLPC labels, as well as the volume and tempo sliders
        def setupGlobalControls( ):
            self.globalControlsFrame = gtk.Frame()
            self.globalControlsFrame.set_shadow_type( gtk.SHADOW_ETCHED_OUT )
            
            self.globalControlsBox = gtk.VBox()
            
            self.tamTamLabel = gtk.Label( "     TAM - TAM     " )
            self.globalControlsBox.pack_start( self.tamTamLabel )
            
            self.mainSlidersBox = gtk.HBox()
            self.volumeAdjustment = gtk.Adjustment( 50, 0, 100, 1, 1, 0 )
            self.volumeAdjustment.connect( "value_changed", self.onVolumeChanged, None )
            self.volumeSlider = gtk.VScale( self.volumeAdjustment )
            self.volumeSlider.set_draw_value( False )
            self.volumeSlider.set_digits( 0 )
            self.volumeSlider.set_inverted( True )
            self.mainSlidersBox.pack_start( self.volumeSlider, True, True, 4 )
            
            self.tempoAdjustment = gtk.Adjustment( 100, 60, 180, 1, 1, 0 )
            self.tempoAdjustment.connect( "value_changed", self.onTempoChanged, None )
            self.tempoSlider = gtk.VScale( self.tempoAdjustment )
            self.tempoSlider.set_draw_value( False )
            self.tempoSlider.set_digits( 0 )
            self.tempoSlider.set_inverted( True )
            self.mainSlidersBox.pack_start( self.tempoSlider )

            self.beatsPerPageAdjustment = gtk.Adjustment( 4, 1, 8, 1, 1, 0 )
            self.beatsPerPageAdjustment.connect( "value_changed", self.updateNumberOfBars, None )
            self.barsSlider = gtk.VScale( self.beatsPerPageAdjustment )
            self.barsSlider.set_draw_value( False )
            self.barsSlider.set_digits( 0 )
            self.barsSlider.set_inverted( True )
            self.barsSlider.set_increments( 1, 1 )
            self.barsSlider.set_update_policy( gtk.UPDATE_DELAYED )
            self.mainSlidersBox.pack_start( self.barsSlider )

            self.globalControlsBox.pack_start( self.mainSlidersBox )

            self.olpcLabel = gtk.Label( "OLPC" )
            self.globalControlsBox.pack_start( self.olpcLabel )
            
            self.saveButton = gtk.Button("Save")
            self.loadButton = gtk.Button("Open")
            
            fileBox = gtk.HBox()
            fileBox.pack_start( self.saveButton, True )
            fileBox.pack_start( self.loadButton, True )
            self.globalControlsBox.pack_start( fileBox, False )
            self.saveButton.connect("clicked", self.handleSave, None )
            self.loadButton.connect("clicked", self.handleLoad, None )
            self.globalControlsFrame.add( self.globalControlsBox )

        def setupPageControls( ):
            self.pageControlsBox = gtk.VBox( False )

            self.generateButton = gtk.ToggleButton( "Generate" )
            self.playButton = gtk.ToggleButton( "Play" )
            self.keyboardButton = gtk.ToggleButton( "K" )
            self.keyboardRecordButton = gtk.ToggleButton( "Record" )
            
            self.pageControlsBox.pack_start( self.generateButton, False )
            self.pageControlsBox.pack_start( self.playButton, False )
            
            keyboardBox = gtk.HBox()
            keyboardBox.pack_start( self.keyboardButton, False )
            keyboardBox.pack_start( self.keyboardRecordButton )
            self.pageControlsBox.pack_start( keyboardBox, False )
            
            self.generateButton.connect( "toggled", self.handleGenerate, None )
            self.playButton.connect( "toggled", self.handlePlay, "Page Play" )
            self.keyboardButton.connect( "toggled", self.onKeyboardButton, None )
            self.keyboardRecordButton.connect( "toggled", self.onKeyboardRecordButton, None )
            
        def setupTrackControls( ):
            self.trackControlsBox = gtk.VBox()
            self.instrumentRecordButtons = {}
            for trackId in range( Constants.NUMBER_OF_TRACKS):
                trackControlsBox = gtk.HBox()

                #setup instrument controls
                instrumentControlsBox = gtk.VBox()
                
                instrumentMenu = gtk.Menu()
                instrumentMenuItem = gtk.MenuItem( "Instrument" )
                instrumentMenuItem.set_submenu( instrumentMenu )
                
                instrumentNames = []
                instrumentFolderNames = CSoundConstants.INSTRUMENTS.keys()
                for instrumentName in instrumentFolderNames:
                    if not instrumentName[0: 4] == 'drum':
                       instrumentNames.append( instrumentName )

                instrumentNames.append( 'drum1kit' )
                instrumentNames.sort()
                for instrumentName in instrumentNames:
                    menuItem = gtk.MenuItem( instrumentName )
                    menuItem.connect_object( "activate", self.handleInstrumentChanged, ( trackId, instrumentName ) )
                    instrumentMenu.append( menuItem )
                    
                instrumentMenuBar = gtk.MenuBar()
                instrumentMenuBar.append( instrumentMenuItem )
                instrumentControlsBox.pack_start( instrumentMenuBar )
                
                recordButton = gtk.Button()
                recordButton.set_size_request( 15, 15 )
                self.instrumentRecordButtons[ trackId ] = recordButton
                instrumentControlsBox.pack_start( recordButton, False )
                
                trackControlsBox.pack_start( instrumentControlsBox )

                #setup playback controls
                playbackControlsBox = gtk.VBox()
                
                muteButton = gtk.ToggleButton()
                muteButton.set_size_request( 15, 15 )
                playbackControlsBox.pack_start( muteButton, False )
                
                volumeAdjustment = gtk.Adjustment( 0.8, 0, 1, 0.01, 0.01, 0 )
                volumeAdjustment.connect( "value_changed", self.onTrackVolumeChanged, trackId )
                self.volumeFunctions[ trackId ] = volumeAdjustment.get_value
                volumeSlider = gtk.VScale( volumeAdjustment )
                volumeSlider.set_update_policy( 0 )
                volumeSlider.set_digits( 2 )
                volumeSlider.set_draw_value( False )
                volumeSlider.set_digits( 0 )
                volumeSlider.set_inverted( True )
                playbackControlsBox.pack_start( volumeSlider, True )
                            
                trackControlsBox.pack_start( playbackControlsBox )

                trackName = "Track %i" % trackId
                muteButton.connect( "toggled", self.onMuteTrack, trackId )

                self.trackControlsBox.pack_start( trackControlsBox )
    
        gtk.EventBox.__init__( self )
            
        # keyboard variables
        self.kb_active = False
        self.kb_record = False
        self.kb_mono = False
        self.kb_keydict = {}

        # playback params
        self.playing = False
        self.playSource = 'Page'
        self.currentpageId = 0
        self.playingTuneIdx = 0

        # FPS stuff
        self.fpsTotalTime = 0
        self.fpsFrameCount = 0
        self.fpsN = 100 # how many frames to average FPS over
        self.fpsLastTime = time.time() # fps will be borked for the first few frames but who cares?
        
        init_data()   #above
        setupGUI()    #above #TEMP
        init_GUI()    #above
		
        self.noteLooper = NoteLooper( 
                0.2,
                Constants.DEFAULT_TEMPO * 0.2,   #0.2 currently converts beats per second to seconds_per_tick
                [e for e in self._data['track_inst']], 
                [e for e in self._data['track_volume']],
                [e for e in self._data['track_mute']])

        self.csnd.setMasterVolume( self.getVolume() )
        
        #for pageId in range( GUIConstants.NUMBER_OF_PAGE_BANK_ROWS * GUIConstants.NUMBER_OF_PAGE_BANK_COLUMNS ):
        #    self.pageBankView.addPage( pageId, False )
        
        for tid in range(Constants.NUMBER_OF_TRACKS):
            self.handleInstrumentChanged( ( tid, self._data['track_inst'][tid] ) )

        #self.handleConfigureEvent( None, None ) # needs to come after pages have been added in initialize()
        
        self.show_all()  #gtk command
    
    def updateFPS( self ):
        t = time.time()
        dt = t - self.fpsLastTime
        self.fpsLastTime = t
        self.fpsTotalTime += dt
        self.fpsFrameCount += 1
        if self.fpsFrameCount == self.fpsN:
            fps = self.fpsN/self.fpsTotalTime
            avgMS = 1000/fps
            fps = "FPS %d ms %.2f" % (fps, avgMS)
            #self.fpsText.set_text(fps )
            print fps
            self.fpsTotalTime = 0
            self.fpsFrameCount = 0

    #-----------------------------------
    # playback functions
    #-----------------------------------
    def handlePlay( self, widget, data ):

        def shutOffCSound():
            for track in range( Constants.NUMBER_OF_TRACKS ):
                for i in range( 3 ):
                    csoundInstrument = i + 5001
                    self.csnd.sendText( CSoundConstants.PLAY_NOTE_OFF_COMMAND % ( csoundInstrument, track ) )

        if widget.get_active():  #play

            #TODO: check for track activation, to not take all
            trackset = set(range(Constants.NUMBER_OF_TRACKS))

            self.noteLooper.clear()       #erase all loaded notes
            notes = []

            pagedelay = 0
            self.pages_playing = self.tuneInterface.getSelectedIds()
            for p in self.pages_playing:
                notes += [(n['onset'] + pagedelay, n) for n in self._data['notebin'] \
                        if n['pageId']==p and n['trackId'] in trackset ]
                pagedelay += self._data['page_beats'][p] * Constants.TICKS_PER_BEAT

            self.noteLooper.insert(notes)
            self.noteLooper.setDuration( pagedelay )
            self.noteLooper.setTick(0)    #TODO: get playback head position
            self.noteLooper.setRate( round( self.tempoAdjustment.value, 0 ) * 0.2 )

            self.csnd.startTime()
            cmds = self.noteLooper.next()
            for c in cmds: self.csnd.sendText( c )
            time.sleep(0.001)
            self.playbackTimeout = gobject.timeout_add( 100, self.onTimeout )
            self.playing = True

        else:                    #stop
            gobject.source_remove( self.playbackTimeout )
            shutOffCSound()
            self.playing = False


        self.kb_record = self.playButton.get_active() and self.keyboardRecordButton.get_active() and self.keyboardButton.get_active()

    def onTimeout(self):

        cmds = self.noteLooper.next()
        for c in cmds: self.csnd.sendText( c )

        self.updateFPS()

        curtick = self.noteLooper.getCurrentTick(0,True, time.time())
        curIdx =  curtick / ( 4 * Constants.TICKS_PER_BEAT) #TODO handle each pages_playing length
        self.tuneInterface.displayPage( self.pages_playing[curIdx], 0 )
        self.trackInterface.displayPage(self.pages_playing[curIdx], 4 )  #TODO: use page_beats

        return True

    def onMuteTrack( self, widget, trackId ):
        self._data['track_mute'][trackId] = not self._data['track_mute'][trackId] 
        if self._data['track_mute'][trackId]:
            self.noteLooper.setMute( trackId, 0.0 )
        else:
            self.noteLooper.setMute( trackId, 1.0 )

    def onTrackVolumeChanged( self, widget, trackId ):
        v =  widget.get_value() / 100.0
        self._data['track_volume'][trackId] = v
        self.noteLooper.setVolume( trackId, v )
        
    # data is tuple ( trackId, instrumentName )
    def handleInstrumentChanged( self, data ):
        (id, instrumentName) = data
        self._data['track_inst'][id] = instrumentName
        print id, instrumentName
        self.noteLooper.setInstrument(id, instrumentName)

        recordButton = self.instrumentRecordButtons[ id ]
        if instrumentName in CSoundConstants.RECORDABLE_INSTRUMENTS:
            recordButton.show()
            recordButton.connect( "clicked", 
                                  self.handleMicRecord,
                                  CSoundConstants.RECORDABLE_INSTRUMENT_CSOUND_IDS[ instrumentName ] )
        else:
            recordButton.hide()

    def onVolumeChanged( self, widget, data ):
    	self.csnd.setMasterVolume(self.getVolume())
       
    def onTempoChanged( self, widget, data ):
        tempo = round( self.tempoAdjustment.value, 0 )
        ticks_per_sec = tempo * 0.2 # 12 BPM / 60 SPM

        self._data['tempo'] = tempo
        self.noteLooper.setRate(ticks_per_sec)

    def onKeyboardButton( self, widget, data ):
        self.kb_active = widget.get_active()
        
    def onKeyboardRecordButton( self, widget, data ):
        if not self.kb_active:
            self.keyboardButton.set_active( True )
            
        self.kb_record = self.playButton.get_active() and self.keyboardRecordButton.get_active()

    def onScoreChange( self, action, noteList ):
        pass

    def onTrackInterfaceNoteDrag( self, dragList ):
        for (id, pitch, onset, duration) in dragList:
            n = self._noteId[id]
            n['pitch'] = pitch
            n['onset'] = onset
            n['duration'] = duration

    #-----------------------------------
    # generation functions
    #-----------------------------------
    def handleGenerate( self, widget, data ):
        #if widget.get_active():
            self.generateParametersWindow.show_all()
        #else:
        #    self.handleCloseGenerateWindow()
            
    def handleCloseGenerateWindow( self, widget = None, data = None ):
        self.generateParametersWindow.hide_all()
        #self.generateButton.set_active( False )
    
    def addNotesToTrackInterface( self, notes ):
        pageList = []
        trackList = []
        noteList = []
        csnoteList = []
        beatList = []

        for n in notes:
            pageList.append( n["pageId"] )
            trackList.append( n["trackId"] )
            noteList.append( n["noteId"] )
            csnoteList.append( n )
            beatList.append( p["beats"] for p in self._data["pages"] if p["pageId"] == n["pageId"] )
         
        self.trackInterface.addNotes( 
                {   "page":pageList,
                    "track":trackList,
                    "note":noteList,
                    "csnote":csnoteList,
                    "beatCount":beatList},
                len(notes) )
                
    def removeNotesFromTrackInterface( self, notes ):
        pageList = []
        trackList = []
        noteList = []
        
        for n in notes:
            pageList.append( n["pageId"] )
            trackList.append( n["trackId"] )
            noteList.append( n["noteId"] )
            
        self.trackInterface.deleteNotes( 
                {   "page":pageList,
                    "track":trackList,
                    "note":noteList },
                len(notes) )
                
    def recompose( self, algo, params):
        def none_to_all(tracks):
            print 'tracks = ',tracks
            if tracks == []: return set(range(0,Constants.NUMBER_OF_TRACKS))
            else:            return set(tracks)

        dict = {}
        for t in range(Constants.NUMBER_OF_TRACKS):
            dict[t] = {}
            for p in range(Constants.NUMBER_OF_PAGES):
                dict[t][p] = []

        newtracks = none_to_all( self.trackInterface.getSelectedTracks())
        newpages  = self.tuneInterface.getSelectedIds()

        algo( 
                params,
                self._data['track_volume'][:],
                self._data['track_inst'][:],
                self._data['tempo'],
                4,  #beats per page TODO: talk to olivier about handling pages of different sizes
                newtracks,
                newpages,
                dict)

        # filter for invalid input
        for track in dict:
            for page in dict[track]:
                for note in dict[track][page]:
                    intdur = int(note.duration)
                    if intdur != note.duration:
                        print "Invalid note duration!"
                    note.duration = intdur
                    note.pageId = page
                    note.trackId = track
                    self._noteIdBase = self._noteIdBase + 1
                    while self._noteIdBase in self._noteId: self._noteIdBase = self._noteIdBase + 1
                    note.noteId = self._noteIdBase

        #add notes to self._data
        newnotes = []
        for tid in dict:
            for pid in dict[tid]:
                newnotes += [note_from_CSoundNote(n) for n in dict[tid][pid]]

        for n in newnotes:
            self._noteId[n['noteId']] = n

        #delete the old pages & tracks!
        togo = [n for n in self._data['notebin'] if (n['trackId'] in newtracks and n['pageId'] in newpages)  ]
        self.trackInterface.deleteNotes( 
                {   "page": [n['pageId'] for n in togo],
                    "track":[n['trackId'] for n in togo] ,
                    "note": [n['noteId'] for n in togo]},
                len(togo))
        for n in togo:
            del self._noteId[n['noteId']]

        self._data['notebin'] = \
                [n for n in self._data['notebin'] if not (n['trackId'] in newtracks and n['pageId'] in newpages)  ] \
                + newnotes

        self.addNotesToTrackInterface( newnotes )

        self.handleCloseGenerateWindow( None, None )
        #self.handleConfigureEvent( None, None )

    def generate( self, params ):
        self.recompose( generator1, params)

    def variate( self, params ):
        self.recompose( variate, params)
        
    #-----------------------------------
    # tune functions
    #-----------------------------------    
    
    def scrollTune( self, scroll ):
        adj = self.GUI["2tuneScrolledWindow"].get_hadjustment()
        adj.set_value( scroll )
    
    def displayPage( self, pageId, beats = -1 ):
        
        if beats == -1:
            for page in self._data["pages"]:
                if pageId == page["pageId"]: break
            beats = page["beats"]
            
        self.displayedPage = pageId
        self.displayedBeats = beats
        
        adj = self.GUI["2tuneScrolledWindow"].get_hadjustment()
        scroll = self.tuneInterface.displayPage( pageId, adj.get_value() )
        if scroll >= 0: adj.set_value(scroll)
                
        self.trackInterface.displayPage( pageId, beats )    
    
    def addPage( self, insert = -1, beats = -1 ):
    
        if insert == -1: insert = self.tuneInterface.getLastSelected() + 1
        if beats == -1: beats = self.displayedBeats
        
        pageId = self._pageIdBase
        self._pageIdBase += 1
        while pageId in [ x["pageId"] for x in self._data["pages"] ]:
            pageId = self._pageIdBase
            self._pageIdBase += 1
        
        newpage = { "pageId": pageId, "beats": beats }
        self._data["pages"].insert( insert, newpage )
        
        self.tuneInterface.clearSelection()
        self.tuneInterface.insertPage( pageId, insert )
        
        self.displayPage( pageId, beats )
    
    def duplicatePages( self, insert = -1, pageIds = -1 ):
        
        if insert == -1: insert = self.tuneInterface.getLastSelected() + 1
        if pageIds == -1: pageIds = self.tuneInterface.getSelectedIds()
        
        nextDisplay = -1
        nextBeats = -1
        newpages = []
        for id in pageIds:
            for page in self._data["pages"]:
                if id == page["pageId"]: break
            
            pageId = self._pageIdBase
            self._pageIdBase += 1
            while pageId in [ x["pageId"] for x in self._data["pages"] ]:
                pageId = self._pageIdBase
                self._pageIdBase += 1
            
            if self.displayedPage == id:
                nextDisplay = pageId
                nextBeats = page["beats"]
            
            newnotes = [ n.copy() for n in self._data["notebin"] if n["pageId"] == id ]
            for n in newnotes: n["pageId"] = pageId
            
            self._data["notebin"].extend( newnotes )
            self.addNotesToTrackInterface( newnotes )
            
            newpages.append( { "pageId": pageId, "beats": page["beats"] } )
            
        self.tuneInterface.insertPages( [ p["pageId"] for p in newpages ], insert, True, True )
       
        for page in newpages:
            self._data["pages"].insert( insert, page )
            insert += 1
        
        self.displayPage( nextDisplay, nextBeats )
        
    def removePages( self, pageIds = -1 ):
        
        if pageIds == -1: pageIds = self.tuneInterface.getSelectedIds()
        
        next = self.tuneInterface.getLastSelected() + 1
        if next == len(self._data["pages"]):
            next -= 2
            while next >= 0 and self._data["pages"][next]["pageId"] in pageIds:
                next -= 1
        
        if next == -1:
            self.addPage()
        else:
            self.tuneInterface.selectPage( self._data["pages"][next]["pageId"], True ) # exclusive select
            self.displayPage( self._data["pages"][next]["pageId"], self._data["pages"][next]["beats"] )
    
        self.tuneInterface.removePages( pageIds )
        self.tuneInterface.selectPage( self._data["pages"][next]["pageId"] )
    
        for id in pageIds:
            for page in self._data["pages"]:
                if id == page["pageId"]: break
    
            self._data["pages"].remove(page)
            
            notes = [ n for n in self._data["notebin"] if n["pageId"] == id ]
            self.removeNotesFromTrackInterface( notes )
            self._data["notebin"] = [ n for n in self._data["notebin"] if n["pageId"] != id ]
            
    def movePages( self, insert = -1, pageIds = -1 ):
        
        if pageIds == -1: pageIds = self.tuneInterface.getSelectedIds()
        if insert == -1: insert = self.tuneInterface.getLastSelected() + 1 - len(pageIds)
        
        for id in pageIds:
            remove = 0
            for page in self._data["pages"]:
        	    if id == page["pageId"]: break
        	    remove += 1
            
            self.tuneInterface.movePage( remove, insert )
            
            if remove == insert: 
                insert += 1
                continue
            elif remove < insert:
                if remove == insert-1: continue
                insert -= 1
	
            self._data["pages"].pop(remove)
            self._data["pages"].insert( insert, page )

            insert += 1

    #-----------------------------------
    # load and save functions
    #-----------------------------------
    def handleSave(self, widget, data):
        #gtk.main_quit()
        self.csnd.initialize(False)
        return

        chooser = gtk.FileChooserDialog(title=None,action=gtk.FILE_CHOOSER_ACTION_SAVE, buttons=(gtk.STOCK_CANCEL,gtk.RESPONSE_CANCEL,gtk.STOCK_SAVE,gtk.RESPONSE_OK))

        if chooser.run() == gtk.RESPONSE_OK:
            try: 
                print 'INFO: serialize to file %s' % chooser.get_filename()
                f = open( chooser.get_filename(), 'w')
                pickle.dump( self._data, f )
                f.close()
            except IOError: 
                print 'ERROR: failed to serialize to file %s' % chooser.get_filename()

        chooser.destroy()

    def handleLoad(self, widget, data):
        #gtk.main_quit()
        self.csnd.initialize(True)
        return
        chooser = gtk.FileChooserDialog(title=None,action=gtk.FILE_CHOOSER_ACTION_OPEN, buttons=(gtk.STOCK_CANCEL,gtk.RESPONSE_CANCEL,gtk.STOCK_OPEN,gtk.RESPONSE_OK))

        if chooser.run() == gtk.RESPONSE_OK:
            try: 
                print 'INFO: unserialize from file %s' % chooser.get_filename()
                f = open( chooser.get_filename(), 'r')
                self._data = pickle.load( f )
            except IOError: 
                print 'ERROR: failed to unserialize from file %s' % chooser.get_filename()

        chooser.destroy()
        print 'TODO: update misc. program state to new music'

    #-----------------------------------
    # Record functions
    #-----------------------------------
    def handleMicRecord( self, widget, data ):
        self.csnd.micRecording( data )
    def handleCloseMicRecordWindow( self, widget = None, data = None ):
        self.micRecordWindow.destroy()
        self.micRecordButton.set_active( False )

    #-----------------------------------
    # callback functions
    #-----------------------------------
    def onKeyPress(self,widget,event):
        
        ModKeys.keyPress( event.hardware_keycode )

        key = event.hardware_keycode 
        
        if key == 53 and ModKeys.ctrlDown: # q == 53
            self.destroy( self )

        if not self.kb_active:
            return
        if self.kb_record:
            self.kb_mono = False
        
        # If the key is already in the dictionnary, exit function (to avoir key repeats)
        if self.kb_keydict.has_key(key):
                return
        # Assign on which track the note will be created according to the number of keys pressed    
        track = len(self.kb_keydict)+10
        if self.kb_mono:
            track = 10
        # If the pressed key is in the keymap
        if KEY_MAP.has_key(key):
            # CsoundNote parameters
            onset = self.getCurrentTick()
            pitch = KEY_MAP[key]
            duration = -1
            instrument = self._data['track_inst'][0]
            # get instrument from top selected track if a track is selected
            if self.getSelectedtrackIds():
                instrument = self._data['track_inst'][min(self.getSelectedtrackIds())]
            
            if instrument == 'drum1kit':
                if GenerationConstants.DRUMPITCH.has_key( pitch ):
                    instrument = CSoundConstants.DRUM1INSTRUMENTS[ GenerationConstants.DRUMPITCH[ pitch ] ]
                else:
                    instrument = CSoundConstants.DRUM1INSTRUMENTS[ pitch ]
                pitch = 36
                duration = 100
            
            if CSoundConstants.INSTRUMENTS[instrument].csoundInstrumentID == 102:
                duration = 100
            
            # Create and play the note
            self.kb_keydict[key] = Note.note_new(onset = 0, 
                                            pitch = pitch, 
                                            amplitude = 1, 
                                            pan = 0.5, 
                                            duration = duration, 
                                            trackId = track, 
                                            fullDuration = False, 
                                            instrument = instrument, 
                                            instrumentFlag = instrument)
            Note.note_play(self.kb_keydict[key])
                
    def onKeyRelease(self,widget,event):

        ModKeys.keyRelease( event.hardware_keycode )

        if not self.kb_active:
            return
        key = event.hardware_keycode 
        
        if KEY_MAP.has_key(key):
            self.kb_keydict[key]['duration'] = 0
            self.kb_keydict[key]['amplitude'] = 0
            self.kb_keydict[key]['dirty'] = True
            Note.note_play(self.kb_keydict[key])
            self.kb_keydict[key]['duration'] = self.getCurrentTick() - self.kb_keydict[key]['onset']
            #print "onset",self.kb_keydict[key].onset
            #print "dur",self.kb_keydict[key].duration
            if self.kb_record and len( self.getSelectedtrackIds() ) != 0:
                self.kb_keydict[key]['amplitude'] = 1
                self.getTrackDictionary()[min(self.getSelectedtrackIds())][self.getCurrentpageIdCallback()].append(self.kb_keydict[key])
                print 'ERROR: keyboard release... callbacks?'
            del self.kb_keydict[key]

    def delete_event( self, widget, event, data = None ):
        return False

    def destroy( self, widget ):
        gtk.main_quit()
    
    def updateNumberOfBars( self, widget = None, data = None ):
        self.trackInterface.updateBeatCount( int(round( self.beatsPerPageAdjustment.value)) )
        
    def updateSelection( self ):
        print 'WARNING: wtf is this?'

    def updatePage( self ):
        TP.ProfileBegin( "updatePage" )

        if self.playingTune:
            self.tuneView.selectPage( self.currentpageId, False )
            self.pageBankView.selectPage(self.pageBankView.NO_PAGE,False)
        else:
            self.tuneView.deselectAll()
            self.tuneView.selectPage(self.tuneView.NO_PAGE,False)

        # temp        
        self.trackInterface.displayPage(0,int(round( self.beatsPerPageAdjustment.value)))

        self.handleConfigureEvent( None, None )

        print TP.ProfileEndAndPrint( "updatePage" )
        
        
    # handle resize (TODO: this could probably be done more efficiently)
    #def handleConfigureEvent( self, widget, event ):
    #    mainBoxRect = self.trackPagesBox.get_allocation()
        
        #self.tuneView.set_size_request( mainBoxRect.width, GUIConstants.PAGE_HEIGHT + 
        #                                                   self.tuneView.get_hscrollbar().get_allocation().height + 10 )
        #self.tuneView.show_all()
    
        #self.pageBankView.set_size_request( mainBoxRect.width, GUIConstants.PAGE_HEIGHT * GUIConstants.NUMBER_OF_PAGE_BANK_ROWS )
        #self.pageBankView.show_all()
        
        #mainViewRect = self.mainView.get_allocation()
        
        #self.trackInterface.set_size_request( mainViewRect.width, mainViewRect.height )
        
        #self.trackControlsBox.set_size_request( 100, mainViewRect.height )

    #-----------------------------------
    # access functions (not sure if this is the best way to go about doing this)
    #-----------------------------------
    def getVolume( self ):
        return round( self.volumeAdjustment.value, 0 )

    def getTempo( self ):
        return round( self.tempoAdjustment.value, 0 )

    def getBeatsPerPage( self ):
        return int(round( self.beatsPerPageAdjustment.value, 0 ))

    def getWindowTitle( self ):
        return "Tam-Tam [Volume %i, Tempo %i, Beats/Page %i]" % ( self.volumeAdjustment.value, self.getTempo(), self.getBeatsPerPage() )