Algo generators on properties

1 files changed, 383 insertions, 34 deletions

diff --git a/Edit/Properties.py b/Edit/Properties.py
index c23f32d..6a4e515 100644
--- a/Edit/Properties.py
+++ b/Edit/Properties.py
@@ -3,6 +3,9 @@ pygtk.require('2.0')
 import gtk
 from types import *
 from math import sqrt
+from random import *
+from Generation.Drunk import *
+from Generation.GenerationConstants import GenerationConstants
 from Util.ThemeWidgets import *
 from Util.NoteDB import PARAMETER
 import Config
@@ -18,11 +21,24 @@ class Properties( gtk.VBox ):
         self.context = "page"
         self.notes = {} # notes indexed by page and track
         self.setup = False # flag to block note updates durning setup
+        
+        self.line = Line(0, 100)
+        self.drunk = Drunk(0, 100)
+        self.droneAndJump = DroneAndJump(0, 100)
+        self.repeter = Repeter(0, 100)
+        self.loopseg = Loopseg(0, 100)
+        self.algoTypes = [self.line, self.drunk, self.droneAndJump, self.repeter, self.loopseg]
+        self.algorithm = self.algoTypes[0]
 
         self.filterType = 0
+        self.minValue = 0.
+        self.maxValue = 100.
+        self.paraValue = 20.
 
+        self.activeWidget = None
+            
         self.GUI = {}
-        self.parametersBox = RoundVBox(fillcolor=Config.INST_BCK_COLOR, bordercolor=Config.PANEL_BCK_COLOR)
+        self.parametersBox = RoundHBox(fillcolor=Config.INST_BCK_COLOR, bordercolor=Config.PANEL_BCK_COLOR)
         self.parametersBox.set_border_width(1)
         self.parametersBox.set_radius(10)
         self.pack_start(self.parametersBox)
@@ -34,6 +50,9 @@ class Properties( gtk.VBox ):
         pitchBox.set_radius(10)
         self.GUI['pitchUp'] = ImageButton( Config.IMAGE_ROOT+"arrowEditUp.png", Config.IMAGE_ROOT+"arrowEditUpDown.png", Config.IMAGE_ROOT+"arrowEditUpOver.png", backgroundFill = Config.PANEL_COLOR )
         self.GUI['pitchUp'].connect( "clicked", lambda w:self.stepPitch( 1 ) )
+        self.GUI['pitchGen'] = ImageToggleButton( Config.IMAGE_ROOT+"diceProp.png", Config.IMAGE_ROOT+"dicePropSel.png", Config.IMAGE_ROOT+"dicePropSel.png", backgroundFill = Config.PANEL_COLOR )
+        self.GUI['pitchGen'].connect( "clicked", self.openAlgoBox, 'pitch' )
+        pitchBox.pack_start( self.GUI['pitchGen'], False, False, 5 )
         pitchBox.pack_start( self.GUI['pitchUp'] )
         self.pitchIcon = gtk.Image()
         self.pitchIcon.set_from_file(Config.IMAGE_ROOT + 'propPitch2.png')
@@ -48,6 +67,9 @@ class Properties( gtk.VBox ):
         volumeBox.set_radius(10)
         self.GUI['volumeUp'] = ImageButton( Config.IMAGE_ROOT+"arrowEditUp.png", Config.IMAGE_ROOT+"arrowEditUpDown.png", Config.IMAGE_ROOT+"arrowEditUpOver.png", backgroundFill = Config.PANEL_COLOR )
         self.GUI['volumeUp'].connect( "clicked", lambda w:self.stepVolume( 0.1 ) )
+        self.GUI['volumeGen'] = ImageToggleButton( Config.IMAGE_ROOT+"diceProp.png", Config.IMAGE_ROOT+"dicePropSel.png", Config.IMAGE_ROOT+"dicePropSel.png", backgroundFill = Config.PANEL_COLOR )
+        self.GUI['volumeGen'].connect( "clicked", self.openAlgoBox, 'volume' )
+        volumeBox.pack_start( self.GUI['volumeGen'], False, False, 5 )
         volumeBox.pack_start( self.GUI['volumeUp'] )
         self.volumeIcon = gtk.Image()
         self.volumeIcon.set_from_file(Config.IMAGE_ROOT + 'volume3.png')
