Algo generators on properties

20 files changed, 460 insertions, 55 deletions

diff --git a/Edit/MainWindow.py b/Edit/MainWindow.py
index ffca721..bb85370 100644
--- a/Edit/MainWindow.py
+++ b/Edit/MainWindow.py
@@ -920,7 +920,7 @@ class MainWindow( SubActivity ):
                 if len(ids[t]):
                     notes[self.displayedPage][t] = [ self.noteDB.getNote( self.displayedPage, t, id ) for id in ids[t] ]
             
-            self.propertiesPanel.setContext("note", notes = notes )
+            self.propertiesPanel.setContext("note", self.generationPanel.scale, notes = notes )
             winLoc = self.parent.window.get_position()
             balloc = self.GUI["2contextBox"].get_allocation()
             walloc = self.GUI["9propertiesPopup"].get_allocation()
@@ -1059,7 +1059,7 @@ class MainWindow( SubActivity ):
 
     def trackProperties( self, widget ):
         if widget.get_active():
-            self.propertiesPanel.setContext( "track", self.tuneInterface.getSelectedIds(), [ i for i in range(Config.NUMBER_OF_TRACKS) if self.trackSelected[i] ] )
+            self.propertiesPanel.setContext( "track", self.generationPanel.scale, self.tuneInterface.getSelectedIds(), [ i for i in range(Config.NUMBER_OF_TRACKS) if self.trackSelected[i] ] )
             winLoc = self.parent.window.get_position()
             balloc = self.GUI["2contextBox"].get_allocation()
             walloc = self.GUI["9propertiesPopup"].get_allocation()
@@ -1155,7 +1155,7 @@ class MainWindow( SubActivity ):
 
     def pageProperties( self, widget ):
         if widget.get_active():
-            self.propertiesPanel.setContext( "page", self.tuneInterface.getSelectedIds() )
+            self.propertiesPanel.setContext( "page", self.generationPanel.scale, self.tuneInterface.getSelectedIds() )
             winLoc = self.parent.window.get_position()
             balloc = self.GUI["2contextBox"].get_allocation()
             walloc = self.GUI["9propertiesPopup"].get_allocation()
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  ) )
 
 
diff --git a/Generation/Drunk.py b/Generation/Drunk.py
index 4649aff..3d0823a 100755
--- a/Generation/Drunk.py
+++ b/Generation/Drunk.py
@@ -6,12 +6,15 @@
 import random
 
 class Drunk:
-    def __init__( self, minValue, maxValue ):
-        self.lastValue = random.randint( minValue, maxValue )
+    def __init__( self, minValue, maxValue, trackLength=None ):
+        self.minValue = min(minValue, maxValue)
+        self.maxValue = max(minValue, maxValue)
+        self.lastValue = random.randint( self.minValue, self.maxValue )
+
 
     def getNextValue( self, maxStepSize, maxValue ):
         if self.lastValue < 0 or self.lastValue > maxValue:
-            return random.randint( 0, maxValue )
+            return random.randint( self.minValue, maxValue )
 
         direction = self.getDirection( maxValue )
         stepSize = self.getStepSize( direction, abs(maxStepSize), maxValue )
@@ -23,10 +26,10 @@ class Drunk:
   
         self.lastValue += direction * random.randint( minStepSize, stepSize )
 
-        if self.lastValue < 0:
-            self.lastValue = 0
-        elif self.lastValue > 14:
-            self.lastValue = 14
+        if self.lastValue < self.minValue:
+            self.lastValue = self.minValue
+        elif self.lastValue > maxValue:  #instead of 14...
+            self.lastValue = maxValue
         else:
             self.lastValue = self.lastValue
 
@@ -47,9 +50,11 @@ class Drunk:
             return min( maxStepSize, maxValue - self.lastValue )
 
 class DroneAndJump( Drunk ):
-    def __init__( self, minValue, maxValue ):
-        Drunk.__init__( self, minValue, maxValue )
-        self.beforeLastValue = random.randint( minValue, maxValue )
+    def __init__( self, minValue, maxValue, trackLength=None ):
+        Drunk.__init__( self, minValue, maxValue, trackLength=None )
+        self.minValue = min(minValue, maxValue)
+        self.maxValue = max(minValue, maxValue)        
+        self.beforeLastValue = self.minValue #random.randint( self.minValue, self.maxValue )
         self.lastValue = self.beforeLastValue + 1
 
     def getNextValue( self, maxStepSize, maxValue ):
