Software Público Brasileiro

# Classes which describe interfaces.

from win32com.server.exception import Exception
from win32com.server.util import ListEnumeratorGateway
from win32com.axdebug import axdebug
from win32com.axdebug.util import RaiseNotImpl, _wrap
import pythoncom
import win32com.server.connect
import winerror

class EnumDebugCodeContexts(ListEnumeratorGateway):
    """A class to expose a Python sequence as an EnumDebugCodeContexts

    Create an instance of this class passing a sequence (list, tuple, or
    any sequence protocol supporting object) and it will automatically
    support the EnumDebugCodeContexts interface for the object.

    """
    _com_interfaces_ = [ axdebug.IID_IEnumDebugCodeContexts ]

class EnumDebugStackFrames(ListEnumeratorGateway):
    """A class to expose a Python sequence as an EnumDebugStackFrames

    Create an instance of this class passing a sequence (list, tuple, or
    any sequence protocol supporting object) and it will automatically
    support the EnumDebugStackFrames interface for the object.

    """
    _com_interfaces_ = [ axdebug.IID_IEnumDebugStackFrames ]

class EnumDebugApplicationNodes(ListEnumeratorGateway):
    """A class to expose a Python sequence as an EnumDebugStackFrames

    Create an instance of this class passing a sequence (list, tuple, or
    any sequence protocol supporting object) and it will automatically
    support the EnumDebugApplicationNodes interface for the object.

    """
    _com_interfaces_ = [ axdebug.IID_IEnumDebugApplicationNodes ]

class EnumRemoteDebugApplications(ListEnumeratorGateway):
    _com_interfaces_ = [ axdebug.IID_IEnumRemoteDebugApplications ]

class EnumRemoteDebugApplicationThreads(ListEnumeratorGateway):
    _com_interfaces_ = [ axdebug.IID_IEnumRemoteDebugApplicationThreads ]

class DebugDocumentInfo:
    _public_methods_ = ["GetName", "GetDocumentClassId"]
    _com_interfaces_ = [axdebug.IID_IDebugDocumentInfo]
    def __init__(self):
        pass
    def GetName(self, dnt):
        """ Get the one of the name of the document
            dnt -- int DOCUMENTNAMETYPE
        """
        RaiseNotImpl("GetName")
    def GetDocumentClassId(self):
        """
            Result must be an IID object (or string representing one).
        """
        RaiseNotImpl("GetDocumentClassId")

class DebugDocumentProvider(DebugDocumentInfo):
    _public_methods_ = DebugDocumentInfo._public_methods_ + ["GetDocument"]
    _com_interfaces_ = DebugDocumentInfo._com_interfaces_ + [axdebug.IID_IDebugDocumentProvider]
    def GetDocument(self):
        RaiseNotImpl("GetDocument")

class DebugApplicationNode(DebugDocumentProvider):
    """Provides the functionality of IDebugDocumentProvider, plus a context within a project tree.
    """
    _public_methods_ = """EnumChildren GetParent SetDocumentProvider
                    Close Attach Detach""".split() + \
            DebugDocumentProvider._public_methods_
    _com_interfaces_ = [axdebug.IID_IDebugDocumentProvider] + \
            DebugDocumentProvider._com_interfaces_
    def __init__(self):
        DebugDocumentProvider.__init__(self)
    def EnumChildren(self):
        # Result is type PyIEnumDebugApplicationNodes
        RaiseNotImpl("EnumChildren")
    def GetParent(self):
        # result is type PyIDebugApplicationNode
        RaiseNotImpl("GetParent")
    def SetDocumentProvider(self, pddp): # PyIDebugDocumentProvider pddp
        # void result.
        RaiseNotImpl("SetDocumentProvider")
    def Close(self):
        # void result.
        RaiseNotImpl("Close")
    def Attach(self, parent): # PyIDebugApplicationNode
        # void result.
        RaiseNotImpl("Attach")
    def Detach(self):
        # void result.
        RaiseNotImpl("Detach")

class DebugApplicationNodeEvents:
    """Event interface for DebugApplicationNode object.
    """
    _public_methods_ = "onAddChild onRemoveChild onDetach".split()
    _com_interfaces_ = [axdebug.IID_IDebugApplicationNodeEvents]
    def __init__(self):
        pass
    def onAddChild(self, child): # PyIDebugApplicationNode
        # void result.
        RaiseNotImpl("onAddChild")
    def onRemoveChild(self, child): # PyIDebugApplicationNode
        # void result.
        RaiseNotImpl("onRemoveChild")
    def onDetach(self):
        # void result.
        RaiseNotImpl("onDetach")
    def onAttach(self, parent): # PyIDebugApplicationNode
        # void result.
        RaiseNotImpl("onAttach")

