== 基于本地的Python应用程序 ==
=== 写在之前 ===
{{{
这篇所说的是关于建立python调用Flash的本地应用，不同于Adobe的Apollo。
没有用到浏览器嵌入flash网页的方法，直接在pythonwin或者wxpython建立的窗口中插入Flash ocx。
因为是操作Activex控件的方式因此大概只适用于windows平台。抱歉我并未在其它平台上试过这种方法，不过linux中应该也有类似的技术。}}}
=== Flash ocx介绍 ===
{{{
Flash ocx实际上是一种COM组件开发模型(Microsoft Component Object Model)，它原先是从Windows 3.x中的OLE发展过来的。现在又被改名叫做Activex。Activex是COM的一种，一般是指带有UI界面的COM。
Flash ocx的本名是叫Shockwave Flash Object，是一个Activex控件。Activex控件文件名的后缀是ocx。
原先的Shockwave包括了很多东西。被Adobe收购的MicroMedia公司的另一个产品Director的web应用就叫shockwave，它集合了视频流、Flash、shockwave 3D于一身。
对于Director我还是挺有感情的，只不过Director到了8.5以后的版本就基本不再发展了，我也渐渐不用它了。(听说Adobe收购MicroMedia以后，还会推出Director 11)}}}
=== Flash ocx与外界通迅的方法 ===
==== 调用ocx标准COM接口IDispatch ====
这种方法最简单，也比较通用。
它又叫COM对象的自动化接口。使用自动化，对象就可以提供一个简单的自动化接口，这样脚本语言作者只需掌握IDispatch和几个COM应用程序接口就可以了。
pythonwin的作者 Mark Hammond 的一本书(Python Programming on Win32)就讲到了怎样用python直接操作COM对象（操作的函义包括使用和发布)。如果想深入细节的话，可以参考这本书。
Python 程序使用 win32com.client.Dispatch() 方法来创建 COM objects。
如创建一个 Flash COM object.
{{{#!python
>>> import win32com.client
>>> fl = win32com.client.Dispatch("ShockwaveFlash.ShockwaveFlash.9") #Flash 9 的ProgID是ShockwaveFlash.ShockwaveFlash.9，有很多工具可以查到机器内部注册的COM组件信息
}}}
这样就得到了Flash COM object，你可以让它LoadMovie，让它Play，但是你暂时还看不到它，你得传给它一个窗口，这样它才能显示在窗口。
所幸wxpython帮我们封装了这一切，你只需要调用wx.lib.flashwin.FlashWindow类就行了。
例：
{{{#!python
import wx
from wx.lib.flashwin import FlashWindow
class CGui(wx.Frame):
def __init__(self):
wx.Frame.__init__(self, None, 101, "map", size = (800, 600), style = wx.FRAME_SHAPED)
self.flash = FlashWindow(self, style=wx.SUNKEN_BORDER, size = (800, 600)) #用wx.lib.flashwin.FlashWindow创建窗口
self.flash.LoadMovie(0, 'C:\\drop_shadow_dog.swf') #播放"C:\\drop_shadow_dog.swf"的Flash影片
self.flash.SetSize((800, 600));
def getText(self):
returnValue = self.flash.GetVariable('FlashValue') #从Flash端
return returnValue
def setText(self, text):
self.flash.SetVariable("PythonValue", text) #传给Flash变量
}}}
这些传递变量在Flash AS端都处于_root层级下。
这儿有个例子
http://www.sephiroth.it/weblog/archives/2004/05
/wxpython_and_flash_first_test.php
{{{#!python
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import wx, sys, os
import string, codecsfrom wx.lib.flashwin
import FlashWindow
from wx.lib.flashwin import EVT_FSCommand
#----------------------------------------
class TestPanel(wx.Panel):
def __init__(self, parent, base, swf):
wx.Panel.__init__(self, parent, -1)
self.base = base
sizer = wx.BoxSizer(wx.VERTICAL)
self.flash = FlashWindow(self, style=wx.SUNKEN_BORDER)
dlg = wx.MessageDialog(self, "This will work only under Windows!","Warning!",wx.OK | wx.ICON_INFORMATION)
dlg.Center()
dlg.ShowModal()
wx.BeginBusyCursor()
try:
self.flash.LoadMovie(0, swf)
except:
wx.MessageDialog(self, "could not load the swf file","Error",wx.OK | wx.ICON_ERROR).ShowModal()
sys.exit(2)
wx.EndBusyCursor()
self.flash.Stop()
self.flash.SetSize((self.flash.GetSize()[0],self.flash.GetSize()[1]))
# sizer
sizer.Add(self.flash, 1, wx.EXPAND)
self.SetSizer(sizer)
self.SetAutoLayout(True)
sizer.Fit(self)
sizer.SetSizeHints(self)
self.SetFlashOptions()
self.Bind(wx.EVT_WINDOW_DESTROY, self.OnDestroy)
self.Bind(EVT_FSCommand, self.CallMethod) ##将Flash ocx的消息事件绑定到CallMethod函数上。
def SetFlashOptions(self):
self.flash.menu = False
self.flash._set_FlashVars("data=Server started on " + sys.platform)
self.flash.Play()
def OnDestroy(self, evt):
if self.flash:
self.flash.Cleanup()
self.flash = None
# Called from Flash FSCommand
def CallMethod(self, evt):
try:
arguments = string.split(evt.args,"###")
filename = arguments[0]
body = arguments[1]
if filename == "" or body == "":
wx.MessageDialog(self, "Please check data inserted", "An Error occurred", wx.OK | wx.ICON_INFORMATION).ShowModal()
else:
dlg = wx.FileDialog(self, "Save as..." , os.getcwd(), filename, "*.*", wx.SAVE | wx.OVERWRITE_PROMPT )
if dlg.ShowModal() == wx.ID_OK:
try:
f = codecs.open(os.path.normpath(dlg.GetPath()), "w", "utf-8", "ignore")
f.write(codecs.utf_8_decode(codecs.BOM_UTF8)[0])
f.write(body)
f.close()
self.flash._set_FlashVars("data=Succesfully saved text file")
except:
wx.MessageDialog(self, "%s %s %s" % sys.exc_info(), "An Error occurred", wx.OK | wx.ICON_ERROR).ShowModal()
self.flash._set_FlashVars("data=%s %s %s" % sys.exc_info())
except:
wx.MessageDialog(self, "Please check data inserted","An Error occurred",wx.OK | wx.ICON_INFORMATION).ShowModal()
self.flash._set_FlashVars("data=%s %s %s" % sys.exc_info())
#-------------------------------------------
if __name__ == '__main__':
class TestFrame(wx.Frame):
def __init__(self):
wx.Frame.__init__(self, None, -1, "ActiveX -- Flash", size=(640, 480), style=wx.DEFAULT_FRAME_STYLE )
base = os.path.normpath(os.path.abspath(os.path.dirname(sys.argv[0])))
swf = os.path.normpath(os.path.join(base, "movie.swf"))
self.tp = TestPanel(self, base, swf)
app = wx.PySimpleApp()
frame = TestFrame()
frame.Center()
frame.Show(True)
app.MainLoop()
}}}
Flash端很简单，两句话就搞定了。
{{{
on (click) {
fscommand("saveFile", this._parent.fnome.text + "###" + this._parent.ftesto.text)
}}}}
这里用到了Flash的fscommand。
在Flash端点击了以后，它就会发送一个fscommand消息事件。
python端接收到了以后，由CallMethod处理。
==== 使用Flash ExternalInterface ====
ExternalInterface 类是一个子系统，通过它可以轻松地实现从 ActionScript 和 Flash Player 到 HTML 页中的 JavaScript 或任何包含 Flash Player 实例的台式机应用程序的通信。
ExternalInterface 可以提供以下功能：
{{{
■ 可以调用注册过的 python 函数。 从python端也可以调用注册过的Flash ActionScript函数。
■ 可以传递任意数量的、具有任意名称的参数；而不是仅限于传递一个命令和一个字符串参数。
■ 可以传递各种数据类型（例如 Boolean 、Number 和 String）；不再仅限于 String 参数。
■ 可以接收调用值，该值将立即返回到 ActionScript（作为进行的调用的返回值）。}}}
Flash利用ExternalInterface与Python之间的通信使用特定的XML格式对函数调用和值进行编码。Flash端自动处理XML格式，Python则需要将接收到的XML数据解析和发送前打包成XML格式。
使用ExternalInterface与Python进行通信时，Flash以特定的XML格式向应用程序发送消息（函数调用和返回值），并要求来自Python的函数调用和返回值使用相同的 XML格式。
下面的 XML 片断说明了一个 XML 格式的函数调用示例：
{{{
... (individual argument values)
}}}
通过XML格式，ExternalInterface与Python之间可以传递多种类型的参数，包括Python的list和dic类型。
我们可以建立一个数据转换类来专门将翻译Python与Flash之间的通迅。
{{{#!python
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)}}}
===== 从Python调用Flash函数 =====
从Python端调用Flash端函数实际上是Python调用Shockwave Flash ActiveX控件的CallFunction()方法，通过ExternalInterface从Flash调用ActionScript函数。
以下示范了从Python调用Flash函数的用法:
Python端：
{{{#!python
def CallFlash(name,args): ## name是Flash ActionScript的函数名,args是传给Flash ActionScript的参数
ds = EIDataSerializer()
s = ds.serializeCall(name,args) ## 将传递的内容打包成XML
s = flashWnd.ocx.CallFunction(s) ## 调用Shockwave Flash ActiveX控件的CallFunction()方法
s = s.encode('utf-8') ## 从ActionScript返回的任何值都被编码为XML格式字符串，并作为CallFunction()调用的返回值发送回来。
return ds.deserializeReturn(s) ## 返回值解包}}}
Flash端:
要从Python调用ActionScript函数，必须向ExternalInterface类注册函数，然后再用Shockwave Flash ActiveX控件的CallFunction()方法调用它。
Python只能调用ExternalInterface类注册函数中的ActionScript代码，而不能调用任何其它ActionScript代码。
向ExternalInterface类注册ActionScript函数的方法，如下所示：
{{{
function callMe(name:String):String
{
return "busy signal";
}
ExternalInterface.addCallback("myFunction", callMe);}}}
ExternalInterface.addCallback()方法采用两个参数。第一个参数为 String 类型的函数名，这是告诉Python端调用的函数名。第二个参数为Flash端实际ActionScript函数。
由于这些名称是截然不同的，因此可以指定将由Python使用的函数名与实际的ActionScript函数具有不同的名称。这在函数名未知的情况下特别有用，例如：指定了匿名函数或需要在运行时确定要调用的函数。
===== 从Flash调用Python函数 =====
从Flash调用Python函数实际上是Shockwave Flash ActiveX控件发送了一个控件消息FlashCall，并附带包含有关函数调用信息的XML 格式的字符串。Python将其解析成函数名和参数，并调用相应函数。
我们继续从消息流程上解析这个过程，首先Flash端示例:
{{{
public function sendMessage(message:String):void
{
ExternalInterface.call("newMessage", message); //调用了Python端的newMessage的方法，message是newMessage方法的参数
}}}}
Python端示例：
先建立一个供Flash调用的函数
{{{#!python
def newMessage(self, message):
print message
return message}}}
建立一个函数字典库
{{{#!python
def RegisterCallback(self,name,callback): ##将需要调用的函数注册
if callable(callback):
self.__callbackReg[name]=callback ##和Flash类似，name是Flash端调用的函数名。callback为Python端实际函数。
return True
else:
return False}}}
{{{#!python
self.RegisterCallback("newMessage", newMessage) ##将其注册到__callbackReg中}}}
最后接收Flash消息,处理函数调用
{{{#!python
def OnFlashCall(self, receiveString): ##注册的Activex消息处理函数
receiveString = receiveString.encode('utf-8') ##从Flash控件消息接收的XML字符串
name,args = self.__szr.deserializeCall(receiveString) ##解析成Python函数名和参数
r = self.__callbackReg[name](*args) ##函数字典中注册的函数名
ds = EIDataSerializer()
s = ds.serializeReturn(r) ##返回值打包成XML
self.SetReturnValue(s)
return}}}
这样就可在Flash端调用Python函数了。
以上方法在pythonwin和wxPython中均可使用。