Jam drawing

1 files changed, 218 insertions, 36 deletions

diff --git a/Jam/Block.py b/Jam/Block.py
index 907ed3d..d2b30a8 100644
--- a/Jam/Block.py
+++ b/Jam/Block.py
@@ -5,35 +5,39 @@ import gtk
 
 import Config
 
-import random
-    
+#::: NOTE:
+# All the graphics resources are loaded in Desktop and referenced here as necessary
+#:::
+
 class Block():
 
     WIDTH = 100
     HEIGHT = 100
 
-    WIDTH_DIV2 = WIDTH//2
-    HEIGHT_DIV2 = HEIGHT//2
-   
-    def __init__( self, owner, graphics_context ):
+    def __init__( self, owner, graphics_context, data ):
         self.owner = owner
         self.gc = graphics_context
+        self.data = data
 
         self.type = Block
 
+        self.width = Block.WIDTH
+        self.height = Block.HEIGHT
+
         self.parent = None
         self.canChild = False
         self.child = None
         self.canParent = False
 
+        self.parentOffest = 0
+
         self.dragging = False 
 
         self.placed = False
         self.x = -1 
         self.y = -1
 
-        # TEMP
-        self.color = random.choice( [ "tempBlock1", "tempBlock2", "tempBlock3", "tempBlock4", "tempBlock5" ] )
+        self.active = True
 
     def destroy( self ):
         if self.child:
@@ -53,13 +57,19 @@ class Block():
         
         self.x = x
         self.y = y
-        self.endX = x + self.type.WIDTH
-        self.endY = y + self.type.HEIGHT
+        self.endX = x + self.width
+        self.endY = y + self.height
 
         self.invalidate_rect( not self.dragging )
 
         if self.child:
-            self.child.setLoc( self.endX, y )
+            self.child._updateParentLoc( self.endX, y )
+
+    def getAttachLoc( self ):
+        return ( self.x + self.parentOffset, self.y )
+
+    def _updateParentLoc( self, x, y ):
+        self.setLoc( x - self.parentOffset, y )
 
     def testChild( self, loc ):
 
@@ -67,8 +77,7 @@ class Block():
             return False
 
         if self.child:
-            handled = self.child.testChild( loc )
-            if handled: return handled
+            return self.child.testChild( loc )
         elif abs( self.endX - loc[0] ) < 10 and abs( self.y - loc[1] ) < 10:
             return self
 
@@ -77,7 +86,7 @@ class Block():
     def addChild( self, child ):
         self.child = child
         child._addParent( self )
-        child.setLoc( self.endX, self.y )
+        child._updateParentLoc( self.endX, self.y )
 
     def removeChild( self ):
         self.child._removeParent()
@@ -105,12 +114,11 @@ class Block():
         if event.x < self.x:
             return False
 
-        if self.child:
-            handled = self.child._button_pressB( event )
-            if handled: return handled
-
         if event.x > self.endX:
-            return False
+            if self.child:
+                return self.child._button_pressB( event )
+            else:
+                return False
 
         self.dragOffset = ( event.x - self.x, event.y - self.y )
 
@@ -143,7 +151,7 @@ class Block():
 
     def _beginDrag( self ):
         self.dragging = True