@@ -65,9 +87,12 @@ class Properties( gtk.VBox ):
         self.panAdjust.connect("value-changed", self.handlePan)
         self.GUI['panSlider'].set_snap( 0.1 )
         self.GUI['panSlider'].set_inverted(True)
-        self.GUI['panSlider'].set_size_request(50, 175)
+        self.GUI['panSlider'].set_size_request(50, 200)
         self.panLabel = gtk.Image()
         self.handlePan( self.panAdjust )
+        self.GUI['panGen'] = ImageToggleButton( Config.IMAGE_ROOT+"diceProp.png", Config.IMAGE_ROOT+"dicePropSel.png", Config.IMAGE_ROOT+"dicePropSel.png", backgroundFill = Config.PANEL_COLOR )
+        self.GUI['panGen'].connect( "clicked", self.openAlgoBox, 'pan' )
+        panBox.pack_start(self.GUI['panGen'], True, True, 5)
         panBox.pack_start(self.GUI['panSlider'], True, True, 5)
         panBox.pack_start(self.panLabel, False, padding=10)
         controlsBox.pack_start(panBox)
@@ -80,9 +105,12 @@ class Properties( gtk.VBox ):
         self.reverbAdjust.connect("value-changed", self.handleReverb)
         self.GUI['reverbSlider'].set_snap( 0.1 )
         self.GUI['reverbSlider'].set_inverted(True)
-        self.GUI['reverbSlider'].set_size_request(50, 175)
+        self.GUI['reverbSlider'].set_size_request(50, 200)
         self.reverbLabel = gtk.Image()
         self.handleReverb( self.reverbAdjust )
+        self.GUI['reverbGen'] = ImageToggleButton( Config.IMAGE_ROOT+"diceProp.png", Config.IMAGE_ROOT+"dicePropSel.png", Config.IMAGE_ROOT+"dicePropSel.png", backgroundFill = Config.PANEL_COLOR )
+        self.GUI['reverbGen'].connect( "clicked", self.openAlgoBox, 'reverb' )
+        reverbBox.pack_start(self.GUI['reverbGen'], True, True, 5)        
         reverbBox.pack_start(self.GUI['reverbSlider'], True, True, 5)
         reverbBox.pack_start(self.reverbLabel, False, padding=10)
         controlsBox.pack_start(reverbBox)
@@ -95,9 +123,12 @@ class Properties( gtk.VBox ):
         self.attackAdjust.connect("value-changed", self.handleAttack)
         self.GUI['attackSlider'].set_snap( 0.01 )
         self.GUI['attackSlider'].set_inverted(True)
-        self.GUI['attackSlider'].set_size_request(50, 175)
+        self.GUI['attackSlider'].set_size_request(50, 200)
         self.attackLabel = gtk.Image()
         self.handleAttack( self.attackAdjust )
+        self.GUI['attackGen'] = ImageToggleButton( Config.IMAGE_ROOT+"diceProp.png", Config.IMAGE_ROOT+"dicePropSel.png", Config.IMAGE_ROOT+"dicePropSel.png", backgroundFill = Config.PANEL_COLOR )
+        self.GUI['attackGen'].connect( "clicked", self.openAlgoBox, 'attack' )
+        attackBox.pack_start(self.GUI['attackGen'], True, True, 5)        
         attackBox.pack_start(self.GUI['attackSlider'], True, True, 5)
         attackBox.pack_start(self.attackLabel, False, padding=10)
         controlsBox.pack_start(attackBox)
@@ -110,9 +141,12 @@ class Properties( gtk.VBox ):
         self.decayAdjust.connect("value-changed", self.handleDecay)
         self.GUI['decaySlider'].set_snap( 0.01 )
         self.GUI['decaySlider'].set_inverted(True)
-        self.GUI['decaySlider'].set_size_request(50, 175)
+        self.GUI['decaySlider'].set_size_request(50, 200)
         self.decayLabel = gtk.Image()
         self.handleDecay( self.decayAdjust )
+        self.GUI['decayGen'] = ImageToggleButton( Config.IMAGE_ROOT+"diceProp.png", Config.IMAGE_ROOT+"dicePropSel.png", Config.IMAGE_ROOT+"dicePropSel.png", backgroundFill = Config.PANEL_COLOR )
+        self.GUI['decayGen'].connect( "clicked", self.openAlgoBox, 'decay' )
+        decayBox.pack_start(self.GUI['decayGen'], True, True, 5)        
         decayBox.pack_start(self.GUI['decaySlider'], True, True, 5)
         decayBox.pack_start(self.decayLabel, False, padding=10)
         controlsBox.pack_start(decayBox)