@@ -68,9 +73,11 @@ class DroneAndJump( Drunk ):
             return Drunk.getStepSize( self, direction, 0, maxValue )
 
 class Repeter( Drunk ):
-    def __init__( self, minValue, maxValue ):
-        Drunk.__init__( self, minValue, maxValue)
-        self.lastValue = random.randint( minValue, maxValue)
+    def __init__( self, minValue, maxValue, trackLength=None ):
+        Drunk.__init__( self, minValue, maxValue, trackLength=None)
+        self.minValue = min(minValue, maxValue)
+        self.maxValue = max(minValue, maxValue)
+        self.lastValue = random.randint( self.minValue, self.maxValue)
 
     def getNextValue( self, maxStepSize, maxValue ):
         self.lastValue = Drunk.getNextValue( self, abs(maxStepSize), maxValue )
@@ -83,8 +90,8 @@ class Repeter( Drunk ):
             return Drunk.getStepSize( self, direction, 0, maxValue )    
 
 class Loopseg( Drunk ):
-    def __init__( self, minValue, maxValue ):
-        Drunk.__init__( self, minValue, maxValue )
+    def __init__( self, minValue, maxValue, trackLength=None ):
+        Drunk.__init__( self, minValue, maxValue, trackLength=None )
         self.recordedValues = []
         self.recordState = 2
         self.recordPlayback = 0
@@ -123,3 +130,33 @@ class Loopseg( Drunk ):
     def loopAround( self ):
         self.lastValue = self.recordedValues[self.recordPlayback]
         self.recordPlayback += 1
+        
+class Line:
+    def __init__(self, minValue, maxValue, trackLength=20):
+        maxVal = max(minValue, maxValue)
+        if maxVal == minValue:
+            self.reverse = True
+            minVal = maxValue
+            self.lastValue = maxVal
+        else:
+            self.reverse = False
+            minVal = minValue
+            self.lastValue = minVal
+            
+        scale = float(maxVal - minVal)
+        if self.reverse:
+            self.inc = -scale/trackLength
+        else:
+            self.inc = scale/trackLength  
+                
+    def getNextValue(self, rand, maxValue):
+        self.val = self.lastValue + int(random.randint(0, rand)*random.choice([-0.5,0.5]))
+        if self.val < 0:
+            self.val = 0
+        elif self.val > maxValue:
+            self.val = maxValue
+        else:
+            self.val = self.val
+        self.lastValue = self.val+self.inc    
+        return self.val
+   
diff --git a/Generation/GenerationPitch.py b/Generation/GenerationPitch.py
index 99fceaa..b4391d5 100644
--- a/Generation/GenerationPitch.py
+++ b/Generation/GenerationPitch.py
@@ -6,8 +6,8 @@ from Generation.GenerationConstants import GenerationConstants
 
 class GenerationPitch:
     def __init__( self, pattern ):
-        MIN = 5
-        MAX = 10
+        MIN = 0
+        MAX = 14
         if pattern == 0:
             self.pitchMethod = Drunk.Drunk( MIN, MAX )
         elif pattern == 1:
