~stomato463/+junk/nvdajp

"""Manages appModules.

@var runningTable: a dictionary of the currently running appModules, using their application's main window handle as a key.

@type runningTable: dict

"""

 

import itertools

import ctypes

import os

import pkgutil

import baseObject

import globalVars

import config

import NVDAObjects #Catches errors before loading default appModule

import api

import appModules

 

#Dictionary of processID:appModule paires used to hold the currently running modules

NVDAProcessID=None

_importers=None

 

class processEntry32W(ctypes.Structure):

        _fields_ = [

                ("dwSize",ctypes.wintypes.DWORD),

        winKernel.kernel32.CloseHandle(FSnapshotHandle)

        if not includeExt:

                appName=os.path.splitext(appName)[0].lower()

        return appName

 

def getAppModuleForNVDAObject(obj):

        if not isinstance(obj,NVDAObjects.NVDAObject):

                return

                appName=getAppNameFromProcessID(processID)

                mod=fetchAppModule(processID,appName)

                if not mod:

                        raise RuntimeError("error fetching default appModule")

                runningTable[processID]=mod

        return mod

 

def update(processID):

        @param processID: the ID of the process.

        @type processID: int

        """

        for deadMod in [mod for mod in runningTable.itervalues() if not mod.isAlive]:

                log.debug("application %s closed"%deadMod.appName)

                if deadMod in set(o.appModule for o in api.getFocusAncestors()+[api.getFocusObject()] if o and o.appModule):

                        if hasattr(deadMod,'event_appLoseFocus'):

 

def doesAppModuleExist(name):

        return any(importer.find_module("appModules.%s" % name) for importer in _importers)

 

        """Returns an appModule found in the appModules directory, for the given application name.

        @param processID: process ID for it to be associated with

        @type processID: integer

        @returns: the appModule, or None if not found

        @rtype: AppModule

        """  

        # First, check whether the module exists.

        # We need to do this separately because even though an ImportError is raised when a module can't be found, it might also be raised for other reasons.

 

def initialize():

        """Initializes the appModule subsystem. 

        global NVDAProcessID,_importers

        NVDAProcessID=os.getpid()

        config.addConfigDirsToPythonPackagePath(appModules)

 

#base class for appModules

class AppModule(baseObject.ScriptableObject):

        """

 

 

        def __init__(self,processID,appName=None):

                self.processID=processID

                self.helperLocalBindingHandle=NVDAHelper.localLib.createConnection(processID)

                if appName is None:

                        appName=getAppNameFromProcessID(processID)

                self.appName=appName

                self.processHandle=winKernel.openProcess(winKernel.SYNCHRONIZE,False,processID)

 

        def __repr__(self):

 

        def _get_appModuleName(self):

                return self.__class__.__module__.split('.')[-1]

        def _get_isAlive(self):

                return bool(winKernel.waitForSingleObject(self.processHandle,0))

 

                winKernel.closeHandle(self.processHandle)

                NVDAHelper.localLib.destroyConnection(self.helperLocalBindingHandle)

 

                @param clsList: The list of classes, which will be modified by this method if appropriate.

                @type clsList: list of L{NVDAObjects.NVDAObject}

                """