class DebugDocument(DebugDocumentInfo):
    """The base interface to all debug documents.
    """
    _public_methods_ = DebugDocumentInfo._public_methods_
    _com_interfaces_ = [axdebug.IID_IDebugDocument] + DebugDocumentInfo._com_interfaces_

class DebugDocumentText(DebugDocument):
    """The interface to a text only debug document.
    """
    _com_interfaces_ = [axdebug.IID_IDebugDocumentText] + \
                         DebugDocument._com_interfaces_
    _public_methods_ = ["GetDocumentAttributes", "GetSize",
                        "GetPositionOfLine", "GetLineOfPosition", "GetText",
                        "GetPositionOfContext", "GetContextOfPosition"] + \
                         DebugDocument._public_methods_
    def __init__(self):
        pass
    # IDebugDocumentText
    def GetDocumentAttributes(self):
        # Result is int (TEXT_DOC_ATTR)
        RaiseNotImpl("GetDocumentAttributes")
    def GetSize(self):
        # Result is (numLines, numChars)
        RaiseNotImpl("GetSize")
    def GetPositionOfLine(self, cLineNumber):
        # Result is int char position
        RaiseNotImpl("GetPositionOfLine")
    def GetLineOfPosition(self, charPos):
        # Result is int, int (lineNo, offset)
        RaiseNotImpl("GetLineOfPosition")
    def GetText(self, charPos, maxChars, wantAttr):
        """Params
        charPos -- integer
        maxChars -- integer
        wantAttr -- Should the function compute attributes.

        Return value must be (string, attribtues).  attributes may be
        None if(not wantAttr)
        """
        RaiseNotImpl("GetText")
    def GetPositionOfContext(self, debugDocumentContext):
        """Params
        debugDocumentContext -- a PyIDebugDocumentContext object.

        Return value must be (charPos, numChars)
        """
        RaiseNotImpl("GetPositionOfContext")
    def GetContextOfPosition(self, charPos, maxChars):
        """Params are integers.
        Return value must be PyIDebugDocumentContext object
        """
        print self
        RaiseNotImpl("GetContextOfPosition")

class DebugDocumentTextExternalAuthor:
    """Allow external editors to edit file-based debugger documents, and to notify the document when the source file has been changed.
    """
    _public_methods_ = ["GetPathName", "GetFileName", "NotifyChanged"]
    _com_interfaces_ = [axdebug.IID_IDebugDocumentTextExternalAuthor]
    def __init__(self):
        pass
    def GetPathName(self):
        """Return the full path (including file name) to the document's source file.

        Result must be (filename, fIsOriginal), where
        - if fIsOriginalPath is TRUE if the path refers to the original file for the document.
        - if fIsOriginalPath is FALSE if the path refers to a newly created temporary file.

        raise Exception(winerror.E_FAIL) if no source file can be created/determined.
        """
        RaiseNotImpl("GetPathName")

    def GetFileName(self):
        """Return just the name of the document, with no path information.  (Used for "Save As...")

        Result is a string
        """
        RaiseNotImpl("GetFileName")

    def NotifyChanged(self):
        """ Notify the host that the document's source file has been saved and
        that its contents should be refreshed.
        """
        RaiseNotImpl("NotifyChanged")


class DebugDocumentTextEvents:
    _public_methods_ = """onDestroy onInsertText onRemoveText
              onReplaceText onUpdateTextAttributes
              onUpdateDocumentAttributes""".split()
    _com_interfaces_ = [ axdebug.IID_IDebugDocumentTextEvents ]
    def __init__(self):
        pass
    def onDestroy(self):
        # Result is void.
        RaiseNotImpl("onDestroy")
    def onInsertText(self, cCharacterPosition, cNumToInsert):
        # Result is void.
        RaiseNotImpl("onInsertText")
    def onRemoveText(self, cCharacterPosition, cNumToRemove):
        # Result is void.
        RaiseNotImpl("onRemoveText")
    def onReplaceText(self, cCharacterPosition, cNumToReplace):
        # Result is void.
        RaiseNotImpl("onReplaceText")
    def onUpdateTextAttributes(self, cCharacterPosition, cNumToUpdate):
        # Result is void.
        RaiseNotImpl("onUpdateTextAttributes")
    def onUpdateDocumentAttributes(self,textdocattr): # TEXT_DOC_ATTR
        # Result is void.
        RaiseNotImpl("onUpdateDocumentAttributes")

