GoogleBlockly: new @block.javascript_callback for StatementBlock, that triggers callback on the fly without having to recompile all the python code to javascript.

hartsantler · hartsantler · commit 701e9d1d1e12 · 2013-10-22T19:29:47.000-07:00
diff --git a/bindings/blockly.py b/bindings/blockly.py
@@ -5,6 +5,17 @@
 BlocklyBlockGenerators = dict()  ## Blocks share a single namespace in Blockly
 _blockly_selected_block = None   ## for triggering on_click_callback
 
+with javascript: BlocklyBlockInstances = {}   ## block-uid : block instance
+_blockly_instances_uid = 0
+
+with javascript:
+	NEW_LINE = String.fromCharCode(10)
+
+def __blockinstance( result, block_uid ):
+	with javascript:
+		BlocklyBlockInstances[ block_uid ].pythonjs_object = result
+	return result
+
 def initialize_blockly( blockly_id='blocklyDiv', toolbox_id='toolbox', on_changed_callback=None ):
 	print 'initialize_blockly'
 	if len( BlocklyBlockGenerators.keys() ):
@@ -80,13 +91,14 @@ class BlocklyBlock:
 		. a bare block can have no inputs or output, and no previous or next statement notches.
 
 	'''
-	def __init__(self, name, title=None, color=None, category=None):
-		self.setup( name, title=title, color=color, category=None )
-
-	def setup(self, name, title=None, color=None, category=None):
-		if name in BlocklyBlockGenerators: raise TypeError
-		BlocklyBlockGenerators[ name ] = self
-		self.name = name
+	def __init__(self, block_name=None, title=None, color=None, category=None):
+		self.setup( block_name=block_name, title=title, color=color, category=None )
+
+	def setup(self, block_name=None, title=None, color=None, category=None):
+		if block_name is None: block_name = '_generated_block' + str(len(BlocklyBlockGenerators.keys()))
+		if block_name in BlocklyBlockGenerators: raise TypeError
+		BlocklyBlockGenerators[ block_name ] = self
+		self.name = block_name
 		self.title = title
 		self.color = color
 		self.category = category
@@ -98,24 +110,30 @@ def setup(self, name, title=None, color=None, category=None):
 		self.stack_output = False
 		self.is_statement = False
 		self.external_function = None
+		self.external_javascript_function = None
 		self.on_click_callback = None
 
+	def javascript_callback(self, jsfunc):
+		print '@callback', jsfunc
+		self.set_external_function( jsfunc.NAME, javascript=True )
+		with javascript: arr = jsfunc.args_signature
+		for i in range(arr.length): self.add_input_value( arr[i] )
+		return jsfunc
+
 	def callback(self, jsfunc):  ## decorator
 		print '@callback', jsfunc
 		self.set_external_function( jsfunc.NAME )
 		with javascript: arr = jsfunc.args_signature
-		print 'arr', arr
-		for i in range(arr.length):
-			self.add_input_value( arr[i] )
+		for i in range(arr.length): self.add_input_value( arr[i] )
 		return jsfunc
 
 	def set_on_click_callback(self, callback):
 		self.on_click_callback = callback
 
-	def set_external_function(self, func_name):
-		self.external_function = func_name
-		if not self.title:
-			self.title = func_name
+	def set_external_function(self, func_name, javascript=False):
+		if javascript: self.external_javascript_function = func_name
+		else: self.external_function = func_name
+		if not self.title: self.title = func_name
 
 	def set_output(self, output):
 		if self.stack_input: raise TypeError
@@ -147,15 +165,17 @@ def add_input_value(self, name=None, type=None, title=None):
 			{'name':name, 'type':type, 'title':title}
 		)
 
-	def add_input_statement(self, name=None, title=None):
+	def add_input_statement(self, name=None, title=None, callback=None):
 		if name is None: raise TypeError
 		if title is None: title = name
 		self.input_statements.append(
-			{'name':name, 'title':title}
+			{'name':name, 'title':title, 'callback':callback}
 		)
 
 
 	def bind_block(self):
+		global _blockly_instances_uid
+
 		block_name = self.name
 		stack_input = self.stack_input
 		stack_output = self.stack_output
@@ -168,9 +188,23 @@ def bind_block(self):
 		color = self.color
 		input_values = self.input_values.js_object
 		input_statements = self.input_statements.js_object
+		external_function = self.external_function
+		external_javascript_function = self.external_javascript_function
+		is_statement = self.is_statement
 
 		with javascript:
 			def init():
+				block_uid = _blockly_instances_uid
+				_blockly_instances_uid += 1
+				BlocklyBlockInstances[ block_uid ] = this
+				this.uid = block_uid  ## note that blockly has its own id called: this.id
+
+				this.__input_values = input_values
+				this.__input_statements = input_statements
+				this.__external_function = external_function
+				this.__external_javascript_function = external_javascript_function
+				this.__is_statement = is_statement
+
 				if color:
 					this.setColour( color )
 
@@ -206,61 +240,92 @@ def init():
 
 	def bind_generator(self):
 		block_name = self.name
-		external_function = self.external_function
-		is_statement = self.is_statement
-		input_values = self.input_values.js_object
-		input_statements = self.input_statements.js_object
+
+		## this is not safe with recursive functions? or this was due to the bad local scope bug below? (see input=null)
+		#external_function = self.external_function
+		#external_javascript_function = self.external_javascript_function
+		#is_statement = self.is_statement
+		#input_values = self.input_values.js_object
+		#input_statements = self.input_statements.js_object
 
 		with javascript:
 			def generator(block):
-				code = ''
+				input_values = block.__input_values
+				input_statements = block.__input_statements
+				external_function = block.__external_function
+				external_javascript_function = block.__external_javascript_function
+				is_statement = block.__is_statement
 
+				code = ''
+				input = null  ## TODO fix local scope generator in python_to_pythonjs.py - need to traverse whileloops - the bug pops up here because this is recursive?
 				args = []
 
 				i = 0
 				while i < input_values.length:
 					input = input_values[i][...]
-					a = Blockly.Python.valueToCode(block, input['name'], Blockly.Python.ORDER_NONE)
+					if external_javascript_function:
+						a = Blockly.JavaScript.valueToCode(block, input['name'], Blockly.JavaScript.ORDER_NONE)
+					else:
+						a = Blockly.Python.valueToCode(block, input['name'], Blockly.Python.ORDER_NONE)
 					if a is not null:  ## blockly API not correct? is says this will return null when nothing is connected.
 						args.push( a )
 					i += 1
-				i = 0
-				while i < input_statements.length:
-					input = input_statements[i][...]
-					a = Blockly.Python.statementToCode(block, input['name'])
-					if a != '':  ## blockly API would be better not returning an empty string here, in case we wanted to set an empty string
-						args.push( a )
-					i += 1
+
+				## input statements are used for dynamic updates
+				if block.pythonjs_object:
+					print 'dynamic blockly js-------'
+					wrapper = block.pythonjs_object[...]
+					print 'dynamic wrapper:', wrapper
+					i = 0
+					while i < input_statements.length:
+						input = input_statements[i][...]
+						#if Object.hasOwnProperty(wrapper, input['name']):  ## this fails on THREE.Mesh.position, why?
+						attr = wrapper[ input['name'] ]
+						if attr:
+							print 'dynamic wrapper has attr:', input['name']
+							js = Blockly.JavaScript.statementToCode(block, input['name'])
+							if input['callback']:
+								print 'DYNAMIC--calling:', js
+								input['callback']( attr, eval(js) )
+							else:
+								print 'WARN - input is missing callback', input
+						i += 1
 
 				if external_function:
 					code += external_function + '(' + ','.join(args) + ')'
+				elif external_javascript_function:
+					## TODO what about pure javascript functions?
+					if is_statement and block.parentBlock_:  ## TODO request Blockly API change: "parentBlock_" to "parentBlock"
+						code += external_javascript_function + '( [' + ','.join(args) + '] )'  ## calling from js a pyjs function
+
 				else:  ## this should be a simple series of statements?
 					for a in args:
 						code += a + ';'
 
 				if is_statement:
-					return code + ';'	## statements can directly return
+					return code + NEW_LINE	## statements can directly return
 				else:
+					code = '__blockinstance(  ' + code + '  ,' + block.uid + ')'
 					return [ code, Blockly.Python.ORDER_NONE ]  ## return Array
 
-			print 'bindings block generator:', block_name
 			Blockly.Python[ block_name ] = generator
+			Blockly.JavaScript[ block_name ] = generator
 
 
 
 class StatementBlock( BlocklyBlock ):
 	'''
 	A statement-block has a previous and/or next statement notch: stack_input and/or stack_output
 	'''
-	def __init__(self, name, title=None, stack_input=False, stack_output=False, color=170, category=None):
-		self.setup( name, title=title, color=color, category=category )
+	def __init__(self, block_name=None, title=None, stack_input=False, stack_output=False, color=170, category=None):
+		self.setup( block_name=block_name, title=title, color=color, category=category )
 		self.make_statement( stack_input=stack_input, stack_output=stack_output)
 
 
 class ValueBlock( BlocklyBlock ):
-	def __init__(self, name, title=None, output='*', color=100, category=None):
+	def __init__(self, block_name=None, title=None, output='*', color=100, category=None):
 		if output is None: raise TypeError
-		self.setup( name, title=title, color=color, category=category )
+		self.setup( block_name=block_name, title=title, color=color, category=category )
 		self.set_output( output )
 
 
diff --git a/pythonjs/python_to_pythonjs.py b/pythonjs/python_to_pythonjs.py
@@ -1092,13 +1092,16 @@ def visit_FunctionDef(self, node):
         writer.write( '%s.args_signature = [%s]' %(node.name, ','.join(['"%s"'%n.id for n in node.args.args])) )
 
         if self._with_js and with_js_decorators:
-            ## these with-js functions are assigned to a some objects prototype,
-            ## here we assume that they depend on the special "this" variable,
-            ## therefore this function can not be marked as f.pythonscript_function,
-            ## because we need get_attribute(f,'__call__') to dynamically bind "this"
             for dec in with_js_decorators:
-                assert '.prototype.' in dec
-                writer.write( '%s=%s'%(dec,node.name) )
+                if '.prototype.' in dec:
+                    ## these with-js functions are assigned to a some objects prototype,
+                    ## here we assume that they depend on the special "this" variable,
+                    ## therefore this function can not be marked as f.pythonscript_function,
+                    ## because we need get_attribute(f,'__call__') to dynamically bind "this"
+                    writer.write( '%s=%s'%(dec,node.name) )
+                else:  ## TODO fix with-javascript decorators
+                    writer.write( '%s = get_attribute(%s,"__call__")( [%s] )' %(node.name, dec, node.name))
+
         elif self._with_js:  ## this is just an optimization so we can avoid making wrappers at runtime
             writer.write('%s.pythonscript_function=true'%node.name)
         else:
diff --git a/tests/threejs_meets_blockly_and_ace.html b/tests/threejs_meets_blockly_and_ace.html
@@ -136,6 +136,7 @@
 <script src="blockly_compressed.js" type="text/javascript" charset="utf-8"></script>
 <script src="blocks_compressed.js" type="text/javascript" charset="utf-8"></script>
 <script src="python_compressed.js" type="text/javascript"></script>
+<script src="javascript_compressed.js" type="text/javascript"></script>
 
 <script type="text/javascript" src="msg/js/en.js"></script>
 
@@ -236,7 +237,24 @@
 
 Meshes = []
 
+block = StatementBlock(block_name='x', stack_input=True, category='Transform')
+@block.javascript_callback
+def vector(x,y,z):
+	print 'js-callback VECTOR', x,y,z
+	with javascript:
+		return [x,y,z]
+
+with javascript:  ## called from blockly generator update
+	def set_vector( vec, arr ):
+		print 'js-level blockly callback', vec, arr
+		vec.x = arr[0]
+		vec.y = arr[1]
+		vec.z = arr[2]
+
 geoblock1 = ValueBlock('geoblock1', category='Geometry')
+geoblock1.add_input_statement('position', callback=set_vector )
+geoblock1.add_input_statement('rotation')  # ,callback='xxxx')
+geoblock1.add_input_statement('scale')  # ,callback='xxxx')
 @geoblock1.callback
 def Circle( radius, segments, start, end, material=None, child=None ):
 	geo = CircleGeometry( radius, segments, start, end )
@@ -247,6 +265,8 @@
 	return mesh
 
 geoblock2 = ValueBlock('geoblock2', category='Geometry')
+geoblock2.add_input_statement('position', callback=set_vector )
+
 @geoblock2.callback
 def Cube( width, height, length, material=None, child=None ):
 	geo = CubeGeometry( width, height, length )
@@ -289,13 +309,13 @@
 
 tblock1 = ValueBlock('tblock1', category='Transform')
 @tblock1.callback
-def move(object, x,y,z):
+def position(object, x,y,z):
 	object.position.set(x,y,z)
 	return object
 
 tblock2 = ValueBlock('tblock2', category='Transform')
 @tblock2.callback
-def rotate(object, x,y,z):
+def rotation(object, x,y,z):
 	object.rotation.set(x,y,z)
 	return object
 
@@ -307,6 +327,7 @@
 
 
 
+
 sblock1 = StatementBlock('sblock1', stack_output=True, category='Scene')
 @sblock1.callback
 def initialize():
