[二]Python通过ActiveX容器嵌入flash

Python代码

# -*- coding: utf-8 -*-
import wx
import os
from xml.dom import minidom
from wx.lib.flashwin import FlashWindow

class EIDataSerializer:
    __xmlData=None
    def __packNumber(self,p,x):
        p.appendChild(self.__xmlData.createElement('number')).appendChild(self.__xmlData.createTextNode(str(x)))
        return
    def __packString(self,p,x):
        p.appendChild(self.__xmlData.createElement('string')).appendChild(self.__xmlData.createTextNode(x))
        return
    def __packNone(self,p):
        p.appendChild(self.__xmlData.createElement('null'))
        return
    def __packBool(self,p,x):
        if x:
            p.appendChild(self.__xmlData.createElement('true'))
        else:
            p.appendChild(self.__xmlData.createElement('false'))
        return
    def __packDict(self,p,x):
        p=p.appendChild(self.__xmlData.createElement('object'))
        for k,v in x.items():
            n=p.appendChild(self.__xmlData.createElement('property'))
            n.setAttribute('id',str(k))
            self.__packData(n,v)
        return
    def __packList(self,p,x):
        p=p.appendChild(self.__xmlData.createElement('array'))
        i=0
        for v in x:
            n=p.appendChild(self.__xmlData.createElement('property'))
            n.setAttribute('id',str(i))
            self.__packData(n,v)
            i+=1
        return
    def __packData(self,p,x): ##将Python的类型打包成XML
        t=type(x)
        if t in (int,long,float):               
            self.__packNumber(p,x)
        elif t in (str,unicode):                
            self.__packString(p,x)
        elif x==None:                           
            self.__packNone(p)
        elif t==bool:       
            self.__packBool(p,x)
        elif t in (list,tuple):
            self.__packList(p,x)
        elif t==dict:
            self.__packDict(p,x)
        return
    def __unpackNumber(self,p):
        try:
            return int(p.firstChild.nodeValue)
        except ValueError:
            try:
                return float(p.firstChild.nodeValue)
            except ValueError:
                return None
    def __unpackString(self,p):
        return p.firstChild.nodeValue
    def __unpackTrue(self):
        return True
    def __unpackFalse(self):
        return False
    def __unpackNull(self):
        return None
    def __unpackUndefined(self):
        return None
    def __unpackObject(self,p):
        d={}
        for n in p.childNodes:
            d[n.getAttribute('id')]=self.__unpackData(n.firstChild)
        return d
    def __unpackArray(self,p):
        a=[]
        for n in p.childNodes:
            a.append(self.__unpackData(n.firstChild))
        return a
    def __unpackData(self,p): ##将Flash传过来的XML解析成Python类型数值
        t=p.nodeName
        if t=='number':
            return self.__unpackNumber(p)
        elif t=='string':
            return self.__unpackString(p)
        elif t=='true':
            return self.__unpackTrue()
        elif t=='false':
            return self.__unpackFalse()
        elif t=='null':
            return self.__unpackNull()
        elif t=='undefined':
            return self.__unpackUndefined()
        elif t=='object':
            return self.__unpackObject(p)
        elif t=='array':
            return self.__unpackArray(p)
    def serializeReturn(self,v):
        self.__xmlData=minidom.Document()
        p=self.__xmlData
        self.__packData(p,v)
        return self.__xmlData.toxml()
    def serializeCall(self,name,args):
        self.__xmlData=minidom.Document()
        p=self.__xmlData.appendChild(self.__xmlData.createElement('invoke'))
        p.setAttribute('name',name)
        p.setAttribute('returntype','xml')
        p=p.appendChild(self.__xmlData.createElement('arguments'))
        for v in args:
            self.__packData(p,v)
        s=self.__xmlData.documentElement.toxml()
        return s
    def deserializeReturn(self,s):
        self.__xmlData=minidom.parseString(s)
        p=self.__xmlData.documentElement
        return self.__unpackData(p)
    def deserializeCall(self,s):
        self.__xmlData=minidom.parseString(s)
        p=self.__xmlData.documentElement#invoke
        name=p.getAttribute('name')
        args=[]
        p=p.firstChild#arguments
        for n in p.childNodes:
            args.append(self.__unpackData(n))
        return (name,args)