class DebugDocumentContext:
    _public_methods_ = [ 'GetDocument', 'EnumCodeContexts']
    _com_interfaces_ = [ axdebug.IID_IDebugDocumentContext ]
    def __init__(self):
        pass
    def GetDocument(self):
        """Return value must be a PyIDebugDocument object
        """
        RaiseNotImpl("GetDocument")

    def EnumCodeContexts(self):
        """Return value must be a PyIEnumDebugCodeContexts object
        """
        RaiseNotImpl("EnumCodeContexts")


class DebugCodeContext:
    _public_methods_ = [ 'GetDocumentContext', 'SetBreakPoint']
    _com_interfaces_ = [ axdebug.IID_IDebugCodeContext ]
    def __init__(self):
        pass
    def GetDocumentContext(self):
        """Return value must be a PyIDebugDocumentContext object
        """
        RaiseNotImpl("GetDocumentContext")
    def SetBreakPoint(self, bps):
        """bps -- an integer with flags.
        """
        RaiseNotImpl("SetBreakPoint")


class DebugStackFrame:
    """Abstraction representing a logical stack frame on the stack of a thread."""
    _public_methods_ = [ 'GetCodeContext', 'GetDescriptionString', 'GetLanguageString', 'GetThread', 'GetDebugProperty']
    _com_interfaces_ = [ axdebug.IID_IDebugStackFrame ]
    def __init__(self):
        pass
    def GetCodeContext(self):
        """Returns the current code context associated with the stack frame.

        Return value must be a IDebugCodeContext object
        """
        RaiseNotImpl("GetCodeContext")
    def GetDescriptionString(self, fLong):
        """Returns a textual description of the stack frame.

        fLong -- A flag indicating if the long name is requested.
        """
        RaiseNotImpl("GetDescriptionString")
    def GetLanguageString(self):
        """Returns a short or long textual description of the language.

        fLong -- A flag indicating if the long name is requested.
        """
        RaiseNotImpl("GetLanguageString")
    def GetThread(self):
        """ Returns the thread associated with this stack frame.

        Result must be a IDebugApplicationThread
        """
        RaiseNotImpl("GetThread")
    def GetDebugProperty(self):
        RaiseNotImpl("GetDebugProperty")


class DebugDocumentHost:
    """The interface from the IDebugDocumentHelper back to
    the smart host or language engine.  This interface
    exposes host specific functionality such as syntax coloring.
    """
    _public_methods_ = [ 'GetDeferredText', 'GetScriptTextAttributes', 'OnCreateDocumentContext', 'GetPathName', 'GetFileName', 'NotifyChanged']
    _com_interfaces_ = [ axdebug.IID_IDebugDocumentHost ]
    def __init__(self):
        pass
    def GetDeferredText(self, dwTextStartCookie,  maxChars, bWantAttr):
        RaiseNotImpl("GetDeferredText")

    def GetScriptTextAttributes(self, codeText, delimterText, flags):
        # Result must be an attribute sequence of same "length" as the code.
        RaiseNotImpl("GetScriptTextAttributes")

    def OnCreateDocumentContext(self):
        # Result must be a PyIUnknown
        RaiseNotImpl("OnCreateDocumentContext")

    def GetPathName(self):
        # Result must be (string, int) where the int is a BOOL
        # - TRUE if the path refers to the original file for the document.
        # - FALSE if the path refers to a newly created temporary file.
        # - raise Exception(scode=E_FAIL) if no source file can be created/determined.
        RaiseNotImpl("GetPathName")

    def GetFileName(self):
        # Result is a string with just the name of the document, no path information.
        RaiseNotImpl("GetFileName")

    def NotifyChanged(self):
        RaiseNotImpl("NotifyChanged")

# Additional gateway related functions.

