Properties's algos connected

1 files changed, 189 insertions, 13 deletions

diff --git a/Edit/EditToolbars.py b/Edit/EditToolbars.py
index 3418512..0c2c137 100644
--- a/Edit/EditToolbars.py
+++ b/Edit/EditToolbars.py
@@ -359,7 +359,7 @@ class generationPalette(Palette):
         self.slidersBox = gtk.HBox()
         self.scaleModeBox = gtk.VBox()
         self.decisionBox = gtk.HBox()
-        
+
         self.XYSlider1MainBox = gtk.VBox()
         self.XYSlider1TopLabel = gtk.Label(_('Rythm'))
         self.XSlider1BottomLabelBox = gtk.HBox()
@@ -533,7 +533,7 @@ class generationPalette(Palette):
         self.colors = { "Beat_Line":   colormap.alloc_color( "#959595", True, True ),
                         "Note_Border": colormap.alloc_color( Config.BG_COLOR, True, True ),
                         "Note_Fill":   colormap.alloc_color( Config.FG_COLOR, True, True ) }
-        
+
         self.scaleBox.set_active(0)
         self.modeBox.set_active(0)
 
@@ -598,7 +598,7 @@ class generationPalette(Palette):
         self.edit.generate(self.getGenerationParameters())
         self.popdown(True)
 
-    ############ generate a preview melody ##############s        
+    ############ generate a preview melody ##############s
     def previewGenerator(self, parameters):
         makeRythm = GenerationRythm()
         makePitch = GenerationPitch(parameters.pattern)
@@ -652,7 +652,7 @@ class generationPalette(Palette):
 
     def drawPreview( self, force = False ):
         if not self.predrawBuffer:
-            return # not alloc'ed yet 
+            return # not alloc'ed yet
 
         if self.drawingPreview and not force:
             return # should never happen
@@ -765,9 +765,20 @@ class propertiesPalette(Palette):
         self.geneTypes = [_('Line'),_('Drunk'),_('Drone and Jump'),_('Repeater'),_('Loop Segments')]
         self.colors = [_('Purple'), _('Green'), _('Blue'), _('Yellow')]
         self.currentFilterType = self.filterTypes[0]
-        self.currentGeneType = self.geneTypes[0]
+
+        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.geneMinimum = 0
+        self.geneMaximum = 100
+        self.geneRandom = 20
 
         self.setup = False
+        self.hidden = False
         self.geneCheckButtonDic = {}
 
         self.pageIds = []
@@ -923,6 +934,7 @@ class propertiesPalette(Palette):
         self.minimumBox = gtk.HBox()
         self.minimumLabel = gtk.Label(_('Minimum: '))
         self.minimumSliderAdj = gtk.Adjustment(0, 0, 100, 1, 1, 0)
+        self.minimumSliderAdj.connect('value-changed', self.handleMinimum)
         self.minimumSlider =  gtk.HScale(adjustment = self.minimumSliderAdj)
         self.minimumSlider.set_size_request(200,-1)
         self.minimumSlider.set_value_pos(gtk.POS_RIGHT)
@@ -932,6 +944,7 @@ class propertiesPalette(Palette):
         self.maximumBox = gtk.HBox()
         self.maximumLabel = gtk.Label(_('Maximum: '))
         self.maximumSliderAdj = gtk.Adjustment(100, 0, 100, 1, 1, 0)
+        self.maximumSliderAdj.connect('value-changed', self.handleMaximum)
         self.maximumSlider =  gtk.HScale(adjustment = self.maximumSliderAdj)
         self.maximumSlider.set_size_request(200,-1)
         self.maximumSlider.set_value_pos(gtk.POS_RIGHT)
@@ -941,6 +954,7 @@ class propertiesPalette(Palette):
         self.randomBox = gtk.HBox()
         self.randomLabel = gtk.Label(_('Random: '))
         self.randomSliderAdj = gtk.Adjustment(20, 0, 100, 1, 1, 0)
+        self.randomSliderAdj.connect('value-changed', self.handleRandom)
         self.randomSlider =  gtk.HScale(adjustment = self.randomSliderAdj)
         self.randomSlider.set_size_request(200,-1)
         self.randomSlider.set_value_pos(gtk.POS_RIGHT)
@@ -949,7 +963,9 @@ class propertiesPalette(Palette):
 
         self.decisionBox = gtk.HBox()
         self.acceptButton = ImageButton(Config.TAM_TAM_ROOT + '/icons/accept.svg')
+        self.acceptButton.connect('clicked', self.acceptGeneration)
         self.cancelButton = ImageButton(Config.TAM_TAM_ROOT + '/icons/cancel.svg')
+        self.cancelButton.connect('clicked', self.resetGeneCheckButton)
         self.decisionBox.pack_start(self.cancelButton, False, False, padding = 5)
         self.decisionBox.pack_start(self.acceptButton, False, False, padding = 5)
 
