Python UnwrapObject.initialize方法代码示例

# 需要导入模块: from xpcom.server import UnwrapObject [as 别名]
# 或者: from xpcom.server.UnwrapObject import initialize [as 别名]
 def addFileStatusChecker(self, checkerInstance):
     self._tlock.acquire()
     try:
         log.info("addFileStatusChecker:: added %r", checkerInstance.name)
         # Try to get the native Python checker instance instead of XPCOM
         # one - saves CPU cycles by not having to go through XPCOM.
         try:
             checkerInstance = UnwrapObject(checkerInstance)
         except:
             pass  # Keep the XPCOM version then.
         checkerInstance.initialize()
         for i in range(len(self._statusCheckers)):
             checker = self._statusCheckers[i]
             if checkerInstance.ranking_weight < checker.ranking_weight:
                 self._statusCheckers.insert(i, checkerInstance)
                 break
         else:
             self._statusCheckers.append(checkerInstance)
         # print "Order now: %r" % ([x.name for x in self._statusCheckers])
     finally:
         self._tlock.release()

# 需要导入模块: from xpcom.server import UnwrapObject [as 别名]
# 或者: from xpcom.server.UnwrapObject import initialize [as 别名]
class KoToolbox2Service(object):
    _com_interfaces_ = [components.interfaces.koIToolbox2Service,
                        components.interfaces.nsIObserver]
    _reg_clsid_ = "{cb9d6082-fc69-2d42-857a-2490e94fa518}"
    _reg_contractid_ = "@activestate.com/koToolbox2Service;1"
    _reg_desc_ = "Similar to the projectService, but for toolbox2"
    
    def __init__(self):
        self.wrapped = WrapObject(self, components.interfaces.nsIObserver)

        self._macros = RunningMacros()
        self._standardToolbox = None  # Stores the top-level folder's ID
        self._loadedToolboxes = {}    # Map project uri to top-level folder's id
        self._tbFromExtension = {}    # Map folder ID to a boolean
        self.db = None
        self._inited = False
        
        self._wrapped = WrapObject(self, components.interfaces.nsIObserver)
        _observerSvc = components.classes["@mozilla.org/observer-service;1"]\
                .getService(components.interfaces.nsIObserverService)
        _observerSvc.addObserver(self._wrapped,
                                 "project_renamed", 0)
        # 
        # self._prefs.prefObserverService.addObserver(self._wrapped,
        #                                 "xpcom-shutdown", 0)
        
    def initialize(self):
        if self._inited:
            return
        self._inited = True
        koDirSvc = components.classes["@activestate.com/koDirs;1"].getService()
        self.toolbox_db = UnwrapObject(components.classes["@activestate.com/KoToolboxDatabaseService;1"].\
                       getService(components.interfaces.koIToolboxDatabaseService))
        self._toolsMgrSvc = UnwrapObject(components.classes["@activestate.com/koToolbox2ToolManager;1"].\
                      getService(components.interfaces.koIToolbox2ToolManager));
        self._toolsMgrSvc.initialize(self.toolbox_db)

        self.db_path = os.path.join(koDirSvc.userDataDir, 'toolbox.sqlite')
        schemaFile = os.path.join(koDirSvc.mozBinDir,
                                  'python', 'komodo', 'toolbox',
                                  'koToolbox.sql')
        try:
            self.db = self.toolbox_db.initialize(self.db_path, schemaFile)
            self.loadMainToolboxes()
        except:
            log.exception("Error initializing toolboxes")

    def loadMainToolboxes(self):
        self.toolboxLoader = koToolbox2.ToolboxLoader(self.db_path, self.db)
        self.toolboxLoader.markAllTopLevelItemsUnloaded()
        koDirSvc = components.classes["@activestate.com/koDirs;1"].getService()
        stdToolboxDir = join(koDirSvc.userDataDir,
                             koToolbox2.DEFAULT_TARGET_DIRECTORY)
        if not os.path.exists(stdToolboxDir):
            try:
                os.mkdir(stdToolboxDir)
            except:
                log.error("Can't create tools dir %s", stdToolboxDir)

        import time
        t1 = time.time()
        toolbox_id = self.toolboxLoader.loadToolboxDirectory("", stdToolboxDir, koToolbox2.DEFAULT_TARGET_DIRECTORY)
        self.notifyAddedToolbox(stdToolboxDir, notifyAllWindows=True)
        t2 = time.time()
        #log.debug("Time to load std-toolbox: %g msec", (t2 - t1) * 1000.0)
        self.registerStandardToolbox(toolbox_id)
        
        import directoryServiceUtils
        extensionDirs = directoryServiceUtils.getExtensionDirectories()
        for extensionDir in extensionDirs:
            # Does this happen for disabled extensions?
            toolDir = join(extensionDir, koToolbox2.DEFAULT_TARGET_DIRECTORY)
            if os.path.exists(toolDir):
                self.activateExtensionToolbox(extensionDir)
            #else:
            #    log.debug("No tools in %s", extensionDir)
        self.toolboxLoader.deleteUnloadedTopLevelItems()
    
    def registerStandardToolbox(self, id):
        #log.debug("registerStandardToolbox(id:%d)", id)
        self._standardToolbox = id

    def registerUserToolbox(self, uri, id, isFromExtension):
        self._loadedToolboxes[uri] = id
        self._tbFromExtension[id] = isFromExtension

    def unregisterUserToolbox(self, uri):
        try:
            id = self._loadedToolboxes[uri]
        except KeyError:
            log.debug("Didn't find uri %s in self._loadedToolboxes")
            return
        try:
            del self._tbFromExtension[id]
        except KeyError:
            pass
        del self._loadedToolboxes[uri]

    def getLoadedProjectIDs(self):
        """
#.........这里部分代码省略.........