diff --git a/Resources/Images/diceProp.png b/Resources/Images/diceProp.png
new file mode 100644
index 0000000..887a6fb
--- /dev/null
+++ b/Resources/Images/diceProp.png
diff --git a/Resources/Images/dicePropSel.png b/Resources/Images/dicePropSel.png
new file mode 100644
index 0000000..13c5779
--- /dev/null
+++ b/Resources/Images/dicePropSel.png
diff --git a/Resources/Images/propDroneJump.png b/Resources/Images/propDroneJump.png
new file mode 100644
index 0000000..9b60f2d
--- /dev/null
+++ b/Resources/Images/propDroneJump.png
diff --git a/Resources/Images/propDroneJumpDown.png b/Resources/Images/propDroneJumpDown.png
new file mode 100644
index 0000000..eba219d
--- /dev/null
+++ b/Resources/Images/propDroneJumpDown.png
diff --git a/Resources/Images/propDroneJumpOver.png b/Resources/Images/propDroneJumpOver.png
new file mode 100644
index 0000000..37c792b
--- /dev/null
+++ b/Resources/Images/propDroneJumpOver.png
diff --git a/Resources/Images/propDrunk.png b/Resources/Images/propDrunk.png
new file mode 100644
index 0000000..a9d6bc4
--- /dev/null
+++ b/Resources/Images/propDrunk.png
diff --git a/Resources/Images/propDrunkDown.png b/Resources/Images/propDrunkDown.png
new file mode 100644
index 0000000..8927429
--- /dev/null
+++ b/Resources/Images/propDrunkDown.png
diff --git a/Resources/Images/propDrunkOver.png b/Resources/Images/propDrunkOver.png
new file mode 100644
index 0000000..813c9db
--- /dev/null
+++ b/Resources/Images/propDrunkOver.png
diff --git a/Resources/Images/propLoopseg.png b/Resources/Images/propLoopseg.png
new file mode 100644
index 0000000..ce03e88
--- /dev/null
+++ b/Resources/Images/propLoopseg.png
diff --git a/Resources/Images/propLoopsegDown.png b/Resources/Images/propLoopsegDown.png
new file mode 100644
index 0000000..25b396b
--- /dev/null
+++ b/Resources/Images/propLoopsegDown.png
diff --git a/Resources/Images/propLoopsegOver.png b/Resources/Images/propLoopsegOver.png
new file mode 100644
index 0000000..03f9924
--- /dev/null
+++ b/Resources/Images/propLoopsegOver.png
diff --git a/Resources/Images/propRepeater.png b/Resources/Images/propRepeater.png
new file mode 100644
index 0000000..7c99d2f
--- /dev/null
+++ b/Resources/Images/propRepeater.png
diff --git a/Resources/Images/propRepeaterDown.png b/Resources/Images/propRepeaterDown.png
new file mode 100644
index 0000000..15dc374
--- /dev/null
+++ b/Resources/Images/propRepeaterDown.png
diff --git a/Resources/Images/propRepeaterOver.png b/Resources/Images/propRepeaterOver.png
new file mode 100644
index 0000000..2631ff2
--- /dev/null
+++ b/Resources/Images/propRepeaterOver.png
diff --git a/Resources/tooltips_en.py b/Resources/tooltips_en.py
index e22db53..4021fc6 100644
--- a/Resources/tooltips_en.py
+++ b/Resources/tooltips_en.py
@@ -75,6 +75,25 @@ class Tooltips:
         self.PROP['filterTypeHighButton'] = 'Highpass filter'
         self.PROP['filterTypeBandButton'] = 'Bandpass filter'
         self.PROP['cutoffSlider'] = 'Filter cutoff'
+        self.PROP['pitchGen'] = 'Open algorithmic generator'
+        self.PROP['volumeGen'] = 'Open algorithmic generator'
+        self.PROP['panGen'] = 'Open algorithmic generator'
+        self.PROP['reverbGen'] = 'Open algorithmic generator'
+        self.PROP['attackGen'] = 'Open algorithmic generator'
+        self.PROP['decayGen'] = 'Open algorithmic generator'
+        self.PROP['cutoffGen'] = 'Open algorithmic generator'
+        self.PROP['line'] = 'Line'
+        self.PROP['drunk'] = 'Drunk'
+        self.PROP['droneJump'] = 'Drone and jump'
+        self.PROP['repeater'] = 'Repeater'
+        self.PROP['loopseg'] = 'Loop segments'
+        self.PROP['minSlider'] = 'Minimum value'
+        self.PROP['maxSlider'] = 'Maximum value'
+        self.PROP['paraSlider'] = 'Specific parameter'
+        self.PROP['checkButton'] = 'Apply generator'
+        self.PROP['cancelButton'] = 'Cancel'
+    
+
 
     #miniTamTam
     VOL = 'Volume'
diff --git a/SynthLab/SynthLabParametersWindow.py b/SynthLab/SynthLabParametersWindow.py
index 30b3e53..4d7b8d3 100644
--- a/SynthLab/SynthLabParametersWindow.py
+++ b/SynthLab/SynthLabParametersWindow.py
@@ -295,7 +295,7 @@ class SynthLabParametersWindow( gtk.Window ):
             if i == active:
                 button.set_active(True)
             button.connect( "toggled", methodCallback, i )
-	    self.tooltips.set_tip(button, typesLabel[i])
+            self.tooltips.set_tip(button, typesLabel[i])
             box.pack_start( button, False, False, 5 )