@@ -992,7 +1008,7 @@ class propertiesPalette(Palette):
             self.setContext('note', self.edit._mainToolbar._generationPalette.scale, notes = notes)
 
     def handlePopdown(self, widget, data = None):
-        self.resetGeneCheckButton()
+        self.resetGeneCheckButton(self.cancelButton)
 
     def setContext( self, context, scale, pageIds = None, trackIds = None, notes = {} ):
         self.context = context
@@ -1034,19 +1050,32 @@ class propertiesPalette(Palette):
                     self.filterCutoffSliderAdj.set_value( n.cs.filterCutoff )
                     self.setup = False
 
-    def resetGeneCheckButton(self):
+    def acceptGeneration( self, widget ):
+        valList = [self.geneMinimum, self.geneMaximum, self.geneRandom]
+        if self.geneCheckButtonDic['transpose'].get_active(): self.algoPitch(valList, self.algorithm)
+        if self.geneCheckButtonDic['volume'].get_active(): self.algoVolume(valList, self.algorithm)
+        if self.geneCheckButtonDic['pan'].get_active(): self.algoPan(valList, self.algorithm)
+        if self.geneCheckButtonDic['reverb'].get_active(): self.algoReverb(valList, self.algorithm)
+        if self.geneCheckButtonDic['attack'].get_active(): self.algoAttack(valList, self.algorithm)
+        if self.geneCheckButtonDic['decay'].get_active(): self.algoDecay(valList, self.algorithm)
+        if self.geneCheckButtonDic['filter'].get_active(): self.algoCutoff(valList, self.algorithm)
+
+    def resetGeneCheckButton(self, widget):
+        if self.hidden:
+            self.generationMainBox.hide()
+
         for key in self.geneCheckButtonDic:
             self.geneCheckButtonDic[key].set_active(False)
 
     def handleGeneCheckButton(self, widget, data = None):
-        hidden = True
+        self.hidden = True
         if widget.get_active():
             self.generationMainBox.show()
         else:
             for key in self.geneCheckButtonDic:
                 if self.geneCheckButtonDic[key].get_active():
-                    hidden = False
-            if hidden:
+                    self.hidden = False
+            if self.hidden:
                 self.generationMainBox.hide()
 
 
@@ -1094,6 +1123,35 @@ class propertiesPalette(Palette):
         if len(stream):
             self.edit.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]
+                        substream += [ n.id, val ]
+                    if len(substream):
+                        stream += [ self.pageIds[p], self.trackIds[t], PARAMETER.PITCH, len(substream)//2 ] + substream
+        if len(stream):
+            self.edit.noteDB.updateNotes( stream + [-1] )
+
     def stepVolume(self, widget, step):
         stream = []
         for p in self.notes:
@@ -1112,6 +1170,25 @@ class propertiesPalette(Palette):
         if len(stream):
             self.edit.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.edit.noteDB.updateNotes( stream + [-1] )
+
     def handlePan(self, adjust):
         if not self.setup:
             stream = []
@@ -1124,6 +1201,24 @@ class propertiesPalette(Palette):
             if len(stream):
                 self.edit.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.edit.noteDB.updateNotes( stream + [-1] )
+
     def handleReverb(self, adjust):
         if not self.setup:
             stream = []
@@ -1136,6 +1231,24 @@ class propertiesPalette(Palette):
             if len(stream):
                 self.edit.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.edit.noteDB.updateNotes( stream + [-1] )
+
     def handleAttack(self, adjust):
         if not self.setup:
             stream = []
@@ -1148,6 +1261,24 @@ class propertiesPalette(Palette):
             if len(stream):
                 self.edit.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.edit.noteDB.updateNotes( stream + [-1] )
+
     def handleDecay(self, adjust):
         if not self.setup:
             stream = []
@@ -1161,6 +1292,24 @@ class propertiesPalette(Palette):
                 self.edit.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.edit.noteDB.updateNotes( stream + [-1] )
+
     def handleFilterTypes(self, widget):
         self.currentFilterType = widget.props.value
 
@@ -1201,9 +1350,6 @@ class propertiesPalette(Palette):
                 if len(typestream):
                     self.edit.noteDB.updateNotes( typestream + [-1] )
 
-    def handleGeneTypes(self, widget):
-        self.currentGeneType = widget.props.value
-
     def handleFilter(self, adjust):
         stream = []
         for p in self.notes:
@@ -1214,3 +1360,33 @@ class propertiesPalette(Palette):
                         stream += [ n.id, adjust.value ]
         if len(stream):
             self.edit.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.edit.noteDB.updateNotes( stream + [-1] )
+
+    def handleGeneTypes(self, widget):
+        self.algorithm = self.algoTypes[widget.props.value]
+
+    def handleMinimum(self, adjust):
+        self.geneMinimum = int(adjust.value)
+
+    def handleMaximum(self, adjust):
+        self.geneMaximum = int(adjust.value)
+
+    def handleRandom(self, adjust):
+        self.geneRandom = int(adjust.value)
\ No newline at end of file