@@ -141,7 +175,10 @@ class Properties( gtk.VBox ):
         self.GUI['cutoffSlider'].set_snap(100)
         self.cutoffAdjust.connect("value-changed", self.handleFilter)
         self.GUI['cutoffSlider'].set_inverted(True)
-        self.GUI['cutoffSlider'].set_size_request(50, 175)
+        self.GUI['cutoffSlider'].set_size_request(50, 200)
+        self.GUI['cutoffGen'] = ImageToggleButton( Config.IMAGE_ROOT+"diceProp.png", Config.IMAGE_ROOT+"dicePropSel.png", Config.IMAGE_ROOT+"dicePropSel.png", backgroundFill = Config.PANEL_COLOR )
+        self.GUI['cutoffGen'].connect( "clicked", self.openAlgoBox, 'cutoff' )
+        self.filterSliderBox.pack_start(self.GUI['cutoffGen'], True, True, 5)        
         self.filterSliderBox.pack_start(self.GUI['cutoffSlider'], True, True, 5)
         self.filterLabel = gtk.Image()
         self.filterLabel.set_from_file(Config.IMAGE_ROOT + 'propFilter1.png')
@@ -150,19 +187,151 @@ class Properties( gtk.VBox ):
         filterBox.pack_start(self.filterSliderBox)
 
         controlsBox.pack_start(filterBox)
