home *** CD-ROM | disk | FTP | other *** search
/ Chip 2004 July / CMCD0704.ISO / Software / Shareware / Comunicatii / jyte / jyte.exe / framework.py < prev    next >
Text File  |  2004-01-29  |  37KB  |  993 lines
  1. """AXScript Client Framework
  2.  
  3.   This module provides a core framework for an ActiveX Scripting client.
  4.   Derived classes actually implement the AX Client itself, including the
  5.   scoping rules, etc.
  6.  
  7.   There are classes defined for the engine itself, and for ScriptItems
  8. """
  9. import sys, string
  10. from win32com.axscript import axscript
  11. import win32com.server.util
  12.  
  13. import win32com.client.connect # Need simple connection point support
  14.  
  15. import win32api, winerror
  16. import pythoncom
  17. import types
  18.  
  19. SCRIPTTEXT_FORCEEXECUTION = -2147483648 # 0x80000000
  20. SCRIPTTEXT_ISEXPRESSION   = 0x00000020
  21. SCRIPTTEXT_ISPERSISTENT = 0x00000040
  22.  
  23. from win32com.server.exception import Exception, IsCOMServerException
  24. import error # ax.client.error
  25.  
  26. state_map = {
  27.     axscript.SCRIPTSTATE_UNINITIALIZED: "SCRIPTSTATE_UNINITIALIZED",
  28.     axscript.SCRIPTSTATE_INITIALIZED: "SCRIPTSTATE_INITIALIZED",
  29.     axscript.SCRIPTSTATE_STARTED: "SCRIPTSTATE_STARTED",
  30.     axscript.SCRIPTSTATE_CONNECTED: "SCRIPTSTATE_CONNECTED",
  31.     axscript.SCRIPTSTATE_DISCONNECTED: "SCRIPTSTATE_DISCONNECTED",
  32.     axscript.SCRIPTSTATE_CLOSED: "SCRIPTSTATE_CLOSED",
  33. }
  34.  
  35. def profile(fn, *args):
  36.     import profile
  37.     prof = profile.Profile()
  38.     try:
  39. # roll on 1.6 :-)        
  40. #        return prof.runcall(fn, *args)
  41.         return apply(prof.runcall, (fn,) + args)
  42.     finally:
  43.         import pstats
  44.         # Damn - really want to send this to Excel!
  45.         #      width, list = pstats.Stats(prof).strip_dirs().get_print_list([])
  46.         pstats.Stats(prof).strip_dirs().sort_stats("time").print_stats()
  47.  
  48. class SafeOutput:
  49.     softspace=1
  50.     def __init__(self, redir=None):
  51.         if redir is None: redir = sys.stdout
  52.         self.redir=redir
  53.     def write(self,message):
  54.         try:
  55.             self.redir.write(message)
  56.         except:
  57.             win32api.OutputDebugString(message)
  58.     def flush(self):
  59.         pass
  60.     def close(self):
  61.         pass
  62.  
  63. # Make sure we have a valid sys.stdout/stderr, otherwise out
  64. # print and trace statements may raise an exception
  65. def MakeValidSysOuts():
  66.     if not isinstance(sys.stdout, SafeOutput):
  67.         sys.stdout = sys.stderr = SafeOutput()
  68.         # and for the sake of working around something I can't understand...
  69.         # prevent keyboard interrupts from killing IIS
  70.         import signal
  71.         def noOp(a,b):
  72.             # it would be nice to get to the bottom of this, so a warning to
  73.             # the debug console can't hurt.
  74.             print "WARNING: Ignoring keyboard interrupt from ActiveScripting engine"
  75.         # If someone else has already redirected, then assume they know what they are doing!
  76.         if signal.getsignal(signal.SIGINT) == signal.default_int_handler:
  77.             try:
  78.                 signal.signal(signal.SIGINT, noOp)
  79.             except ValueError:
  80.                 # Not the main thread - can't do much.
  81.                 pass
  82.  
  83. def trace(*args):
  84.     """A function used instead of "print" for debugging output.
  85.     """
  86.     for arg in args:
  87.         print arg,
  88.     print
  89.  
  90. def RaiseAssert(scode, desc):
  91.     """A debugging function that raises an exception considered an "Assertion".
  92.     """
  93.     print "**************** ASSERTION FAILED *******************"
  94.     print desc
  95.     raise Exception(scode, desc)
  96.  
  97. class AXScriptCodeBlock:
  98.     """An object which represents a chunk of code in an AX Script
  99.     """
  100.     def __init__(self, name, codeText, sourceContextCookie, startLineNumber, flags):
  101.         self.name = name
  102.         self.codeText = codeText
  103.         self.codeObject = None
  104.         self.sourceContextCookie = sourceContextCookie
  105.         self.startLineNumber = startLineNumber
  106.         self.flags = flags
  107.         self.beenExecuted = 0
  108.     def GetFileName(self):
  109.         # Gets the "file name" for Python - uses <...> so Python doesnt think
  110.         # it is a real file.
  111.         return "<%s>" % self.name
  112.     def GetDisplayName(self):
  113.         return self.name
  114.     def GetLineNo(self, no):
  115.         pos = -1
  116.         for i in range(no-1):
  117.             pos = string.find(self.codeText, '\n', pos+1)
  118.             if pos==-1: pos=len(self.codeText)
  119.         epos = string.find(self.codeText, '\n', pos+1)
  120.         if epos==-1:
  121.             epos=len(self.codeText)
  122.         return string.strip(self.codeText[pos+1:epos])
  123.  
  124. class Event:
  125.     """A single event for a ActiveX named object.
  126.     """
  127.     def __init__(self):
  128.         self.name = "<None>"
  129.     def __repr__(self):
  130.         return "<%s at %d: %s>" % (self.__class__.__name__, id(self), self.name)
  131.     def Reset(self):
  132.         pass
  133.     def Close(self):
  134.         pass
  135.     def Build(self, typeinfo, funcdesc):
  136.         self.dispid = funcdesc[0]
  137.         self.name = typeinfo.GetNames(self.dispid)[0]
  138. #        print "Event.Build() - Event Name is ", self.name
  139.  
  140. class EventSink:
  141.     """A set of events against an item.  Note this is a COM client for connection points.
  142.     """
  143.     _public_methods_ = []
  144.     def __init__(self, myItem, coDispatch):
  145.         self.events = {}
  146.         self.connection = None
  147.         self.coDispatch = coDispatch
  148.         self.myScriptItem = myItem
  149.         self.myInvokeMethod = myItem.GetEngine().ProcessScriptItemEvent
  150.         self.iid = None
  151.     def Reset(self):
  152.         self.Disconnect()
  153.     def Close(self):
  154.         self.iid = None
  155.         self.myScriptItem = None
  156.         self.myInvokeMethod = None
  157.         self.coDispatch = None
  158.         for event in self.events.values():
  159.             event.Reset()
  160.         self.events = {}
  161.         self.Disconnect()
  162.     # COM Connection point methods.
  163.     def _query_interface_(self, iid):
  164.         if iid==self.iid:
  165.             return win32com.server.util.wrap(self)
  166.     def _invoke_(self, dispid, lcid, wFlags, args):
  167.         try:
  168.             event = self.events[dispid]
  169.         except:
  170.             raise Exception(scode=winerror.DISP_E_MEMBERNOTFOUND)
  171.         #print "Invoke for ", event, "on", self.myScriptItem, " - calling",  self.myInvokeMethod
  172.         return self.myInvokeMethod(self.myScriptItem, event, lcid, wFlags, args)
  173.  
  174.     def GetSourceTypeInfo(self, typeinfo):
  175.         """Gets the typeinfo for the Source Events for the passed typeinfo"""
  176.         attr = typeinfo.GetTypeAttr()
  177.         cFuncs = attr[6]
  178.         typeKind = attr[5]
  179.         if typeKind not in [pythoncom.TKIND_COCLASS, pythoncom.TKIND_INTERFACE]:
  180.             RaiseAssert(winerror.E_UNEXPECTED, "The typeKind of the object is unexpected")
  181.         cImplType = attr[8]
  182.         for i in xrange(cImplType):
  183.             # Look for the [source, default] interface on the coclass
  184.             # that isn't marked as restricted.
  185.             flags = typeinfo.GetImplTypeFlags(i)
  186.             flagsNeeded = pythoncom.IMPLTYPEFLAG_FDEFAULT | pythoncom.IMPLTYPEFLAG_FSOURCE
  187.             if (flags & ( flagsNeeded | pythoncom.IMPLTYPEFLAG_FRESTRICTED))==(flagsNeeded):
  188.                 # Get the handle to the implemented interface.
  189.                 href = typeinfo.GetRefTypeOfImplType(i)
  190.                 return typeinfo.GetRefTypeInfo(href)
  191.  
  192.     def BuildEvents(self):
  193.         # See if it is an extender object.
  194.         try:
  195.             mainTypeInfo = self.coDispatch.QueryInterface(axscript.IID_IProvideMultipleClassInfo)
  196.             isMulti = 1
  197.             numTypeInfos = mainTypeInfo.GetMultiTypeInfoCount()
  198.         except pythoncom.com_error:
  199.             isMulti = 0
  200.             numTypeInfos = 1
  201.             try:
  202.                 mainTypeInfo = self.coDispatch.QueryInterface(pythoncom.IID_IProvideClassInfo)
  203.             except pythoncom.com_error:
  204.                 numTypeInfos = 0
  205.         # Create an event handler for the item.
  206.         for item in xrange(numTypeInfos):
  207.             if isMulti:
  208.                 typeinfo, flags = mainTypeInfo.GetInfoOfIndex(item, axscript.MULTICLASSINFO_GETTYPEINFO)
  209.             else:
  210.                 typeinfo = mainTypeInfo.GetClassInfo()
  211.             sourceType = self.GetSourceTypeInfo(typeinfo)
  212.             cFuncs = 0
  213.             if sourceType:
  214.                 attr = sourceType.GetTypeAttr()
  215.                 self.iid = attr[0]
  216.                 cFuncs = attr[6]
  217.                 for i in xrange(cFuncs):
  218.                     funcdesc = sourceType.GetFuncDesc(i)
  219.                     event = Event()
  220.                     event.Build(sourceType, funcdesc)
  221.                     self.events[event.dispid] = event
  222.  
  223.     def Connect(self):
  224.         if self.connection is not None or self.iid is None: return
  225. #        trace("Connect for sink item", self.myScriptItem.name, "with IID",str(self.iid))
  226.         self.connection = win32com.client.connect.SimpleConnection(self.coDispatch, self, self.iid)
  227.     def Disconnect(self):
  228.         if self.connection:
  229.             try:
  230.                 self.connection.Disconnect()
  231.             except pythoncom.com_error:
  232.                 pass # Ignore disconnection errors.
  233.             self.connection = None
  234.  
  235. class ScriptItem:
  236.     """An item (or subitem) that is exposed to the ActiveX script
  237.     """
  238.     def __init__(self, parentItem, name, dispatch, flags):
  239.         self.parentItem = parentItem
  240.         self.dispatch = dispatch
  241.         self.name = name
  242.         self.flags = flags
  243.         self.eventSink = None
  244.         self.subItems = {}
  245.         self.createdConnections = 0
  246.         self.isRegistered = 0
  247. #        trace("Creating ScriptItem", name, "of parent", parentItem,"with dispatch", dispatch)
  248.  
  249.     def __repr__(self):
  250.         flagsDesc=""
  251.         if self.flags is not None and self.flags & axscript.SCRIPTITEM_GLOBALMEMBERS:
  252.             flagsDesc = "/Global"
  253.         return "<%s at %d: %s%s>" % (self.__class__.__name__, id(self), self.name,flagsDesc)
  254.  
  255.     def _dump_(self, level):
  256.         flagDescs = []
  257.         if self.flags is not None and self.flags & axscript.SCRIPTITEM_GLOBALMEMBERS:
  258.             flagDescs.append("GLOBAL!")
  259.         if self.flags is None or self.flags & axscript.SCRIPTITEM_ISVISIBLE == 0:
  260.             flagDescs.append("NOT VISIBLE")
  261.         if self.flags is not None and self.flags & axscript.SCRIPTITEM_ISSOURCE:
  262.             flagDescs.append("EVENT SINK")
  263.         if self.flags is not None and self.flags & axscript.SCRIPTITEM_CODEONLY:
  264.             flagDescs.append("CODE ONLY")
  265.         print " " * level, "Name=", self.name, ", flags=", "/".join(flagDescs), self
  266.         for subItem in self.subItems.values():
  267.             subItem._dump_(level+1)
  268.  
  269.     def Reset(self):
  270.         self.Disconnect()
  271.         if self.eventSink:
  272.             self.eventSink.Reset()
  273.         self.isRegistered = 0
  274.         for subItem in self.subItems.values():
  275.             subItem.Reset()
  276.  
  277.     def Close(self):
  278.         self.Reset()
  279.         self.dispatch = None
  280.         self.parentItem = None
  281.         if self.eventSink:
  282.             self.eventSink.Close()
  283.             self.eventSink = None
  284.         for subItem in self.subItems.values():
  285.             subItem.Close()
  286.         self.subItems = []
  287.         self.createdConnections = 0
  288.  
  289.     def Register(self):
  290.         if self.isRegistered: return
  291.         # Get the type info to use to build this item.
  292. #        if not self.dispatch:
  293. #            id = self.parentItem.dispatch.GetIDsOfNames(self.name)
  294. #            print "DispID of me is", id
  295. #            result = self.parentItem.dispatch.Invoke(id, 0, pythoncom.DISPATCH_PROPERTYGET,1)
  296. #            if type(result)==pythoncom.TypeIIDs[pythoncom.IID_IDispatch]:
  297. #                self.dispatch = result
  298. #            else:
  299. #                print "*** No dispatch"
  300. #                return
  301. #            print "**** Made dispatch"
  302.         self.isRegistered = 1
  303.         # Register the sub-items.                
  304.         for item in self.subItems.values():
  305.             if not item.isRegistered:
  306.                 item.Register()
  307.  
  308.     def IsGlobal(self):
  309.         return self.flags & axscript.SCRIPTITEM_GLOBALMEMBERS
  310.  
  311.     def IsVisible(self):
  312.         return (self.flags & (axscript.SCRIPTITEM_ISVISIBLE | axscript.SCRIPTITEM_ISSOURCE)) != 0
  313.  
  314.     def GetEngine(self):
  315.         item = self
  316.         while item.parentItem.__class__==self.__class__:
  317.             item = item.parentItem
  318.         return item.parentItem
  319.  
  320.     def _GetFullItemName(self):
  321.         ret = self.name
  322.         if self.parentItem:
  323.             try:
  324.                 ret = self.parentItem._GetFullItemName() + "." + ret
  325.             except AttributeError:
  326.                 pass
  327.         return ret
  328.     
  329.     def GetSubItemClass(self):
  330.         return self.__class__
  331.  
  332.     def GetSubItem(self, name):
  333.         return self.subItems[string.lower(name)]
  334.  
  335.     def GetCreateSubItem(self, parentItem, name, dispatch, flags):
  336.         keyName = string.lower(name)
  337.         try:
  338.             rc = self.subItems[keyName]
  339.             # No changes allowed to existing flags.
  340.             if not rc.flags is None and not flags is None and rc.flags != flags:
  341.                 raise Exception(scode=winerror.E_INVALIDARG)
  342.             # Existing item must not have a dispatch.
  343.             if not rc.dispatch is None and not dispatch is None:
  344.                 raise Exception(scode=winerror.E_INVALIDARG)
  345.             rc.flags = flags # Setup the real flags.
  346.             rc.dispatch = dispatch
  347.         except KeyError:
  348.             rc = self.subItems[keyName] = self.GetSubItemClass()(parentItem, name, dispatch, flags)
  349.         return rc
  350. #        if self.dispatch is None: 
  351. #            RaiseAssert(winerror.E_UNEXPECTED, "??")
  352.  
  353.     def CreateConnections(self):
  354.         # Create (but do not connect to) the connection points.
  355.         if self.createdConnections: return
  356.         self.createdConnections = 1
  357.         # Nothing to do unless this is an event source
  358.         # This flags means self, _and_ children, are connectable.
  359.         if self.flags & axscript.SCRIPTITEM_ISSOURCE:
  360.             self.BuildEvents()
  361.             self.FindBuildSubItemEvents()
  362.  
  363.     def Connect(self):
  364.         # Connect to the already created connection points.
  365.         if self.eventSink:
  366.             self.eventSink.Connect()
  367.         for subItem in self.subItems.values():
  368.             subItem.Connect()
  369.             
  370.     def Disconnect(self):
  371.         # Disconnect from the connection points.
  372.         if self.eventSink:
  373.             self.eventSink.Disconnect()
  374.         for subItem in self.subItems.values():
  375.             subItem.Disconnect()
  376.  
  377.  
  378.     def BuildEvents(self):
  379.         if self.eventSink is not None or self.dispatch is None:
  380.             RaiseAssert(winerror.E_UNEXPECTED, "Item already has built events, or no dispatch available?")
  381.         
  382. #        trace("BuildEvents for named item", self._GetFullItemName())
  383.         self.eventSink = EventSink(self, self.dispatch)
  384.         self.eventSink.BuildEvents()
  385.  
  386.     def FindBuildSubItemEvents(self):
  387.         # Called during connection to event source.  Seeks out and connects to
  388.         # all children.  As per the AX spec, this is not recursive
  389.         # (ie, children sub-items are not seeked)
  390.         try:
  391.             multiTypeInfo = self.dispatch.QueryInterface(axscript.IID_IProvideMultipleClassInfo)
  392.             numTypeInfos = multiTypeInfo.GetMultiTypeInfoCount()
  393.         except pythoncom.com_error:
  394.             return
  395.         for item in xrange(numTypeInfos):
  396.             typeinfo, flags = multiTypeInfo.GetInfoOfIndex(item, axscript.MULTICLASSINFO_GETTYPEINFO)
  397.             defaultType = self.GetDefaultSourceTypeInfo(typeinfo)
  398.             index = 0
  399.             while 1:
  400.                 try:
  401.                     fdesc = defaultType.GetFuncDesc(index)
  402.                 except pythoncom.com_error:
  403.                     break # No more funcs
  404.                 index = index + 1
  405.                 dispid = fdesc[0]
  406.                 funckind = fdesc[3]
  407.                 invkind = fdesc[4]
  408.                 elemdesc = fdesc[8]
  409.                 funcflags = fdesc[9]
  410.                 try:
  411.                     isSubObject = not (funcflags & pythoncom.FUNCFLAG_FRESTRICTED) and \
  412.                         funckind == pythoncom.FUNC_DISPATCH and \
  413.                         invkind  == pythoncom.INVOKE_PROPERTYGET and \
  414.                         elemdesc[0][0] == pythoncom.VT_PTR and \
  415.                         elemdesc[0][1][0] == pythoncom.VT_USERDEFINED
  416.                 except:
  417.                     isSubObject = 0
  418.                 if isSubObject:
  419.                         try:
  420.                             # We found a sub-object.
  421.                             names = typeinfo.GetNames(dispid);
  422.                             result = self.dispatch.Invoke(dispid, 0x0, pythoncom.DISPATCH_PROPERTYGET, 1)
  423.                             # IE has an interesting problem - there are lots of synonyms for the same object.  Eg
  424.                             # in a simple form, "window.top", "window.window", "window.parent", "window.self"
  425.                             # all refer to the same object.  Our event implementation code does not differentiate
  426.                             # eg, "window_onload" will fire for *all* objects named "window".  Thus,
  427.                             # "window" and "window.window" will fire the same event handler :(
  428.                             # One option would be to check if the sub-object is indeed the
  429.                             # parent object - however, this would stop "top_onload" from firing,
  430.                             # as no event handler for "top" would work.
  431.                             # I think we simply need to connect to a *single* event handler.
  432.                             # As use in IE is deprecated, I am not solving this now.
  433.                             if type(result)==pythoncom.TypeIIDs[pythoncom.IID_IDispatch]:
  434.                                 name = names[0]
  435.                                 subObj = self.GetCreateSubItem(self, name, result, axscript.SCRIPTITEM_ISVISIBLE)
  436.                                 #print "subobj", name, "flags are", subObj.flags, "mydisp=", self.dispatch, "result disp=", result, "compare=", self.dispatch==result
  437.                                 subObj.BuildEvents()
  438.                                 subObj.Register()
  439.                         except pythoncom.com_error:
  440.                             pass
  441.  
  442.     def GetDefaultSourceTypeInfo(self, typeinfo):
  443.         """Gets the typeinfo for the Default Dispatch for the passed typeinfo"""
  444.         attr = typeinfo.GetTypeAttr()
  445.         cFuncs = attr[6]
  446.         typeKind = attr[5]
  447.         if typeKind not in [pythoncom.TKIND_COCLASS, pythoncom.TKIND_INTERFACE]:
  448.             RaiseAssert(winerror.E_UNEXPECTED, "The typeKind of the object is unexpected")
  449.         cImplType = attr[8]
  450.         for i in xrange(cImplType):
  451.             # Look for the [source, default] interface on the coclass
  452.             # that isn't marked as restricted.
  453.             flags = typeinfo.GetImplTypeFlags(i)
  454.             if (flags & ( pythoncom.IMPLTYPEFLAG_FDEFAULT | pythoncom.IMPLTYPEFLAG_FSOURCE | pythoncom.IMPLTYPEFLAG_FRESTRICTED))==pythoncom.IMPLTYPEFLAG_FDEFAULT:
  455.                 # Get the handle to the implemented interface.
  456.                 href = typeinfo.GetRefTypeOfImplType(i)
  457.                 defTypeInfo = typeinfo.GetRefTypeInfo(href)
  458.                 attr = defTypeInfo.GetTypeAttr()
  459.                 typeKind = attr[5]
  460.                 typeFlags = attr[11]
  461.                 if typeKind == pythoncom.TKIND_INTERFACE and typeFlags & pythoncom.TYPEFLAG_FDUAL:
  462.                     # Get corresponding Disp interface
  463.                     # -1 is a special value which does this for us.
  464.                     href = typeinfo.GetRefTypeOfImplType(-1)
  465.                     return defTypeInfo.GetRefTypeInfo(href)
  466.                 else:
  467.                     return defTypeInfo
  468.  
  469.  
  470. IActiveScriptMethods = [
  471.    "SetScriptSite", "GetScriptSite", "SetScriptState", "GetScriptState",
  472.    "Close", "AddNamedItem", "AddTypeLib", "GetScriptDispatch",
  473.    "GetCurrentScriptThreadID", "GetScriptThreadID", "GetScriptThreadState",
  474.    "InterruptScriptThread", "Clone" ]
  475. IActiveScriptParseMethods = [
  476.    "InitNew", "AddScriptlet", "ParseScriptText" ]
  477. IObjectSafetyMethods = [
  478.    "GetInterfaceSafetyOptions", "SetInterfaceSafetyOptions"]
  479.  
  480. # ActiveScriptParseProcedure is a new interface with IIS4/IE4.
  481. IActiveScriptParseProcedureMethods = ['ParseProcedureText']
  482. class COMScript:
  483.     """An ActiveX Scripting engine base class.
  484.  
  485.     This class implements the required COM interfaces for ActiveX scripting.
  486.     """
  487.     _public_methods_ = IActiveScriptMethods + IActiveScriptParseMethods + IObjectSafetyMethods + IActiveScriptParseProcedureMethods
  488.     _com_interfaces_ = [axscript.IID_IActiveScript, axscript.IID_IActiveScriptParse, axscript.IID_IObjectSafety] #, axscript.IID_IActiveScriptParseProcedure]
  489.  
  490.     def __init__(self):
  491.         # Make sure we can print/trace wihout an exception!
  492.         MakeValidSysOuts()
  493. #        trace("AXScriptEngine object created", self)
  494.         self.baseThreadId = -1
  495.         self.debugManager = None
  496.         self.threadState = axscript.SCRIPTTHREADSTATE_NOTINSCRIPT
  497.         self.scriptState = axscript.SCRIPTSTATE_UNINITIALIZED
  498.         self.scriptSite = None
  499.         self.safetyOptions = 0
  500.         self.lcid = 0
  501.         self.subItems = {}
  502.         self.scriptCodeBlocks = {}
  503.  
  504.     def _query_interface_(self, iid):
  505.         if self.debugManager:
  506.             return self.debugManager._query_interface_for_debugger_(iid)
  507. #        trace("ScriptEngine QI - unknown IID", iid)
  508.         return 0
  509.  
  510.     # IActiveScriptParse
  511.     def InitNew(self):
  512.         if self.scriptSite is not None:
  513.             self.SetScriptState(axscript.SCRIPTSTATE_INITIALIZED)
  514.  
  515.     def AddScriptlet(self, defaultName, code, itemName, subItemName, eventName, delimiter, sourceContextCookie, startLineNumber):
  516. #        trace ("AddScriptlet", defaultName, code, itemName, subItemName, eventName, delimiter, sourceContextCookie, startLineNumber)
  517.         self.DoAddScriptlet(defaultName, str(code), itemName, subItemName, eventName, delimiter,sourceContextCookie, startLineNumber)
  518.  
  519.     def ParseScriptText(self, code, itemName, context, delimiter, sourceContextCookie, startLineNumber, flags, bWantResult):
  520. #        trace ("ParseScriptText", code[:20],"...", itemName, context, delimiter, sourceContextCookie, startLineNumber, flags, bWantResult)
  521.         if bWantResult or self.scriptState == axscript.SCRIPTSTATE_STARTED \
  522.                 or self.scriptState == axscript.SCRIPTSTATE_CONNECTED \
  523.                 or self.scriptState == axscript.SCRIPTSTATE_DISCONNECTED :
  524.             flags = flags | SCRIPTTEXT_FORCEEXECUTION
  525.         else:
  526.             flags = flags & (~SCRIPTTEXT_FORCEEXECUTION)
  527.  
  528.         if flags & SCRIPTTEXT_FORCEEXECUTION:
  529.             # About to execute the code.
  530.             self.RegisterNewNamedItems()
  531.         return self.DoParseScriptText(str(code), sourceContextCookie, startLineNumber, bWantResult, flags)
  532.  
  533.     #
  534.     # IActiveScriptParseProcedure
  535.     def ParseProcedureText( self, code, formalParams, procName, itemName, unkContext, delimiter, contextCookie, startingLineNumber, flags):
  536.         trace("ParseProcedureText", code, formalParams, procName, itemName, unkContext, delimiter, contextCookie, startingLineNumber, flags)
  537.         # NOTE - this is never called, as we have disabled this interface.
  538.         # Problem is, once enabled all even code comes via here, rather than AddScriptlet.
  539.         # However, the "procName" is always an empty string - ie, itemName is the object whose event we are handling,
  540.         # but no idea what the specific event is!?
  541.         # Problem is disabling this block is that AddScriptlet is _not_ passed
  542.         # <SCRIPT for="whatever" event="onClick" language="Python">
  543.         # (but even for those blocks, the "onClick" information is still missing!?!?!?)
  544.  
  545. #        self.DoAddScriptlet(None, str(code), itemName, subItemName, eventName, delimiter,sourceContextCookie, startLineNumber)
  546.         return None
  547.     #
  548.     # IActiveScript
  549.     def SetScriptSite(self, site):
  550.         # We should still work with an existing site (or so MSXML believes :)
  551.         self.scriptSite = site
  552.         if self.debugManager is not None:
  553.             self.debugManager.Close()
  554.         import traceback
  555.         try:
  556.             import win32com.axdebug.axdebug # see if the core exists.
  557.             import debug
  558.             self.debugManager = debug.DebugManager(self)
  559.         except pythoncom.com_error:
  560.             # COM errors will occur if the debugger interface has never been
  561.             # seen on the target system
  562.             trace("Debugging interfaces not available - debugging is disabled..")
  563.             self.debugManager = None
  564.         except ImportError:
  565.             trace("Debugging extensions (axdebug) module does not exist - debugging is disabled..")
  566.             self.debugManager = None
  567.         except:
  568.             traceback.print_exc()
  569.             trace("*** Debugger Manager could not initialize - %s: %s" % (sys.exc_info()[0],sys.exc_info()[1]))
  570.             self.debugManager = None
  571.  
  572.         try:
  573.             self.lcid = site.GetLCID() 
  574.         except pythoncom.com_error:
  575.             self.lcid = win32api.GetUserDefaultLCID()
  576.         self.Reset()
  577.  
  578.     def GetScriptSite(self, iid):
  579.         if self.scriptSite is None: raise Exception(scode=winerror.S_FALSE)
  580.         return self.scriptSite.QueryInterface(iid)
  581.  
  582.     def SetScriptState(self, state):
  583.         #print "SetScriptState with %s - currentstate = %s" % (state_map.get(state),state_map.get(self.scriptState))
  584.         if state == self.scriptState: return
  585.         # If closed, allow no other state transitions
  586.         if self.scriptState==axscript.SCRIPTSTATE_CLOSED:
  587.             raise Exception(scode=winerror.E_INVALIDARG)
  588.  
  589.         if state==axscript.SCRIPTSTATE_INITIALIZED:
  590.             # Re-initialize - shutdown then reset.
  591.             if self.scriptState in [axscript.SCRIPTSTATE_CONNECTED, axscript.SCRIPTSTATE_STARTED]:
  592.                 self.Stop()
  593.         elif state==axscript.SCRIPTSTATE_STARTED:
  594.             if self.scriptState == axscript.SCRIPTSTATE_CONNECTED:
  595.                 self.Disconnect()
  596.             if self.scriptState == axscript.SCRIPTSTATE_DISCONNECTED:
  597.                 self.Reset()
  598.             self.Run()
  599.             self.ChangeScriptState(axscript.SCRIPTSTATE_STARTED)
  600.         elif state==axscript.SCRIPTSTATE_CONNECTED:
  601.             if self.scriptState in [axscript.SCRIPTSTATE_UNINITIALIZED,axscript.SCRIPTSTATE_INITIALIZED]:
  602.                 self.ChangeScriptState(axscript.SCRIPTSTATE_STARTED) # report transition through started
  603.                 self.Run()
  604.             if self.scriptState == axscript.SCRIPTSTATE_STARTED:
  605.                 self.Connect()
  606.                 self.ChangeScriptState(state)
  607.         elif state==axscript.SCRIPTSTATE_DISCONNECTED:
  608.             if self.scriptState == axscript.SCRIPTSTATE_CONNECTED:
  609.                 self.Disconnect()
  610.         elif state==axscript.SCRIPTSTATE_CLOSED:
  611.             self.Close()
  612.         elif state==axscript.SCRIPTSTATE_UNINITIALIZED:
  613.             if self.scriptState == axscript.SCRIPTSTATE_STARTED:
  614.                 self.Stop()
  615.             if self.scriptState == axscript.SCRIPTSTATE_CONNECTED:
  616.                 self.Disconnect()
  617.             if self.scriptState == axscript.SCRIPTSTATE_DISCONNECTED:
  618.                 self.Reset()
  619.             self.ChangeScriptState(state)
  620.         else:
  621.             raise Exception(scode=winerror.E_INVALIDARG)
  622.  
  623.     def GetScriptState(self):
  624.         return self.scriptState
  625.  
  626.     def Close(self):
  627. #        trace("Close")
  628.         if self.scriptState in [axscript.SCRIPTSTATE_CONNECTED, axscript.SCRIPTSTATE_DISCONNECTED]:
  629.             self.Stop()
  630.         if self.scriptState in [axscript.SCRIPTSTATE_CONNECTED, axscript.SCRIPTSTATE_DISCONNECTED, axscript.SCRIPTSTATE_INITIALIZED, axscript.SCRIPTSTATE_STARTED]:
  631.             pass # engine.close??
  632.         if self.scriptState in [axscript.SCRIPTSTATE_UNINITIALIZED, axscript.SCRIPTSTATE_CONNECTED, axscript.SCRIPTSTATE_DISCONNECTED, axscript.SCRIPTSTATE_INITIALIZED, axscript.SCRIPTSTATE_STARTED]:
  633.             self.ChangeScriptState(axscript.SCRIPTSTATE_CLOSED)
  634.             # Completely reset all named items (including persistent)
  635.             for item in self.subItems.values():
  636.                 item.Close()
  637.             self.subItems = {}
  638.             self.baseThreadId = -1
  639.         if self.debugManager:
  640.             self.debugManager.Close()
  641.             self.debugManager = None
  642.         self.scriptSite = None
  643.         self.scriptCodeBlocks = {}
  644.         self.persistLoaded = 0
  645.  
  646.     def AddNamedItem(self, name, flags):
  647.         if self.scriptSite is None: raise Exception(scode=winerror.E_INVALIDARG)
  648.         name = str(name) # Convert from Unicode.
  649.         try:
  650.             unknown = self.scriptSite.GetItemInfo(name, axscript.SCRIPTINFO_IUNKNOWN)[0]
  651.             dispatch = unknown.QueryInterface(pythoncom.IID_IDispatch)
  652.         except pythoncom.com_error:
  653.             raise Exception(scode=winerror.E_NOINTERFACE, desc="Object has no dispatch interface available.")
  654.         newItem = self.subItems[name] = self.GetNamedItemClass()(self, name, dispatch, flags)
  655.         if newItem.IsGlobal():
  656.             newItem.CreateConnections()
  657.  
  658.     def GetScriptDispatch(self, name):
  659.         # Base classes should override.
  660.         raise Exception(scode=winerror.E_NOTIMPL)
  661.  
  662.     def GetCurrentScriptThreadID(self):
  663.         return self.baseThreadId
  664.  
  665.     def GetScriptThreadID(self, win32ThreadId):
  666.         if self.baseThreadId == -1:
  667.             raise Exception(scode=winerror.E_UNEXPECTED)
  668.         if self.baseThreadId != win32ThreadId:
  669.             raise Exception(scode=winerror.E_INVALIDARG)
  670.         return self.baseThreadId
  671.  
  672.     def GetScriptThreadState(self, scriptThreadId):
  673.         if self.baseThreadId == -1:
  674.             raise Exception(scode=winerror.E_UNEXPECTED)
  675.         if scriptThreadId != self.baseThreadId:
  676.             raise Exception(scode=winerror.E_INVALIDARG)
  677.         return self.threadState
  678.  
  679.     def AddTypeLib(self, uuid, major, minor, flags):
  680.         # Get the win32com gencache to register this library.
  681.         from win32com.client import gencache
  682.         gencache.EnsureModule(uuid, self.lcid, major, minor, bForDemand = 1)
  683.  
  684.     def InterruptScriptThread(self, state, flags):
  685.         raise Exception("Not Implemented", scode=winerror.E_NOTIMPL)
  686.  
  687.     def Clone(self):
  688.         raise Exception("Not Implemented", scode=winerror.E_NOTIMPL)
  689.     #
  690.     # IObjectSafety
  691.  
  692.     # Note that IE seems to insist we say we support all the flags, even tho
  693.     # we dont accept them all.  If unknown flags come in, they are ignored, and never
  694.     # reflected in GetInterfaceSafetyOptions and the QIs obviously fail, but still IE
  695.     # allows our engine to initialize.
  696.     def SetInterfaceSafetyOptions(self, iid, optionsMask, enabledOptions):
  697. #        trace ("SetInterfaceSafetyOptions", iid, optionsMask, enabledOptions)
  698.         if optionsMask & enabledOptions == 0:
  699.             return
  700.  
  701. # See comments above.
  702. #        if (optionsMask & enabledOptions & \
  703. #            ~(axscript.INTERFACESAFE_FOR_UNTRUSTED_DATA | axscript.INTERFACESAFE_FOR_UNTRUSTED_CALLER)):
  704. #            # request for options we don't understand
  705. #            RaiseAssert(scode=winerror.E_FAIL, desc="Unknown safety options")
  706.  
  707.         if iid in [pythoncom.IID_IPersist, pythoncom.IID_IPersistStream, pythoncom.IID_IPersistStreamInit,
  708.                     axscript.IID_IActiveScript, axscript.IID_IActiveScriptParse]:
  709.             supported = self._GetSupportedInterfaceSafetyOptions()
  710.             self.safetyOptions = supported & optionsMask & enabledOptions
  711.         else:
  712.             raise Exception(scode=winerror.E_NOINTERFACE)
  713.  
  714.     def _GetSupportedInterfaceSafetyOptions(self):
  715.         return 0 
  716.  
  717.     def GetInterfaceSafetyOptions(self, iid):
  718.         if iid in [pythoncom.IID_IPersist, pythoncom.IID_IPersistStream, pythoncom.IID_IPersistStreamInit,
  719.                     axscript.IID_IActiveScript, axscript.IID_IActiveScriptParse]:
  720.             supported = self._GetSupportedInterfaceSafetyOptions()
  721.             return supported, self.safetyOptions
  722.         else:
  723.             raise Exception(scode=winerror.E_NOINTERFACE)
  724.     #
  725.     # Other helpers.
  726.     def ExecutePendingScripts(self):
  727.         self.RegisterNewNamedItems()
  728.         self.DoExecutePendingScripts()
  729.  
  730.     def ProcessScriptItemEvent(self, item, event, lcid, wFlags, args):
  731. #        trace("ProcessScriptItemEvent", item, event, lcid, wFlags, args)
  732.         self.RegisterNewNamedItems()
  733.         return self.DoProcessScriptItemEvent(item, event, lcid, wFlags, args)
  734.  
  735.     def _DumpNamedItems_(self):
  736.         for item in self.subItems.values():
  737.             item._dump_(0)
  738.  
  739.     def ResetNamedItems(self):
  740.         # Due to the way we work, we re-create persistent ones.
  741.         si = self.subItems.items()
  742.         self.subItems = {}
  743.         for name, item in si:
  744.             item.Close()
  745.             if item.flags & axscript.SCRIPTITEM_ISPERSISTENT:
  746.                 self.AddNamedItem(item.name, item.flags)
  747.  
  748.     def GetCurrentSafetyOptions(self):
  749.         return self.safetyOptions
  750.     def ProcessNewNamedItemsConnections(self):
  751.         # Process all sub-items.
  752.         for item in self.subItems.values():
  753.             if not item.createdConnections: # Fast-track!
  754.                 item.CreateConnections()
  755.  
  756.     def RegisterNewNamedItems(self):
  757.         # Register all sub-items.
  758.         for item in self.subItems.values():
  759.             if not item.isRegistered: # Fast-track!
  760.                 self.RegisterNamedItem(item)
  761.  
  762.     def RegisterNamedItem(self, item):
  763.         item.Register()
  764.  
  765.     def CheckConnectedOrDisconnected(self):
  766.         if self.scriptState in [axscript.SCRIPTSTATE_CONNECTED, axscript.SCRIPTSTATE_DISCONNECTED]:
  767.             return
  768.         RaiseAssert(winerror.E_UNEXPECTED, "Not connected or disconnected - %d" % self.scriptState)
  769.  
  770.     def Connect(self):
  771.         self.ProcessNewNamedItemsConnections()
  772.         self.RegisterNewNamedItems()
  773.         self.ConnectEventHandlers()
  774.  
  775.     def Run(self):
  776. #        trace("AXScript running...")
  777.         if self.scriptState != axscript.SCRIPTSTATE_INITIALIZED and self.scriptState != axscript.SCRIPTSTATE_STARTED:
  778.             raise Exception(scode=winerror.E_UNEXPECTED)
  779. #        self._DumpNamedItems_()
  780.         self.ExecutePendingScripts()
  781.         self.DoRun()
  782.  
  783.     def Stop(self):
  784.         # Stop all executing scripts, and disconnect.
  785.         if self.scriptState == axscript.SCRIPTSTATE_CONNECTED:
  786.             self.Disconnect()
  787.         # Reset back to initialized.
  788.         self.Reset()
  789.  
  790.     def Disconnect(self):
  791.         self.CheckConnectedOrDisconnected()
  792.         try:
  793.             self.DisconnectEventHandlers()
  794.         except pythoncom.com_error:
  795.             # Ignore errors when disconnecting.
  796.             pass 
  797.  
  798.         self.ChangeScriptState(axscript.SCRIPTSTATE_DISCONNECTED)
  799.  
  800.     def ConnectEventHandlers(self):
  801. #        trace ("Connecting to event handlers")
  802.         for item in self.subItems.values():
  803.             item.Connect()
  804.         self.ChangeScriptState(axscript.SCRIPTSTATE_CONNECTED);
  805.  
  806.     def DisconnectEventHandlers(self):
  807. #        trace ("Disconnecting from event handlers")
  808.         for item in self.subItems.values():
  809.             item.Disconnect()
  810.  
  811.     def Reset(self):
  812.         # Keeping persistent engine state, reset back an initialized state
  813.         self.ResetNamedItems()
  814.         self.ChangeScriptState(axscript.SCRIPTSTATE_INITIALIZED)
  815.  
  816.     def ChangeScriptState(self, state):
  817.         #print "  ChangeScriptState with %s - currentstate = %s" % (state_map.get(state),state_map.get(self.scriptState))
  818.         self.DisableInterrupts()
  819.         try:
  820.             self.scriptState = state
  821.             try:
  822.                 if self.scriptSite: self.scriptSite.OnStateChange(state)
  823.             except pythoncom.com_error, (hr, desc, exc, arg):
  824.                 pass # Ignore all errors here - E_NOTIMPL likely from scriptlets.
  825.         finally:
  826.             self.EnableInterrupts()
  827.  
  828.     # This stack frame is debugged - therefore we do as little as possible in it.
  829.     def _ApplyInScriptedSection(self, fn, args):
  830.         if self.debugManager: self.debugManager.OnEnterScript()
  831.         return apply(fn, args)
  832.     
  833.     def ApplyInScriptedSection(self, codeBlock, fn, args):
  834.         self.BeginScriptedSection()
  835.         try:
  836.             try:
  837. #                print "ApplyInSS", codeBlock, fn, args
  838.                 return self._ApplyInScriptedSection(fn, args)
  839.             finally:
  840.                 if self.debugManager: self.debugManager.OnLeaveScript()
  841.                 self.EndScriptedSection()
  842.         except:
  843.             self.HandleException(codeBlock)
  844.             
  845.     # This stack frame is debugged - therefore we do as little as possible in it.
  846.     def _CompileInScriptedSection(self, code, name, type):
  847.         if self.debugManager: self.debugManager.OnEnterScript()
  848.         return compile(code, name, type)
  849.  
  850.     def CompileInScriptedSection(self, codeBlock, type, realCode = None):
  851.         if codeBlock.codeObject is not None: # already compiled
  852.             return 1
  853.         if realCode is None:
  854.             code = codeBlock.codeText
  855.         else:
  856.             code = realCode
  857.         name = codeBlock.GetFileName()
  858.         self.BeginScriptedSection()
  859.         try:
  860.             try:
  861.                 codeObject = self._CompileInScriptedSection(code, name, type)
  862.                 codeBlock.codeObject = codeObject
  863.                 return 1
  864.             finally:
  865.                 if self.debugManager: self.debugManager.OnLeaveScript()
  866.                 self.EndScriptedSection()
  867.         except:
  868.             self.HandleException(codeBlock)
  869.     
  870.     # This stack frame is debugged - therefore we do as little as possible in it.
  871.     def _ExecInScriptedSection(self, codeObject, globals, locals = None):
  872.         if self.debugManager: self.debugManager.OnEnterScript()
  873.         exec codeObject in globals, locals
  874.  
  875.     def ExecInScriptedSection(self, codeBlock, globals, locals = None):
  876.         if locals is None: locals = globals
  877.         assert not codeBlock.beenExecuted, "This code block should not have been executed"
  878.         codeBlock.beenExecuted = 1
  879.         self.BeginScriptedSection()
  880.         try:
  881.             try:
  882.                 self._ExecInScriptedSection(codeBlock.codeObject, globals, locals)
  883.             finally:
  884.                 if self.debugManager: self.debugManager.OnLeaveScript()
  885.                 self.EndScriptedSection()
  886.         except:
  887.             self.HandleException(codeBlock)
  888.  
  889.     def _EvalInScriptedSection(self, codeBlock, globals, locals = None):
  890.         if self.debugManager: self.debugManager.OnEnterScript()
  891.         return eval(codeBlock, globals, locals)
  892.         
  893.     def EvalInScriptedSection(self, codeBlock, globals, locals = None):
  894.         if locals is None: locals = globals
  895.         assert not codeBlock.beenExecuted, "This code block should not have been executed"
  896.         codeBlock.beenExecuted = 1
  897.         self.BeginScriptedSection()
  898.         try:
  899.             try:
  900.                 return self._EvalInScriptedSection(codeBlock.codeObject, globals, locals)
  901.             finally:
  902.                 if self.debugManager: self.debugManager.OnLeaveScript()
  903.                 self.EndScriptedSection()
  904.         except:
  905.             self.HandleException(codeBlock)
  906.  
  907.     def HandleException(self, codeBlock):
  908.         # NOTE - Never returns - raises a ComException
  909.         exc_type, exc_value, exc_traceback = sys.exc_info()
  910.         # If a SERVER exception, re-raise it.  If a client side COM error, it is
  911.         # likely to have originated from the script code itself, and therefore
  912.         # needs to be reported like any other exception.
  913.         if IsCOMServerException(exc_type):
  914.             # Ensure the traceback doesnt cause a cycle.
  915.             exc_traceback = None
  916.             raise
  917.         # It could be an error by another script.
  918.         if issubclass(pythoncom.com_error, exc_type) and exc_value[0]==axscript.SCRIPT_E_REPORTED:
  919.             # Ensure the traceback doesnt cause a cycle.
  920.             exc_traceback = None
  921.             raise Exception(scode=exc_value[0])
  922.         
  923.         exception = error.AXScriptException(self, \
  924.                                codeBlock, exc_type, exc_value, exc_traceback)
  925.  
  926.         # Ensure the traceback doesnt cause a cycle.
  927.         exc_traceback = None
  928.         result_exception = error.ProcessAXScriptException(self.scriptSite, self.debugManager, exception)
  929.         if result_exception is not None:
  930.             try:
  931.                 self.scriptSite.OnScriptTerminate(None, result_exception)
  932.             except pythoncom.com_error:
  933.                 pass # Ignore errors telling engine we stopped.
  934.             # reset ourselves to 'connected' so further events continue to fire.
  935.             self.SetScriptState(axscript.SCRIPTSTATE_CONNECTED)
  936.             raise result_exception
  937.         # I think that in some cases this should just return - but the code
  938.         # that could return None above is disabled, so it never happens.
  939.         RaiseAssert(winerror.E_UNEXPECTED, "Don't have an exception to raise to the caller!")
  940.  
  941.     def BeginScriptedSection(self):
  942.         if self.scriptSite is None:
  943.             raise Exception(E_UNEXPECTED)
  944.         self.scriptSite.OnEnterScript()
  945.     def EndScriptedSection(self):
  946.         if self.scriptSite is None:
  947.             raise Exception(E_UNEXPECTED)
  948.         self.scriptSite.OnLeaveScript()
  949.     
  950.     def DisableInterrupts(self):
  951.         pass
  952.     def EnableInterrupts(self):
  953.         pass
  954.     def GetNamedItem(self, name):
  955.         try:
  956.             return self.subItems[name]
  957.         except KeyError:
  958.             raise Exception(scode=winerror.E_INVALIDARG)
  959.  
  960.     def GetNamedItemClass(self):
  961.         return ScriptItem
  962.  
  963.     def _AddScriptCodeBlock(self, codeBlock):
  964.         self.scriptCodeBlocks[codeBlock.GetFileName()] = codeBlock
  965.         if self.debugManager:
  966.             self.debugManager.AddScriptBlock(codeBlock)
  967.  
  968. if __name__=='__main__':
  969.     print "This is a framework class - please use pyscript.py etc"
  970.  
  971. def dumptypeinfo(typeinfo):
  972.         return
  973.         attr = typeinfo.GetTypeAttr()
  974.         # Loop over all methods
  975.         print "Methods"
  976.         for j in xrange(attr[6]):
  977.             fdesc = list(typeinfo.GetFuncDesc(j))
  978.             id = fdesc[0]
  979.             try:
  980.                 names = typeinfo.GetNames(id)
  981.             except pythoncom.ole_error:
  982.                 names = None
  983.             doc = typeinfo.GetDocumentation(id)
  984.  
  985.             print " ", names, "has attr", fdesc
  986.  
  987.         # Loop over all variables (ie, properties)
  988.         print "Variables"
  989.         for j in xrange(attr[7]):
  990.             fdesc = list(typeinfo.GetVarDesc(j))
  991.             names = typeinfo.GetNames(id)
  992.             print " ", names, "has attr", fdesc
  993.