Python RendererManager.RendererManager类代码示例

def plugin_loaded():
    Server.init()
    # Setting must be the first to initialize.
    Setting.instance().init()
    PluginManager.instance().subscribe_setting_events()
    RendererManager.start()
    PluginManager.instance().restart_server()

    def run(self, edit, immediate=True):
        # Whether RendererManager is finished loading?
        if not RendererManager.ensure_started():
            sublime.status_message('OmniMarkupPreviewer have not yet started')
            return

        buffer_id = self.view.buffer_id()
        # Opened in a tab already?
        opened = False
        for view in self.view.window().views():
            if view.buffer_id() == buffer_id:
                opened = True
                break
        if not opened:
            RendererManager.enqueue_view(self.view, immediate=True)

        host = Setting.instance().server_host
        port = Setting.instance().server_port
        if host == '0.0.0.0':
            host = '127.0.0.1'
        url = 'http://%s:%d/view/%d' % (host, port, buffer_id)
        # Open with the default browser
        log.info('Launching web browser for %s', url)
        launching_web_browser_for_url(
            url,
            success_msg_default='Preview launched in default web browser',
            success_msg_user='Preview launched in user defined web browser')

    def put(self, view, preemptive=True, timeout=0.5):
        if not RendererManager.any_available_renderer_for_view(view):
            return

        view_id = view.id()
        now = time.time()

        with self.mutex:
            if view_id in self.view_entry_mapping:
                # Too fast, cancel this operation
                if now - self.last_signaled <= 0.01:
                    return

        if preemptive:
            # Cancel pending actions
            with self.cond:
                if view_id in self.view_entry_mapping:
                    del self.view_entry_mapping[view_id]
                    self.cond.notify()
            RendererManager.enqueue_view(view, only_exists=True)
            self.last_signaled = now
        else:
            with self.cond:
                filename = view.file_name()
                if view_id not in self.view_entry_mapping:
                    self.view_entry_mapping[view_id] = self.Entry(view, timeout)
                else:
                    entry = self.view_entry_mapping[view_id]
                    entry.view = view
                    entry.filename = filename
                    entry.timeout = timeout
                self.cond.notify()

    def queue(self, view, preemptive=True, timeout=0.5):
        if not RendererManager.has_renderer_enabled_in_view(view):
            return

        view_id = view.id()
        now = time.time()

        with self.mutex:
            if view_id in self.delayed_views:
                if now - self.last_signaled <= 0.01:  # Too fast, cancel this operation
                    return

        if preemptive:
            # Cancel pending actions
            with self.cond:
                if view_id in self.delayed_views:
                    del self.delayed_views[view_id]
                    self.cond.notify()
            RendererManager.queue_view(view, only_exists=True)
            self.last_signaled = now
        else:
            with self.cond:
                filename = view.file_name()
                if view_id not in self.delayed_views:
                    self.delayed_views[view_id] = self.Entry(view, filename, timeout)
                else:
                    entry = self.delayed_views[view_id]
                    entry.view = view
                    entry.filename = filename
                    entry.timeout = timeout
                self.cond.notify()

def render_text_by_buffer_id(buffer_id):
    valid_view = None
    for window in sublime.windows():
        if valid_view is not None:
            break
        for view in window.views():
            if view.buffer_id() == buffer_id:
                valid_view = view
                break
    if valid_view is None:
        return None
    RendererManager.queue_view(valid_view, immediate=True)
    return RenderedMarkupCache.instance().get_entry(buffer_id)

    def queue_to_renderer_manager(self, view, filename):
        view_id = view.id()
        valid_view = False
        for window in sublime.windows():
            if valid_view:
                break
            for v in window.views():
                if v.id() == view_id:  # Got view
                    valid_view = True
                    break

        if not valid_view or view.is_loading() or view.file_name() != filename:
            return
        if RendererManager.has_renderer_enabled_in_view(view):
            RendererManager.queue_view(view, only_exists=True)
            self.last_signaled = time.time()

    def run(self, edit, immediate=True):
        buffer_id = self.view.buffer_id()
        # Is opened in a tab?
        opened = False
        for view in self.view.window().views():
            if view.buffer_id == buffer_id:
                opened = True
                break
        if not opened:
            RendererManager.queue_view(self.view, immediate=True)

        url = 'http://localhost:%d/view/%d' % (Setting.instance().server_port, buffer_id)
        # Open with the default browser
        log.info('Launching web browser for %s', url)
        launching_web_browser_for_url(
            url,
            success_msg_default='Preview launched in default web browser',
            success_msg_user='Preview launched in user defined web browser'
        )

def unload_handler():
    log.info('Unloading plugin...')
    # Cleaning up resources...
    PluginManager.instance().stop_server()
    # Stopping renderer worker
    RendererManager.stop()

 def on_query_context(self, view, key, operator, operand, match_all):
     # `omp_is_enabled` for backwards compatibility
     if key == 'omnimarkup_is_enabled' or key == 'omp_is_enabled':
         return RendererManager.any_available_renderer_for_view(view)
     return None

 def enqueue_view_to_renderer_manager(self, view, filename):
     if view.is_loading() or view.file_name() != filename:
         return
     if RendererManager.any_available_renderer_for_view(view):
         RendererManager.enqueue_view(view, only_exists=True)
         self.last_signaled = time.time()

 def is_visible(self):
     return RendererManager.any_available_renderer_for_view(self.view)

 def on_query_context(self, view, key, operator, operand, match_all):
     # omp_is_enabled is here for backwards compatibility
     if key == 'omnimarkup_is_enabled' or key == 'omp_is_enabled':
         return RendererManager.has_renderer_enabled_in_view(view)
     return None

 def is_enabled(self):
     return RendererManager.has_renderer_enabled_in_view(self.view)

        g_server = Server(host=setting.server_host, port=setting.server_port)

    def stop_server(self):
        global g_server
        if g_server is not None:
            g_server.stop()
            g_server = None

    def try_download_mathjax(self, setting=None):
        if setting is None:
            setting = Setting.instance()
        if setting.mathjax_enabled:
            OnDemandDownloader.on_demand_download_mathjax()


def unload_handler():
    log.info('Unloading plugin...')
    # Cleaning up resources...
    PluginManager.instance().stop_server()
    # Stopping renderer worker
    RendererManager.WORKER.stop()


# Setting must be the first to initialize.
Setting.instance().init()
PluginManager.instance().subscribe_setting_events()
RendererManager.init()
RendererManager.WORKER.start()
PluginManager.instance().restart_server()
PluginManager.instance().try_download_mathjax()