class DebugDocumentTextConnectServer:
    _public_methods_ = win32com.server.connect.IConnectionPointContainer_methods + win32com.server.connect.IConnectionPoint_methods
    _com_interfaces_ = [pythoncom.IID_IConnectionPoint, pythoncom.IID_IConnectionPointContainer]
    # IConnectionPoint interfaces
    def __init__(self):
        self.cookieNo = -1
        self.connections = {}
    def EnumConnections(self):
        RaiseNotImpl("EnumConnections")
    def GetConnectionInterface(self):
        RaiseNotImpl("GetConnectionInterface")
    def GetConnectionPointContainer(self):
        return _wrap(self)
    def Advise(self, pUnk):
        # Creates a connection to the client.  Simply allocate a new cookie,
        # find the clients interface, and store it in a dictionary.
        interface = pUnk.QueryInterface(axdebug.IID_IDebugDocumentTextEvents,1)
        self.cookieNo = self.cookieNo + 1
        self.connections[self.cookieNo] = interface
        return self.cookieNo
    def Unadvise(self, cookie):
        # Destroy a connection - simply delete interface from the map.
        try:
            del self.connections[cookie]
        except KeyError:
            return Exception(scode=winerror.E_UNEXPECTED)
    # IConnectionPointContainer interfaces
    def EnumConnectionPoints(self):
        RaiseNotImpl("EnumConnectionPoints")
    def FindConnectionPoint(self, iid):
        # Find a connection we support.  Only support the single event interface.
        if iid==axdebug.IID_IDebugDocumentTextEvents:
            return _wrap(self)
        raise Exception(scode=winerror.E_NOINTERFACE) # ??

class RemoteDebugApplicationEvents:
    _public_methods_ = ["OnConnectDebugger","OnDisconnectDebugger","OnSetName","OnDebugOutput","OnClose","OnEnterBreakPoint","OnLeaveBreakPoint","OnCreateThread","OnDestroyThread","OnBreakFlagChange"]
    _com_interfaces_ = [axdebug.IID_IRemoteDebugApplicationEvents]
    def OnConnectDebugger(self, appDebugger):
        """appDebugger -- a PyIApplicationDebugger
        """
        RaiseNotImpl("OnConnectDebugger")
    def OnDisconnectDebugger(self):
        RaiseNotImpl("OnDisconnectDebugger")
    def OnSetName(self, name):
        RaiseNotImpl("OnSetName")
    def OnDebugOutput(self, string):
        RaiseNotImpl("OnDebugOutput")
    def OnClose(self):
        RaiseNotImpl("OnClose")
    def OnEnterBreakPoint(self, rdat):
        """rdat -- PyIRemoteDebugApplicationThread
        """
        RaiseNotImpl("OnEnterBreakPoint")
    def OnLeaveBreakPoint(self, rdat):
        """rdat -- PyIRemoteDebugApplicationThread
        """
        RaiseNotImpl("OnLeaveBreakPoint")
    def OnCreateThread(self, rdat):
        """rdat -- PyIRemoteDebugApplicationThread
        """
        RaiseNotImpl("OnCreateThread")
    def OnDestroyThread(self, rdat):
        """rdat -- PyIRemoteDebugApplicationThread
        """
        RaiseNotImpl("OnDestroyThread")
    def OnBreakFlagChange(self, abf, rdat):
        """abf -- int - one of the axdebug.APPBREAKFLAGS constants
        rdat -- PyIRemoteDebugApplicationThread
        RaiseNotImpl("OnBreakFlagChange")
        """
class DebugExpressionContext:
    _public_methods_ = ["ParseLanguageText", "GetLanguageInfo"]
    _com_interfaces_ = [axdebug.IID_IDebugExpressionContext]
    def __init__(self):
        pass
    def ParseLanguageText(self, code, radix, delim, flags):
        """
        result is IDebugExpression
        """
        RaiseNotImpl("ParseLanguageText")
    def GetLanguageInfo(self):
        """
        result is (string langName, iid langId)
        """
        RaiseNotImpl("GetLanguageInfo")

class DebugExpression:
    _public_methods_ = ["Start", "Abort", "QueryIsComplete", "GetResultAsString", "GetResultAsDebugProperty"]
    _com_interfaces_ = [axdebug.IID_IDebugExpression]
    def Start(self, callback):
        """
        callback -- an IDebugExpressionCallback

        result - void
        """
        RaiseNotImpl("Start")
    def Abort(self):
        """
        no params
        result -- void
        """
        RaiseNotImpl("Abort")

    def QueryIsComplete(self):
        """
        no params
        result -- void
        """
        RaiseNotImpl("QueryIsComplete")

    def GetResultAsString(self):
        RaiseNotImpl("GetResultAsString")

    def GetResultAsDebugProperty(self):
        RaiseNotImpl("GetResultAsDebugProperty")

class ProvideExpressionContexts:
    _public_methods_ = ["EnumExpressionContexts"]
    _com_interfaces_ = [axdebug.IID_IProvideExpressionContexts]
    def EnumExpressionContexts(self):
        RaiseNotImpl("EnumExpressionContexts")