class FlashFrame(wx.Frame):
    def __init__(self, parent, fid, title): 
        wx.Frame.__init__(self, parent, fid, title)  
        sort = -1
        self.rootPanel = wx.Panel(self, sort)
        self.flashWin  = FlashWindow(self.rootPanel)
        self.txtBox    = wx.TextCtrl(self.rootPanel, wx.NewId())
        self.btSend    = wx.Button(self.rootPanel, wx.NewId(), "Call Flash")
    
        self.flashSizer = wx.BoxSizer(wx.VERTICAL)
        self.flashSizer.Add(self.flashWin, proportion=1,   flag=wx.EXPAND)
        self.flashSizer.Add(self.txtBox,   proportion=0.3, flag=wx.EXPAND|wx.ALL, border=2)
        self.flashSizer.Add(self.btSend,   proportion=0.3, flag=wx.EXPAND|wx.ALL, border=2)
        self.rootPanel.SetSizer(self.flashSizer)
        self.rootPanel.SetAutoLayout(True)

        self.flashWin.AddEventSink(self)
        self.rootPanel.Bind(wx.EVT_BUTTON, self.sendToFlashHandler, self.btSend)
        self.flashWin.LoadMovie(0, os.getcwd() + os.path.sep + 'hello.swf')
        return

    def FlashCall(self, xmlStr):
        serializer = EIDataSerializer()
        xmlStr   = xmlStr.encode('utf-8')             ##从Flash控件消息接收的XML字符串
        print "FlashCall: \n" + xmlStr
        name, args       = serializer.deserializeCall(xmlStr) ##解析成Python函数名和参数
        print name
        print args
        print args[0]
        result = "Python返回: " + args[0]
        result = serializer.serializeReturn(result)                     ##返回值打包成XML  
        self.flashWin.ctrl.SetReturnValue(result)
    


    def sendToFlashHandler(self, btEvent):
        sendStr = self.txtBox.GetValue()
        flashFunctionName = "helloFlash"
        xmlStr = "<invoke name=\"" + flashFunctionName + "\" returntype=\"xml\">"
        xmlStr += "<arguments>"
        xmlStr += "<string>" + sendStr + "</string>"
        xmlStr += "</arguments>"
        xmlStr += "</invoke>"
        rValue = self.flashWin.ctrl.CallFunction(xmlStr)
        print "Flash返回: ", rValue


app = wx.PySimpleApp()
frame = FlashFrame(None, -1, "Python & Flash")
frame.Show(True)
app.MainLoop()

Flash代码

package
{
	import flash.display.Sprite;
	import flash.display.StageAlign;
	import flash.display.StageScaleMode;
	import flash.events.Event;
	import flash.events.MouseEvent;
	import flash.external.ExternalInterface;
	import flash.text.TextField;
	import flash.text.TextFieldType;

	public class Hello extends Sprite {
		
		private var input:TextField;
		private var submit:Sprite;
		private var message:TextField;
		
		public function Hello() {
			stage.align = StageAlign.TOP_LEFT;
			stage.scaleMode = StageScaleMode.NO_SCALE;
			addEventListener(Event.ADDED_TO_STAGE, onAddedToStage);
		}
		
		private function onAddedToStage(event:Event):void {
			removeEventListener(Event.ADDED_TO_STAGE, onAddedToStage);
			stage.align = StageAlign.TOP_LEFT;
			stage.scaleMode = StageScaleMode.NO_SCALE;
			createInput();
			createButton();
			createMessage();
			ExternalInterface.addCallback("helloFlash", helloFlash);
		}
		
		private function createInput():void {
			input = new TextField();
			input.type = TextFieldType.INPUT;
			input.width = 200;
			input.height = 30;
			input.border = true;
			input.text = "请输入传给Python方法的参数";
			addChild(input);
		}
		
		private function createButton():void {
			submit = new Sprite();
			submit.graphics.beginFill(0x888888);
			submit.graphics.drawRoundRect(0, 0, 60, 30, 5, 5);
			submit.graphics.endFill();
			addChild(submit);
			submit.x = input.x + input.width + 1;
			submit.addEventListener(MouseEvent.CLICK, onSubmitClick);
		}
		
		private function onSubmitClick(event:MouseEvent):void {
			if(input.text && !isSpaces(input.text)) {
				var result:* = ExternalInterface.call("helloPython", input.text);
				if(!result) {
					result = "null";	
				}
				result += "\n";
				message.appendText(result as String);
			}else {
				input.text = "请输入传给Python方法的参数";	
			}
		}
		
		public function helloFlash(data:String):String {
			return "Python input: " + data;	
		}
		
		private function isSpaces(str:String):Boolean {
			for (var i:int = 0; i < str.length; i++) {
				var char:String = str.charAt(i);
				if(char != " ") {
					return false;	
				}
			}
			return true;
		}
		
		private function createMessage():void {
			message = new TextField();
			message.width = input.width + submit.width + 1;
			message.height = 100;
			message.wordWrap = true;
			message.multiline = true;
			message.border = true;
			addChild(message);
			message.text = "";
			message.x = input.x;
			message.y = input.y + input.height + 5;
		}
	}
}