-        self.parametersBox.pack_start(controlsBox)
+        
+        self.algoBox = RoundVBox(fillcolor=Config.PANEL_COLOR, bordercolor=Config.INST_BCK_COLOR)
+        self.algoBox.set_border_width(3)
+        self.algoBox.set_radius(10)
+        #self.algoBox = gtk.VBox()
+        
+        algoUpperBox = gtk.HBox()
+        
+        algoRadioButtonBox = gtk.VBox()
+        algoRadioButtonBox.set_size_request(100, 150)
+        #algoRadioButtonBox = RoundHBox(fillcolor=Config.PANEL_COLOR, bordercolor=Config.INST_BCK_COLOR)
+        #algoRadioButtonBox.set_border_width(3)
+        #algoRadioButtonBox.set_radius(10)
+
+        self.GUI['line'] = ImageRadioButton( None, Config.IMAGE_ROOT + 'propDrunk.png', Config.IMAGE_ROOT + 'propDrunkDown.png', Config.IMAGE_ROOT + 'propDrunkOver.png' )
+        self.GUI['line'].connect( "toggled", self.handleAlgo, 0 )
+        algoRadioButtonBox.pack_start( self.GUI['line'], False, False, 1 )
+        self.GUI['drunk'] = ImageRadioButton( self.GUI['line'], Config.IMAGE_ROOT + 'propDrunk.png', Config.IMAGE_ROOT + 'propDrunkDown.png', Config.IMAGE_ROOT + 'propDrunkOver.png' )
+        self.GUI['drunk'].connect( "toggled", self.handleAlgo, 1 )
+        algoRadioButtonBox.pack_start( self.GUI['drunk'], False, False, 1 )
+        self.GUI['droneJump'] = ImageRadioButton( self.GUI['line'], Config.IMAGE_ROOT + 'propDroneJump.png', Config.IMAGE_ROOT + 'propDroneJumpDown.png', Config.IMAGE_ROOT + 'propDroneJumpOver.png' )
+        self.GUI['droneJump'].connect( "toggled", self.handleAlgo, 2 )
+        algoRadioButtonBox.pack_start( self.GUI['droneJump'], False, False, 1 )
+        self.GUI['repeater'] = ImageRadioButton( self.GUI['line'], Config.IMAGE_ROOT + 'propRepeater.png', Config.IMAGE_ROOT + 'propRepeaterDown.png', Config.IMAGE_ROOT + 'propRepeaterOver.png' )
+        self.GUI['repeater'].connect( "toggled", self.handleAlgo, 3 )
+        algoRadioButtonBox.pack_start( self.GUI['repeater'], False, False, 1 )
+        self.GUI['loopseg'] = ImageRadioButton( self.GUI['line'], Config.IMAGE_ROOT + 'propLoopseg.png', Config.IMAGE_ROOT + 'propLoopsegDown.png', Config.IMAGE_ROOT + 'propLoopsegOver.png' )
+        self.GUI['loopseg'].connect( "toggled", self.handleAlgo, 4 )
+        algoRadioButtonBox.pack_start( self.GUI['loopseg'], False, False, 1 )
+        
+        algoUpperBox.pack_start(algoRadioButtonBox)
+        
+        algoSlidersBox = gtk.HBox()
+        algoSlidersBox.set_size_request(150, 320)
+        #algoSlidersBox = RoundHBox(fillcolor=Config.PANEL_COLOR, bordercolor=Config.INST_BCK_COLOR)
+        #algoSlidersBox.set_border_width(3)
+        #algoSlidersBox.set_radius(10)        
+        minBox = gtk.VBox()
+        self.minAdjust = gtk.Adjustment(0, 0, 100, 1, 1, 0)
+        self.GUI['minSlider'] = ImageVScale( Config.TAM_TAM_ROOT + "/Resources/Images/sliderEditVolume.png", self.minAdjust, 7 )
+        self.GUI['minSlider'].set_snap(1)
+        self.minAdjust.connect("value-changed", self.handleMin)
+        self.GUI['minSlider'].set_inverted(True)
+        self.GUI['minSlider'].set_size_request(50, 200)
+        minBox.pack_start(self.GUI['minSlider'], True, True, 5)     
+        algoSlidersBox.pack_start(minBox)
+        
+        maxBox = gtk.VBox()
+        self.maxAdjust = gtk.Adjustment(100, 0, 100, 1, 1, 0)
+        self.GUI['maxSlider'] = ImageVScale( Config.TAM_TAM_ROOT + "/Resources/Images/sliderEditVolume.png", self.maxAdjust, 7 )
+        self.GUI['maxSlider'].set_snap(1)
+        self.maxAdjust.connect("value-changed", self.handleMax)
+        self.GUI['maxSlider'].set_inverted(True)
+        self.GUI['maxSlider'].set_size_request(50, 200)
+        maxBox.pack_start(self.GUI['maxSlider'], True, True, 5)     
+        algoSlidersBox.pack_start(maxBox)
+        
+        paraBox = gtk.VBox()
+        self.paraAdjust = gtk.Adjustment(20, 0, 100, 1, 1, 0)
+        self.GUI['paraSlider'] = ImageVScale( Config.TAM_TAM_ROOT + "/Resources/Images/sliderEditVolume.png", self.paraAdjust, 7 )
+        self.GUI['paraSlider'].set_snap(1)
+        self.paraAdjust.connect("value-changed", self.handlePara)
+        self.GUI['paraSlider'].set_inverted(True)
+        self.GUI['paraSlider'].set_size_request(50, 200)
+        paraBox.pack_start(self.GUI['paraSlider'], True, True, 5)     
+        algoSlidersBox.pack_start(paraBox)         
+        
+        algoUpperBox.pack_start(algoSlidersBox)
+        
+        self.algoBox.pack_start(algoUpperBox)
+        
+        #transButtonBox = RoundHBox(fillcolor=Config.PANEL_COLOR, bordercolor=Config.INST_BCK_COLOR)
+        #transButtonBox.set_border_width(3)
+        #transButtonBox.set_radius(10)
+        transButtonBox = gtk.HBox()
+        transButtonBox.set_size_request(150, 50)
+        
+        # create cancel/check button
+        self.GUI["checkButton"] = ImageButton(Config.IMAGE_ROOT + 'check.png', backgroundFill=Config.PANEL_COLOR )
+        self.GUI["checkButton"].connect("clicked", self.apply)
+ 
+        self.GUI["cancelButton"] = ImageButton(Config.IMAGE_ROOT + 'closeA.png', backgroundFill=Config.PANEL_COLOR )
+        self.GUI["cancelButton"].connect("clicked", self.cancel)
+        
+        transButtonBox.pack_end(self.GUI["checkButton"], False, False, 10)
+        transButtonBox.pack_end(self.GUI["cancelButton"], False, False)
+        self.algoBox.pack_start(transButtonBox)
+        
+        self.parametersBox.pack_start(controlsBox)        
+        self.parametersBox.pack_start(self.algoBox)
 
         # set tooltips
         for key in self.GUI:
             if Tooltips.PROP.has_key(key):
                 self.tooltips.set_tip(self.GUI[key],Tooltips.PROP[key])