-        self.dragOffset = ( self.type.WIDTH_DIV2, self.type.HEIGHT_DIV2 )
+        self.dragOffset = ( self.width//2, self.height//2 )
 
     def invalidateBranch( self, base = True ):
         self.invalidate_rect( base )
@@ -151,7 +159,7 @@ class Block():
             self.child.invalidateBranch( base )
 
     def invalidate_rect( self, base = True ):
-        self.owner.invalidate_rect( self.x, self.y, self.type.WIDTH, self.type.HEIGHT, base )
+        self.owner.invalidate_rect( self.x, self.y, self.width, self.height, base )
 
     def draw( self, startX, startY, stopX, stopY, pixmap ):
         if stopY < self.y or startY > self.endY:
@@ -175,33 +183,207 @@ class Block():
         return True
 
     def _doDraw( self, startX, startY, stopX, stopY, pixmap ):
-        # TEMP
-        self.gc.foreground = self.owner.colors[self.color]
-        pixmap.draw_rectangle( self.gc, True, self.x, self.y, self.type.WIDTH, self.type.HEIGHT )
         pass # override in subclasses
 
     def drawHighlight( self, startX, startY, stopX, stopY, pixmap ):
-        # TEMP
-        self.gc.foreground = self.owner.colors["tempWhite"]
-        pixmap.draw_rectangle( self.gc, False, self.x, self.y, self.type.WIDTH-1, self.type.HEIGHT-1 )
-        
+        pass # override in subclasses 
 
 class Instrument(Block):
     
-    WIDTH = Block.WIDTH 
-    HEIGHT = Block.HEIGHT
+    MASK_START = 0
 
-    WIDTH_DIV2 = WIDTH//2
-    HEIGHT_DIV2 = HEIGHT//2
-   
-    def __init__( self, owner, graphics_context ):
-        Block.__init__( self, owner, graphics_context )
+    #::: data format:
+    # { }
+    #:::
+    def __init__( self, owner, graphics_context, data ):
+        Block.__init__( self, owner, graphics_context, data )
 
         self.type = Instrument
 
         self.canParent = True
+
+    def _doButtonPress( self, event ): # we were hit with a button press
+        pass
+
+    def _doDraw( self, startX, startY, stopX, stopY, pixmap ):
+        # draw border
+        if self.active: self.gc.foreground = self.owner.colors["Border_Active"]
+        else:           self.gc.foreground = self.owner.colors["Border_Inactive"]
+        self.gc.set_clip_origin( self.x-Instrument.MASK_START, self.y )
+        pixmap.draw_rectangle( self.gc, True, self.x, self.y, self.width, self.height )
+
+        # draw block
+        if self.active: self.gc.foreground = self.owner.colors["Bg_Active"]
+        else:           self.gc.foreground = self.owner.colors["Bg_Inactive"]
+        self.gc.set_clip_origin( self.x-Instrument.MASK_START, self.y-self.height )
+        pixmap.draw_rectangle( self.gc, True, self.x, self.y, self.width, self.height )
+
+    def drawHighlight( self, startX, startY, stopX, stopY, pixmap ):
+        self.gc.foreground = self.owner.colors["Border_Highlight"]
+        self.gc.set_clip_origin( self.x-Instrument.MASK_START, self.y )
+        pixmap.draw_rectangle( self.gc, True, self.x, self.y, self.width, self.height )
+
+
+class Drum(Block):
+
+    MASK_START = 100
+    
+    #::: data format:
+    # { }
+    #:::
+    def __init__( self, owner, graphics_context, data ):
+        Block.__init__( self, owner, graphics_context, data )
+
+        self.type = Drum 
+
+    def _doButtonPress( self, event ): # we were hit with a button press
+        pass
+
+    def _doDraw( self, startX, startY, stopX, stopY, pixmap ):
+        # draw border
+        if self.active: self.gc.foreground = self.owner.colors["Border_Active"]
+        else:           self.gc.foreground = self.owner.colors["Border_Inactive"]
+        self.gc.set_clip_origin( self.x-Drum.MASK_START, self.y )
+        pixmap.draw_rectangle( self.gc, True, self.x, self.y, self.width, self.height )
+
+        # draw block
+        if self.active: self.gc.foreground = self.owner.colors["Bg_Active"]
+        else:           self.gc.foreground = self.owner.colors["Bg_Inactive"]
+        self.gc.set_clip_origin( self.x-Drum.MASK_START, self.y-self.height )
+        pixmap.draw_rectangle( self.gc, True, self.x, self.y, self.width, self.height )
+
+    def drawHighlight( self, startX, startY, stopX, stopY, pixmap ):
+        self.gc.foreground = self.owner.colors["Border_Highlight"]
+        self.gc.set_clip_origin( self.x-Drum.MASK_START, self.y )
+        pixmap.draw_rectangle( self.gc, True, self.x, self.y, self.width, self.height )
+
+
+class Loop(Block):
+
+    HEAD = 13
+    BEAT = 23
+    TAIL = BEAT + 4
+
+    BEAT_MUL3 = BEAT*3
+
+    MASK_START = 200
+    MASK_BEAT  = MASK_START + HEAD
+    MASK_TAIL  = MASK_START + HEAD + BEAT*3
+    
+    #::: data format:
+    # { "beats": N }
+    #:::
+    def __init__( self, owner, graphics_context, data ):
+        Block.__init__( self, owner, graphics_context, data )
+
+        self.type = Loop
+
+        self.width = Loop.HEAD + Loop.BEAT*(data["beats"]-1) + Loop.TAIL
+
+        self.canParent = True
         self.canChild = True
 
+        self.parentOffset = Loop.HEAD - 4
+
     def _doButtonPress( self, event ): # we were hit with a button press
         pass
-        
+
+    def _doDraw( self, startX, startY, stopX, stopY, pixmap ):
+
+        #-- draw head -----------------------------------------
+
+        # draw border
+        if self.active: self.gc.foreground = self.owner.colors["Border_Active"]
+        else:           self.gc.foreground = self.owner.colors["Border_Inactive"]
+        self.gc.set_clip_origin( self.x-Loop.MASK_START, self.y )
+        pixmap.draw_rectangle( self.gc, True, self.x, self.y, Loop.HEAD, self.height )
+
+        # draw block
+        if self.active: self.gc.foreground = self.owner.colors["Bg_Active"]
+        else:           self.gc.foreground = self.owner.colors["Bg_Inactive"]
+        self.gc.set_clip_origin( self.x-Loop.MASK_START, self.y-self.height )
+        pixmap.draw_rectangle( self.gc, True, self.x, self.y, Loop.HEAD, self.height )
+
+        #-- draw beats ----------------------------------------
+  
+        beats = self.data["beats"] - 1 # last beat is drawn with the tail
+        x = self.x + Loop.HEAD
+        while beats > 3:
+            # draw border
+            if self.active: self.gc.foreground = self.owner.colors["Border_Active"]
+            else:           self.gc.foreground = self.owner.colors["Border_Inactive"]
+            self.gc.set_clip_origin( x-Loop.MASK_BEAT, self.y )
+            pixmap.draw_rectangle( self.gc, True, x, self.y, Loop.BEAT_MUL3, self.height )
+
+            # draw block
+            if self.active: self.gc.foreground = self.owner.colors["Bg_Active"]
+            else:           self.gc.foreground = self.owner.colors["Bg_Inactive"]
+            self.gc.set_clip_origin( x-Loop.MASK_BEAT, self.y-self.height )
+            pixmap.draw_rectangle( self.gc, True, x, self.y, Loop.BEAT_MUL3, self.height )
+
+            x += Loop.BEAT_MUL3
+            beats -= 3
+        if beats:
+            width = Loop.BEAT*beats
+            
+            # draw border
+            if self.active: self.gc.foreground = self.owner.colors["Border_Active"]
+            else:           self.gc.foreground = self.owner.colors["Border_Inactive"]
+            self.gc.set_clip_origin( x-Loop.MASK_BEAT, self.y )
+            pixmap.draw_rectangle( self.gc, True, x, self.y, width, self.height )
+
+            # draw block
+            if self.active: self.gc.foreground = self.owner.colors["Bg_Active"]
+            else:           self.gc.foreground = self.owner.colors["Bg_Inactive"]
+            self.gc.set_clip_origin( x-Loop.MASK_BEAT, self.y-self.height )
+            pixmap.draw_rectangle( self.gc, True, x, self.y, width, self.height )
+
+            x += width
+
+        #-- draw tail -----------------------------------------
+
+        # draw border
+        if self.active: self.gc.foreground = self.owner.colors["Border_Active"]
+        else:           self.gc.foreground = self.owner.colors["Border_Inactive"]
+        self.gc.set_clip_origin( x-Loop.MASK_TAIL, self.y )
+        pixmap.draw_rectangle( self.gc, True, x, self.y, Loop.TAIL, self.height )
+
+        # draw block
+        if self.active: self.gc.foreground = self.owner.colors["Bg_Active"]
+        else:           self.gc.foreground = self.owner.colors["Bg_Inactive"]
+        self.gc.set_clip_origin( x-Loop.MASK_TAIL, self.y-self.height )
+        pixmap.draw_rectangle( self.gc, True, x, self.y, Loop.TAIL, self.height )
+
+    def drawHighlight( self, startX, startY, stopX, stopY, pixmap ):
+
+        self.gc.foreground = self.owner.colors["Border_Highlight"]
+
+        #-- draw head -----------------------------------------
+
+        self.gc.set_clip_origin( self.x-Loop.MASK_START, self.y )
+        pixmap.draw_rectangle( self.gc, True, self.x, self.y, Loop.HEAD, self.height )
+
+        #-- draw beats ----------------------------------------
+  
+        beats = self.data["beats"] - 1 # last beat is drawn with the tail
+        x = self.x + Loop.HEAD
+        while beats > 3:
+            self.gc.set_clip_origin( x-Loop.MASK_BEAT, self.y )
+            pixmap.draw_rectangle( self.gc, True, x, self.y, Loop.BEAT_MUL3, self.height )
+
+            x += Loop.BEAT_MUL3
+            beats -= 3
+        if beats:
+            width = Loop.BEAT*beats
+            
+            self.gc.set_clip_origin( x-Loop.MASK_BEAT, self.y )
+            pixmap.draw_rectangle( self.gc, True, x, self.y, width, self.height )
+            
+            x += width
+
+        #-- draw tail -----------------------------------------
+
+        self.gc.set_clip_origin( x-Loop.MASK_TAIL, self.y )
+        pixmap.draw_rectangle( self.gc, True, x, self.y, Loop.TAIL, self.height )
+
+