output.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 re
import gobject
import gtk
import gtk.glade
from gettext import gettext

import view
import extension
import execution
import config
import environment
import settings

datadir = None
views = []

def init_extension(d):
        global datadir
        datadir = d

def get_views():
        global views
        return [i for i in views if not i.is_busy()]

##
## Output

class Output (environment.OutputExtension):
        def __init__(self):
                environment.OutputExtension.__init__(self)

        def get_view(self):
                views = get_views()
                if views:
                        return views[0]
                else:
                        view = View()
                        environment.add_view(view, 'bottom')
                        return view

        def set_batch(self, batch):
                view = self.get_view()
                view.set_batch(batch)
                environment.show_view(view, focus=False)

gobject.type_register(Output)

##
## Launcher

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

                label = gettext('Output window')
                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.AbstractView):
        def __init__(self):
                view.AbstractView.__init__(self)

                path = os.path.join(datadir, 'encode', 'output-view.glade')
                self.glade = gtk.glade.XML(path)
                self.glade.signal_autoconnect(self)

                self._set_title('idle')

                buffer = self._get_buffer()
                buffer.connect_after('insert-text', self.on_buffer_insert)

                self.tag_common = buffer.create_tag()

                self.tag_execute = buffer.create_tag()
                self.tag_execute.set_property('foreground', 'blue')

                self.tag_error = buffer.create_tag()
                self.tag_error.set_property('foreground', 'red3')

                self.tag_success = buffer.create_tag()
                self.tag_success.set_property('foreground', 'green4')

                self.tag_failure = buffer.create_tag()
                self.tag_failure.set_property('foreground', 'red')

                self.conf = config.Directory('encode/output')
                self.conf.add_string('font', lambda font: self.tag_common.set_property('font', font))

                self.formats = []
                self.conf.add_strings('formats', self.set_formats)

                self.batch = None
                self.handlers = None
                self.jobs_by_line = []

        def set_formats(self, strings):
                self.formats = [re.compile(s) for s in strings]

        def _get_job(self, line):
                for start_line, job in self.jobs_by_line:
                        if start_line <= line:
                                return job
                return None

        def _get_buffer(self):
                textview = self.glade.get_widget('textview')
                return textview.get_buffer()

        def _set_title(self, name):
                data_label = self.glade.get_widget('title_%s' % name)
                text = data_label.get_label()

                display_label = self.glade.get_widget('title')
                display_label.set_label(text)

        def _ensure_newline(self):
                buffer = self._get_buffer()
                end = buffer.get_end_iter()

                if not end.is_start():
                        last = end.copy()
                        last.backward_char()

                        if last.get_char() != '\n':
                                buffer.insert(end, '\n')

        def _append(self, text, tags=[]):
                buffer = self._get_buffer()

                end = buffer.get_end_iter()
                buffer.insert(end, text)

                start = buffer.get_iter_at_mark(self.mark)

                for tag in [self.tag_common] + tags:
                        buffer.apply_tag(tag, start, end)

                buffer.move_mark(self.mark, end)

        def _append_message(self, tag, name, params=()):
                label = self.glade.get_widget('message_%s' % name)
                format = label.get_label()

                text = format % params

                self._ensure_newline()
                self._append(text, [tag])

        def on_textview_popup(self, textview, menu):
                item = self.glade.get_widget('stop_item')
                menu.insert(item, 0)
                menu.connect('destroy', lambda menu: menu.remove(item))

                separator = gtk.SeparatorMenuItem()
                separator.show()
                menu.insert(separator, 1)

        def on_textview_release(self, textview, event):
                if event.button == 1:
                        buffer = self._get_buffer()
                        if not buffer.get_selection_bounds():
                                buf_x, buf_y = textview.window_to_buffer_coords(gtk.TEXT_WINDOW_WIDGET, int(event.x), int(event.y))
                                line_iter, line_y = textview.get_line_at_y(buf_y)

                                self._edit_source(line_iter)

        def on_scrolledwindow_parent_set(self, scrolledwindow, old_parent):
                global views
                if scrolledwindow.get_parent():
                        if not old_parent:
                                views.append(self)
                else:
                        if old_parent:
                                views.remove(self)

        def on_scrolledwindow_destroy(self, scrolledwindow):
                self.conf.remove_all()
                self.conf = None

                if self.batch:
                        self.batch.stop()
                        self.batch = None

        # Execution

        def set_batch(self, batch):
                if self.batch:
                        for id in self.handlers:
                                self.batch.disconnect(id)

                self.batch = batch
                self.handlers = (
                        self.batch.connect('job-started', self.on_batch_started),
                        self.batch.connect('finished', self.on_batch_finished)
                )

                self.batch.get_output().consumers.add(self._consume_output)
                self.batch.get_error().consumers.add(self._consume_error)

                self.jobs_by_line = []

                self._set_title('busy')

                buffer = self._get_buffer()
                buffer.set_text('')

                start = buffer.get_start_iter()
                self.mark = buffer.create_mark(None, start, left_gravity=True)

        def is_busy(self):
                if not self.get_widget():
                        return True

                if self.batch:
                        return self.batch.is_alive()
                else:
                        return False

        def _consume_output(self, text, tags=[]):
                self._append(text, tags)

        def _consume_error(self, text):
                self._consume_output(text, [self.tag_error])

        def on_batch_started(self, batch, job):
                # Job

                self._ensure_newline()

                buffer = self._get_buffer()
                iter = buffer.get_end_iter()
                line = iter.get_line()

                self.jobs_by_line.append((line, job))

                # Message

                info = ''

                if isinstance(job, execution.Job):
                        if job.vars:
                                for key in job.vars:
                                        info += 'Environ: %s=%s\n' % (key, job.vars[key])

                        if job.workdir:
                                info += 'Workdir: %s\n' % job.workdir

                        info += 'Command:'
                        for arg in job.args:
                                arg = arg.replace(' ', '\\ ')
                                info = '%s %s' % (info, arg)
                else:
                        info += 'Hook: %s' % job

                info += '\n'

                self._append_message(self.tag_execute, 'execute', (info))
                self._ensure_newline()

                item = self.glade.get_widget('stop_item')
                item.set_sensitive(True)

        def on_batch_finished(self, batch, status):
                self._set_title('idle')

                if status == 0:
                        self._append_message(self.tag_success, 'success')
                else:
                        signum = status & 0xff
                        retval = status >> 8

                        if signum:
                                self._append_message(self.tag_failure, 'signal', (signum))
                        else:
                                self._append_message(self.tag_failure, 'error', (retval))

                item = self.glade.get_widget('stop_item')
                item.set_sensitive(False)

        def on_buffer_insert(self, buffer, iter, text, length):
                textview = self.glade.get_widget('textview')
                textview.scroll_to_mark(self.mark, within_margin=0.0, use_align=True, xalign=0.0, yalign=0.0)

        def on_stop_activate(self, item):
                self.batch.stop()

                self._set_title('idle')
                self._append_message(self.tag_failure, 'stop')

                item.set_sensitive(False)

        # Edit source

        def _edit_source(self, iter):
                line = iter.get_line()

                job = self._get_job(line)
                if job:
                        buffer = self._get_buffer()

                        end_iter = buffer.get_iter_at_line(line + 1)
                        if iter == end_iter:
                                end_iter = buffer.get_end_iter()

                        text = buffer.get_text(iter, end_iter)

                        location = self._match(text)
                        if location:
                                filename, line = location

                                path = os.path.join(job.workdir, filename)
                                environment.edit(path, job.workdir, line)

        def _match(self, text):
                for regex in self.formats:
                        match = regex.match(text)
                        if match:
                                filename, line = match.group(1, 2)
                                return filename, int(line)
                return None

        # View

        def get_label(self):
                return self.glade.get_widget('title')

        def get_widget(self):
                return self.glade.get_widget('scrolledwindow')

gobject.type_register(View)

##
## Settings

if 'set' not in __builtins__:
        import sets
        set = sets.Set

class Settings (settings.SettingsExtension):
        def __init__(self):
                settings.SettingsExtension.__init__(self)

                path = os.path.join(datadir, 'encode', 'output-settings.glade')
                self.glade = gtk.glade.XML(path)
                self.glade.signal_autoconnect(self)

                self.conf = config.Directory('encode/output')

                self.dirty = set((
                        'font',
                ))
                self.revert()

        def get_name(self):
                return gettext('Output')

        def get_title(self):
                return gettext('Output window')

        def get_widget(self):
                return self.glade.get_widget('table')

        def apply(self):
                if 'font' in self.dirty:
                        fontbutton = self.glade.get_widget('font_fontbutton')
                        font = fontbutton.get_font_name()

                        self.conf.set_string('font', font)

                self.dirty.clear()

        def revert(self):
                if 'font' in self.dirty:
                        font = self.conf.get_string('font')

                        fontbutton = self.glade.get_widget('font_fontbutton')
                        fontbutton.set_font_name(font)

                self.dirty.clear()

        def on_font_set(self, fontbutton):
                self.dirty.add('font')
                self.modified()

gobject.type_register(Settings)

---