+        self.tooltips.set_tip(self.GUI['paraSlider'], 'Random')
+                
 
         self.show_all()
-    
-    def setContext( self, context, pageIds = None, trackIds = None, notes = {} ):
+
+    def openAlgoBox( self, widget, data=None ):
+        if widget.get_active() == True:
+            self.property = data
+            if self.activeWidget:
+                self.activeWidget.set_active(False)
+            self.GUI['line'].show()
+            self.GUI['drunk'].show()
+            self.GUI['droneJump'].show()
+            self.GUI['repeater'].show()
+            self.GUI['loopseg'].show()
+            self.GUI['minSlider'].show()
+            self.GUI['maxSlider'].show()
+            self.GUI['paraSlider'].show()
+            self.GUI['checkButton'].show()
+            self.GUI['cancelButton'].show()
+            self.activeWidget = widget
+        else:
+            self.property = None
+            self.GUI['line'].hide()
+            self.GUI['drunk'].hide()
+            self.GUI['droneJump'].hide()
+            self.GUI['repeater'].hide()
+            self.GUI['loopseg'].hide()
+            self.GUI['minSlider'].hide()
+            self.GUI['maxSlider'].hide()
+            self.GUI['paraSlider'].hide()
+            self.GUI['checkButton'].hide()
+            self.GUI['cancelButton'].hide()
+            self.activeWidget = None
+            
+    def setContext( self, context, scale, pageIds = None, trackIds = None, notes = {} ):
         self.context = context
-        self.notes = {} 
+        self.scale = GenerationConstants.SCALES[scale]
+        self.notes = {}
+        self.pageIds = pageIds
+        self.trackIds = trackIds
+        
+        try:
+            self.activeWidget.set_active(False)
+            self.activeWidget = None
+        except:
+            self.activeWidget = None
+            
         if context == "page":
+            self.trackIds = [0,1,2,3,4]
             for p in pageIds:
                 self.notes[p] = {}
                 for t in range(Config.NUMBER_OF_TRACKS):
@@ -174,6 +343,8 @@ class Properties( gtk.VBox ):
                     self.notes[p][t] = self.noteDB.getNotesByTrack( p, t )
         else:
             self.notes = notes
+            self.pageIds = self.notes.keys()
+            self.trackIds = self.notes[self.pageIds[0]].keys()
 
         for p in self.notes: 
             for t in self.notes[p]:
@@ -191,6 +362,7 @@ class Properties( gtk.VBox ):
                         self.GUI['filterTypeBandButton'].set_active(False)
                         self.filterLabel.hide()
                         self.GUI['cutoffSlider'].hide()
+                        self.GUI['cutoffGen'].hide()        
                     else:
                         if n.cs.filterType == 1:
                             self.GUI['filterTypeLowButton'].set_active(True)
@@ -200,8 +372,19 @@ class Properties( gtk.VBox ):
                             self.GUI['filterTypeBandButton'].set_active(True)
                         self.filterLabel.show()
                         self.GUI['cutoffSlider'].show()
+                        self.GUI['cutoffGen'].show()
                     self.filterType = n.cs.filterType
                     self.cutoffAdjust.set_value( n.cs.filterCutoff )
+                    self.GUI['line'].hide()
+                    self.GUI['drunk'].hide()
+                    self.GUI['droneJump'].hide()
+                    self.GUI['repeater'].hide()
+                    self.GUI['loopseg'].hide()
+                    self.GUI['minSlider'].hide()
+                    self.GUI['maxSlider'].hide()
+                    self.GUI['paraSlider'].hide()
+                    self.GUI['checkButton'].hide()
+                    self.GUI['cancelButton'].hide()
                     self.setup = False
                     return
 
