emacs.py

Go to the documentation of this file.

# Copyright 2005, 2006  Timo Savola
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published
# by the Free Software Foundation; either version 2.1 of the License, or
# (at your option) any later version.

import os
import gobject
import gtk
from gettext import gettext

import environment
import view
import execution
import config
import extension

conf = config.Directory('encode/emacs')
views = []

def init_extension(datadir):
        pass

##
## Handler

class Handler (environment.HandlerExtension):
        command = 'emacsclient'

        def __init__(self):
                environment.HandlerExtension.__init__(self)

                conf.add_string('client_command', self.set_command)

                label = gettext('Open in Emacs')
                self.action = gtk.Action(None, label, None, None)
                self.action.set_visible(True)

                self.executor = execution.Executor()

        def set_command(self, command):
                self.command = command

        def get_action(self):
                return self.action

        def get_view(self):
                global views
                if views:
                        return views[0]
                else:
                        raise environment.ViewNotFound, 'Emacs not running'

        def eval(self, view, expr):
                server = view.get_server()
                args = [self.command, '--socket-name', server, '--eval', expr]

                self.executor.start(execution.Job(args))

        def supports_file(self, path):
                global views
                return bool(views)

        def handle_file(self, path):
                self.open_file(path)

        def open_file(self, path, workdir=None, line=None):
                path_expr = string_expr(path)

                if line is not None:
                        expr = '(let* ((f %s)' \
                               '       (b (find-buffer-visiting f)))' \
                               ' (if b (switch-to-buffer b)' \
                               '       (find-file f))' \
                               ' (goto-line %d))' \
                               % (path_expr, line)
                else:
                        expr = '(let* ((f %s)' \
                               '       (b (find-buffer-visiting f)))' \
                               ' (if b (switch-to-buffer b)' \
                               '       (find-file f)))' \
                               % path_expr

                view = self.get_view()
                self.eval(view, expr)

                environment.show_view(view, focus=True)

        def close_file(self, path):
                expr = '(let ((b (find-buffer-visiting %s)))' \
                       ' (if b (kill-buffer b)))' \
                       % Handler.string_expr(path)

                global views
                for view in views:
                        self.eval(view, expr)

        def cleanup(self):
                global views
                for view in views:
                        self.eval(view, '(save-buffers-kill-emacs)')

gobject.type_register(Handler)

def string_expr(path):
        return '"%s"' % path.replace('"', '\\"')

##
## Launcher

class Launcher (environment.LauncherExtension):
        def __init__(self):
                environment.LauncherExtension.__init__(self)

                label = gettext('Emacs text editor')
                self.action = gtk.Action(None, label, None, None)
                self.action.set_visible(True)

        def get_action(self):
                return self.action

        def create(self):
                return View()

gobject.type_register(Launcher)

##
## View

class View (view.AbstractEmbedder):
        command = 'emacs'

        def __init__(self):
                view.AbstractEmbedder.__init__(self)

                conf.add_string('command', self.set_command)

                text = gettext('Emacs')
                self.label = gtk.Label(text)
                self.label.show()

                self.executor = execution.Executor()
                self.server = None

        def set_command(self, command):
                self.command = command

        def is_alive(self):
                return self.executor.is_alive()

        def get_server(self):
                return self.server

        def client_start(self, xid):
                self.server = 'encode-%d' % xid

                args = [self.command, '--no-splash', '--parent-id', str(xid),
                        '--eval', '(setq server-name "%s")' % self.server,
                        '--eval', '(server-start)',
                        '--eval', '(setq confirm-kill-emacs nil)']

                self.executor.start(execution.Job(args))

                global views
                views.append(self)

        def client_destroy(self):
                global views
                views.remove(self)

                self.server = None
                self.executor.stop()

        def get_label(self):
                return self.label

gobject.type_register(View)

---