@@ -232,11 +415,41 @@ class Properties( gtk.VBox ):
                     stream += [ p, t, PARAMETER.PITCH, len(substream)//2 ] + substream
         if len(stream):
             self.noteDB.updateNotes( stream + [-1] )
-                    
+
+    def algoPitch( self, list, algorithm ):
+        maxValue = max(list[0], list[1])
+        scaleLength = len(self.scale)-1
+        stream = []
+        for t in range(len(self.trackIds)):
+            trackLength = 0
+            for p in range(len(self.pageIds)):
+                trackLength += len(self.notes[self.pageIds[p]][self.trackIds[t]])
+            algorithm.__init__(list[0], list[1], trackLength)
+            for p in range(len(self.pageIds)):                
+                substream = []
+                if self.trackIds[t] != Config.NUMBER_OF_TRACKS-1:
+                    for n in self.notes[self.pageIds[p]][self.trackIds[t]]:
+                        val = algorithm.getNextValue(list[2], maxValue)
+                        substream += [ n.id, self.scale[int(val*0.01*scaleLength)]+36 ]
+                    if len(substream):
+                        stream += [ self.pageIds[p], self.trackIds[t], PARAMETER.PITCH, len(substream)//2 ] + substream    
+                else:
+                    for n in self.notes[self.pageIds[p]][self.trackIds[t]]:
+                        val = algorithm.getNextValue(list[2], maxValue)
+                        val = int((val*0.12)*2+24)
+                        if val in GenerationConstants.DRUMPITCH.keys():
+                            val = GenerationConstants.DRUMPITCH[val]
+                        print val    
+                        substream += [ n.id, val ]
+                    if len(substream):
+                        stream += [ self.pageIds[p], self.trackIds[t], PARAMETER.PITCH, len(substream)//2 ] + substream    
+        if len(stream):
+            self.noteDB.updateNotes( stream + [-1] )
+            
     def stepVolume( self, step ):
         stream = []
         for p in self.notes:
-            for t in self.notes[p]:
+            for t in self.notes[p]:                  
                 substream = []
                 if step > 0:
                     for n in self.notes[p][t]:
@@ -250,6 +463,24 @@ class Properties( gtk.VBox ):
                     stream += [ p, t, PARAMETER.AMPLITUDE, len(substream)//2 ] + substream
         if len(stream):
             self.noteDB.updateNotes( stream + [-1] )
+            
+    def algoVolume( self, list, algorithm ):
+        maxValue = max(list[0], list[1])
+        stream = []
+        for t in range(len(self.trackIds)):
+            trackLength = 0
+            for p in range(len(self.pageIds)):
+                trackLength += len(self.notes[self.pageIds[p]][self.trackIds[t]])
+            algorithm.__init__(list[0], list[1], trackLength)
+            for p in range(len(self.pageIds)):                
+                substream = []
+                for n in self.notes[self.pageIds[p]][self.trackIds[t]]:
+                    val = algorithm.getNextValue(list[2], maxValue)
+                    substream += [ n.id, min( Config.MAXIMUM_AMPLITUDE, val*0.01 ) ]
+                if len(substream):
+                    stream += [ self.pageIds[p], self.trackIds[t], PARAMETER.AMPLITUDE, len(substream)//2 ] + substream    
+        if len(stream):
+            self.noteDB.updateNotes( stream + [-1] )            
          
     def handlePan( self, adjust ):
         img = min( 4, int(adjust.value * 5) )
@@ -265,6 +496,24 @@ class Properties( gtk.VBox ):
             if len(stream):
                 self.noteDB.updateNotes( stream + [-1] )
 
+    def algoPan( self, list, algorithm ):
+        maxValue = max(list[0], list[1])
+        stream = []
+        for t in range(len(self.trackIds)):
+            trackLength = 0
+            for p in range(len(self.pageIds)):
+                trackLength += len(self.notes[self.pageIds[p]][self.trackIds[t]])
+            algorithm.__init__(list[0], list[1], trackLength)
+            for p in range(len(self.pageIds)):                
+                substream = []
+                for n in self.notes[self.pageIds[p]][self.trackIds[t]]:
+                    val = algorithm.getNextValue(list[2], maxValue)
+                    substream += [ n.id, val*0.01 ]
+                if len(substream):
+                    stream += [ self.pageIds[p], self.trackIds[t], PARAMETER.PAN, len(substream)//2 ] + substream    
+        if len(stream):
+            self.noteDB.updateNotes( stream + [-1] )
+            
     def handleReverb( self, adjust ):
         img = min( 5, int(adjust.value * 6) )
         self.reverbLabel.set_from_file(Config.IMAGE_ROOT + 'propReverb' + str(img) + '.png')
@@ -278,10 +527,28 @@ class Properties( gtk.VBox ):
                             stream += [ n.id, adjust.value ]
             if len(stream):
                 self.noteDB.updateNotes( stream + [-1] )
+                
+    def algoReverb( self, list, algorithm ):
+        maxValue = max(list[0], list[1])
+        stream = []
+        for t in range(len(self.trackIds)):
+            trackLength = 0
+            for p in range(len(self.pageIds)):
+                trackLength += len(self.notes[self.pageIds[p]][self.trackIds[t]])
+            algorithm.__init__(list[0], list[1], trackLength)
+            for p in range(len(self.pageIds)):                
+                substream = []
+                for n in self.notes[self.pageIds[p]][self.trackIds[t]]:
+                    val = algorithm.getNextValue(list[2], maxValue)
+                    substream += [ n.id, val*0.02 ]
+                if len(substream):
+                    stream += [ self.pageIds[p], self.trackIds[t], PARAMETER.REVERB, len(substream)//2 ] + substream    
+        if len(stream):
+            self.noteDB.updateNotes( stream + [-1] )                
 
     def handleAttack( self, adjust ):
-        val = adjust.value*adjust.value
-        img = min( 4, int(val * 5) )
+        val = adjust.value #*adjust.value
+        img = min( 4, int(val * 4) )
         self.attackLabel.set_from_file(Config.IMAGE_ROOT + 'propAtt' + str(img) + '.png')
         if not self.setup:
             stream = []
@@ -294,9 +561,27 @@ class Properties( gtk.VBox ):
             if len(stream):
                 self.noteDB.updateNotes( stream + [-1] )
 
+    def algoAttack( self, list, algorithm ):
+        maxValue = max(list[0], list[1])
+        stream = []
+        for t in range(len(self.trackIds)):
+            trackLength = 0
+            for p in range(len(self.pageIds)):
+                trackLength += len(self.notes[self.pageIds[p]][self.trackIds[t]])
+            algorithm.__init__(list[0], list[1], trackLength)
+            for p in range(len(self.pageIds)):                
+                substream = []
+                for n in self.notes[self.pageIds[p]][self.trackIds[t]]:
+                    val = algorithm.getNextValue(list[2], maxValue)
+                    substream += [ n.id, val*0.01 ]
+                if len(substream):
+                    stream += [ self.pageIds[p], self.trackIds[t], PARAMETER.ATTACK, len(substream)//2 ] + substream    
+        if len(stream):
+            self.noteDB.updateNotes( stream + [-1] )
+            
     def handleDecay( self, adjust ):
-        val = adjust.value*adjust.value
-        img = min( 4, int(val * 5) )
+        val = adjust.value #*adjust.value
+        img = min( 4, int(val * 4) )
         self.decayLabel.set_from_file(Config.IMAGE_ROOT + 'propDec' + str(img) + '.png')
         if not self.setup:
             stream = []
@@ -309,12 +594,31 @@ class Properties( gtk.VBox ):
             if len(stream):
                 self.noteDB.updateNotes( stream + [-1] )
 
+    def algoDecay( self, list, algorithm ):
+        maxValue = max(list[0], list[1])
+        stream = []
+        for t in range(len(self.trackIds)):
+            trackLength = 0
+            for p in range(len(self.pageIds)):
+                trackLength += len(self.notes[self.pageIds[p]][self.trackIds[t]])
+            algorithm.__init__(list[0], list[1], trackLength)
+            for p in range(len(self.pageIds)):                
+                substream = []
+                for n in self.notes[self.pageIds[p]][self.trackIds[t]]:
+                    val = algorithm.getNextValue(list[2], maxValue)
+                    substream += [ n.id, val*0.01 ]
+                if len(substream):
+                    stream += [ self.pageIds[p], self.trackIds[t], PARAMETER.DECAY, len(substream)//2 ] + substream    
+        if len(stream):
+            self.noteDB.updateNotes( stream + [-1] )
+            
     def handleFilterType( self, widget, type ):
 
         if widget.get_active():
             if self.filterType == 0:
                 self.filterLabel.show()
                 self.GUI['cutoffSlider'].show()
+                self.GUI['cutoffGen'].show()
 
             self.filterType = type
             self.updateFilterLabel()
@@ -349,6 +653,7 @@ class Properties( gtk.VBox ):
             self.filterType = 0
             self.filterLabel.hide()
             self.GUI['cutoffSlider'].hide()
+            self.GUI['cutoffGen'].hide()
             if not self.setup:
                 typestream = []
                 for p in self.notes:
@@ -371,34 +676,78 @@ class Properties( gtk.VBox ):
         if len(stream):
             self.noteDB.updateNotes( stream + [-1] )
 
+    def algoCutoff( self, list, algorithm ):
+        maxValue = max(list[0], list[1])
+        stream = []
+        for t in range(len(self.trackIds)):
+            trackLength = 0
+            for p in range(len(self.pageIds)):
+                trackLength += len(self.notes[self.pageIds[p]][self.trackIds[t]])
+            algorithm.__init__(list[0], list[1], trackLength)
+            for p in range(len(self.pageIds)):                
+                substream = []
+                for n in self.notes[self.pageIds[p]][self.trackIds[t]]:
+                    val = algorithm.getNextValue(list[2], maxValue)
+                    substream += [ n.id, val*70+100 ]
+                if len(substream):
+                    stream += [ self.pageIds[p], self.trackIds[t], PARAMETER.FILTERCUTOFF, len(substream)//2 ] + substream    
+        if len(stream):
+            self.noteDB.updateNotes( stream + [-1] )
 
         self.updateFilterLabel()
-
+        
+    def handleAlgo( self, widget, data ):
+        self.algorithm = self.algoTypes[data]
+        paraTooltips = ['Random', 'Maximum step', 'Maximum step', 'Maximum step', 'Maximum step']
+        self.tooltips.set_tip(self.GUI['paraSlider'], paraTooltips[data])
+        
+    def handleMin( self, adjust ):
+        self.minValue = adjust.value
+
+    def handleMax( self, adjust ):
+        self.maxValue = adjust.value
+    
+    def handlePara( self, adjust ):
+        self.paraValue = adjust.value
+    
+    def apply( self, widget, data=None ):
+        valList = [self.minValue, self.maxValue, self.paraValue]
+        if self.property == 'pitch':
+            self.algoPitch(valList, self.algorithm)
+        elif self.property == 'volume':
+            self.algoVolume(valList, self.algorithm)
+        elif self.property == 'pan':
+            self.algoPan(valList, self.algorithm)
+        elif self.property == 'reverb':
+            self.algoReverb(valList, self.algorithm)
+        elif self.property == 'attack':
+            self.algoAttack(valList, self.algorithm)
+        elif self.property == 'decay':
+            self.algoDecay(valList, self.algorithm)
+        elif self.property == 'cutoff':
+            self.algoCutoff(valList, self.algorithm)            
+        self.cancel(self.activeWidget)
+    
+    def cancel( self, widget, data=None ):
+        self.GUI['line'].hide()
+        self.GUI['drunk'].hide()
+        self.GUI['droneJump'].hide()
+        self.GUI['repeater'].hide()
+        self.GUI['loopseg'].hide()
+        self.GUI['minSlider'].hide()
+        self.GUI['maxSlider'].hide()
+        self.GUI['paraSlider'].hide()
+        self.GUI['checkButton'].hide()
+        self.GUI['cancelButton'].hide()
+        self.activeWidget.set_active(False)
    
     def updateFilterLabel( self ):
         val = (self.cutoffAdjust.value-self.cutoffAdjust.lower)/(self.cutoffAdjust.upper-self.cutoffAdjust.lower)
         img = min( 5, int(val * 6) )
         self.filterLabel.set_from_file(Config.IMAGE_ROOT + 'propFilter%d.%d' % (self.filterType, img) + '.png')
 
-    def cancel( self, widget, data=None ):
-        self.window.destroy()
-
-    def applyParametersChange( self, data=None ):
-        #self.getNoteParameters()
-        self.window.destroy()
-
-    def filterCallback( self, widget, data=None):
-        if widget.get_active():
-            self.filterType = data
 
-    def tiedCallback( self, widget, data=None ):
-        self.tied = widget.get_active()
 
-    def overlapCallback( self, widget, data=None ):
-        self.overlap = widget.get_active()
 
-    def handleCutoffScale( self, widget, data=None ):
-        self.filterCutoff = int( pow( self.filterCutoffAdjust.value, 2) * 19980 + 20 )
-        self.filterCutoffLabel.set_text( str( self.filterCutoff  ) )