gstreamer/debug-viewer/GstDebugViewer/GUI.py

# -*- coding: utf-8; mode: python; -*-
#
#  GStreamer Debug Viewer - View and analyze GStreamer debug log files
#
#  Copyright (C) 2007 René Stadler <mail@renestadler.de>
#
#  This program is free software; you can redistribute it and/or modify it
#  under the terms of the GNU General Public License as published by the Free
#  Software Foundation; either version 3 of the License, or (at your option)
#  any later version.
#
#  This program is distributed in the hope that it will be useful, but WITHOUT
#  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
#  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
#  more details.
#
#  You should have received a copy of the GNU General Public License along with
#  this program.  If not, see <http://www.gnu.org/licenses/>.

"""GStreamer Debug Viewer GUI module."""

__author__ = u"René Stadler <mail@renestadler.de>"
__version__ = "0.1"

def _ (s):
    return s

import sys
import os
import os.path
from operator import add
from sets import Set
import logging

import pygtk
pygtk.require ("2.0")

import gobject
import gtk
import gtk.glade

from GstDebugViewer import Common, Data, Main

class Color (object):

    def __init__ (self, hex_24):

        if hex_24.startswith ("#"):
            s = hex_24[1:]
        else:
            s = hex_24

        self._fields = tuple ((int (hs, 16) for hs in (s[:2], s[2:4], s[4:],)))

    def hex_string (self):

        return "#%02x%02x%02x" % self._fields

    def float_tuple (self):

        return tuple ((float (x) / 255 for x in self._fields))

    def byte_tuple (self):

        return self._fields

    def short_tuple (self):

        return tuple ((x << 8 for x in self._fields))

class ColorPalette (object):

    @classmethod
    def get (cls):

        try:
            return cls._instance
        except AttributeError:
            cls._instance = cls ()
            return cls._instance

class TangoPalette (ColorPalette):

    def __init__ (self):

        for name, r, g, b in  [("butter1", 252, 233, 79),
                               ("butter2", 237, 212, 0),
                               ("butter3", 196, 160, 0),
                               ("chameleon1", 138, 226, 52),
                               ("chameleon2", 115, 210, 22),
                               ("chameleon3", 78, 154, 6),
                               ("orange1", 252, 175, 62),
                               ("orange2", 245, 121, 0),
                               ("orange3", 206, 92, 0),
                               ("skyblue1", 114, 159, 207),
                               ("skyblue2", 52, 101, 164),
                               ("skyblue3", 32, 74, 135),
                               ("plum1", 173, 127, 168),
                               ("plum2", 117, 80, 123),
                               ("plum3", 92, 53, 102),
                               ("chocolate1", 233, 185, 110),
                               ("chocolate2", 193, 125, 17),
                               ("chocolate3", 143, 89, 2),
                               ("scarletred1", 239, 41, 41),
                               ("scarletred2", 204, 0, 0),
                               ("scarletred3", 164, 0, 0),
                               ("aluminium1", 238, 238, 236),
                               ("aluminium2", 211, 215, 207),
                               ("aluminium3", 186, 189, 182),
                               ("aluminium4", 136, 138, 133),
                               ("aluminium5", 85, 87, 83),
                               ("aluminium6", 46, 52, 54)]:
            setattr (self, name, Color ("%02x%02x%02x" % (r, g, b,)))

class ColorTheme (object):

    def __init__ (self):

        self.colors = {}

    def add_color (self, key, fg_color, bg_color = None, bg_color2 = None):

        self.colors[key] = (fg_color, bg_color, bg_color2,)

    def colors_float (self, key):

        return tuple ((self.hex_string_to_floats (color)
                       for color in self.colors[key]))

    @staticmethod
    def hex_string_to_floats (s):

        if s.startswith ("#"):
            s = s[1:]
        return tuple ((float (int (hs, 16)) / 255. for hs in (s[:2], s[2:4], s[4:],)))

class LevelColorTheme (ColorTheme):

    pass

class LevelColorThemeTango (LevelColorTheme):

    def __init__ (self):

        LevelColorTheme.__init__ (self)

        self.add_color (Data.debug_level_none, None, None, None)
        self.add_color (Data.debug_level_log, "#000000", "#ad7fa8", "#e0a4d9")
        self.add_color (Data.debug_level_debug, "#000000", "#729fcf", "#8cc4ff")
        self.add_color (Data.debug_level_info, "#000000", "#8ae234", "#9dff3b")
        self.add_color (Data.debug_level_warning, "#000000", "#fcaf3e", "#ffc266")
        self.add_color (Data.debug_level_error, "#ffffff", "#ef2929", "#ff4545")

class ThreadColorTheme (ColorTheme):

    pass

class ThreadColorThemeTango (ThreadColorTheme):

    def __init__ (self):

        ThreadColorTheme.__init__ (self)

        t = TangoPalette.get ()
        for i, color in enumerate ([t.butter2,
                                    t.orange2,
                                    t.chocolate3,
                                    t.chameleon2,
                                    t.skyblue1,
                                    t.plum1,
                                    t.scarletred1,
                                    t.aluminium6]):
            self.add_color (i, color)

class LogModelBase (gtk.GenericTreeModel):

    __metaclass__ = Common.GUI.MetaModel

    columns = ("COL_TIME", gobject.TYPE_UINT64,
               "COL_PID", int,
               "COL_THREAD", gobject.TYPE_UINT64,
               "COL_LEVEL", object,               
               "COL_CATEGORY", str,
               "COL_FILENAME", str,
               "COL_LINE_NUMBER", int,
               "COL_FUNCTION", str,
               "COL_OBJECT", str,
               "COL_MESSAGE", str,)

    def __init__ (self):

        gtk.GenericTreeModel.__init__ (self)

        ##self.props.leak_references = False

        self.line_offsets = []
        self.line_levels = [] # FIXME: Not so nice!
        self.line_cache = {}

    def ensure_cached (self, line_offset):

        raise NotImplementedError ("derived classes must override this method")

    def access_offset (self, offset):

        raise NotImplementedError ("derived classes must override this method")

    def iter_rows_offset (self):

        for i, offset in enumerate (self.line_offsets):
            self.ensure_cached (offset)
            row = self.line_cache[offset]
            row[self.COL_LEVEL] = self.line_levels[i] # FIXME
            yield (row, offset,)

    def on_get_flags (self):

        flags = gtk.TREE_MODEL_LIST_ONLY | gtk.TREE_MODEL_ITERS_PERSIST

        return flags

    def on_get_n_columns (self):
        
        return len (self.column_types)

    def on_get_column_type (self, col_id):

        return self.column_types[col_id]

    def on_get_iter (self, path):

        if not path:
            return

        if len (path) > 1:
            # Flat model.
            return None

        line_index = path[0]

        if line_index > len (self.line_offsets) - 1:
            return None

        return line_index

    def on_get_path (self, rowref):

        line_index = rowref

        return (line_index,)

    def on_get_value (self, line_index, col_id):

        last_index = len (self.line_offsets) - 1

        if line_index > last_index:
            return None

        if col_id == self.COL_LEVEL:
            return self.line_levels[line_index]

        line_offset = self.line_offsets[line_index]
        self.ensure_cached (line_offset)

        value = self.line_cache[line_offset][col_id]
        if col_id == self.COL_MESSAGE:
            message_offset = value
            value = self.access_offset (line_offset + message_offset).strip ()

        return value

    def on_iter_next (self, line_index):

        last_index = len (self.line_offsets) - 1

        if line_index >= last_index:
            return None
        else:
            return line_index + 1

    def on_iter_children (self, parent):

        return self.on_iter_nth_child (parent, 0)

    def on_iter_has_child (self, rowref):

        return False

    def on_iter_n_children (self, rowref):

        if rowref is not None:
            return 0

        return len (self.line_offsets)

    def on_iter_nth_child (self, parent, n):

        last_index = len (self.line_offsets) - 1

        if parent or n > last_index:
            return None

        return n

    def on_iter_parent (self, child):

        return None

    ## def on_ref_node (self, rowref):

    ##     pass

    ## def on_unref_node (self, rowref):

    ##     pass

class LazyLogModel (LogModelBase):

    def __init__ (self, log_obj = None):

        LogModelBase.__init__ (self)

        self.__log_obj = log_obj

        if log_obj:
            self.set_log (log_obj)

    def set_log (self, log_obj):

        self.__fileobj = log_obj.fileobj

        self.line_cache.clear ()
        self.line_offsets = log_obj.line_cache.offsets
        self.line_levels = log_obj.line_cache.levels

    def access_offset (self, offset):

        # TODO: Implement using one slice access instead of seek+readline.
        self.__fileobj.seek (offset)
        return self.__fileobj.readline ()

    def ensure_cached (self, line_offset):

        if line_offset in self.line_cache:
            return

        if len (self.line_cache) > 10000:
            self.line_cache.clear ()

        self.__fileobj.seek (line_offset)
        line = self.__fileobj.readline ()

        self.line_cache[line_offset] = Data.LogLine.parse_full (line)

class FilteredLogModelBase (LogModelBase):

    def __init__ (self, super_model):

        LogModelBase.__init__ (self)

        self.logger = logging.getLogger ("filter-model-base")

        self.super_model = super_model
        self.access_offset = super_model.access_offset
        self.ensure_cached = super_model.ensure_cached
        self.line_cache = super_model.line_cache    

    def line_index_to_super (self, line_index):

        raise NotImplementedError ("index conversion not supported")

    def line_index_from_super (self, super_line_index):

        raise NotImplementedError ("index conversion not supported")

    def line_index_to_top (self, line_index):

        _log_indices = [line_index]
        
        super_index = line_index
        for model in self._iter_hierarchy ():
            super_index = model.line_index_to_super (super_index)
            _log_indices.append (super_index)

        _log_trans = " -> ".join ([str (x) for x in _log_indices])
        self.logger.debug ("translated index to top: %s", _log_trans)

        return super_index

    def line_index_from_top (self, super_index):

        _log_indices = [super_index]

        line_index = super_index
        for model in reversed (list (self._iter_hierarchy ())):
            line_index = model.line_index_from_super (line_index)
            _log_indices.append (line_index)

        _log_trans = " -> ".join ([str (x) for x in _log_indices])
        self.logger.debug ("translated index from top: %s", _log_trans)

        return line_index

    def super_model_changed (self):

        pass

    def _iter_hierarchy (self):

        model = self
        while hasattr (model, "super_model") and model.super_model:
            yield model
            model = model.super_model

class FilteredLogModelIdentity (FilteredLogModelBase):

    def __init__ (self, super_model):

        FilteredLogModelBase.__init__ (self, super_model)

        self.line_offsets = self.super_model.line_offsets
        self.line_levels = self.super_model.line_levels

    def line_index_from_super (self, super_line_index):

        return super_line_index

    def line_index_to_super (self, line_index):

        return line_index

class FilteredLogModel (FilteredLogModelBase):

    def __init__ (self, super_model):

        FilteredLogModelBase.__init__ (self, super_model)

        self.logger = logging.getLogger ("filtered-log-model")

        self.filters = []
        self.super_index = []
        self.from_super_index = {}
        self.reset ()
        self.__active_process = None
        self.__filter_progress = 0.
        
    def reset (self):

        del self.line_offsets[:]
        self.line_offsets += self.super_model.line_offsets
        del self.line_levels[:]
        self.line_levels += self.super_model.line_levels

        del self.super_index[:]
        self.from_super_index.clear ()

        del self.filters[:]

    def __filter_process (self, filter):

        YIELD_LIMIT = 10000

        self.logger.debug ("preparing new filter")
        self.filters.append (filter)
        ## del self.line_offsets[:]
        ## del self.line_levels[:]
        new_line_offsets = []
        new_line_levels = []
        new_super_index = []
        new_from_super_index = {}
        level_id = self.COL_LEVEL
        func = filter.filter_func
        if len (self.filters) == 1:
            # This is the first filter that gets applied.
            def enum ():
                i = 0
                for row, offset in self.iter_rows_offset ():
                    yield (i, row, offset,)
                    i += 1
        else:
            def enum ():
                i = 0
                for row, offset in self.iter_rows_offset ():
                    line_index = self.super_index[i]
                    yield (line_index, row, offset,)
                    i += 1
        self.logger.debug ("running filter")
        progress = 0.
        progress_full = float (len (self))
        y = YIELD_LIMIT
        for i, row, offset in enum ():
            if func (row):
                new_line_offsets.append (offset)
                new_line_levels.append (row[level_id])
                new_super_index.append (i)
                new_from_super_index[i] = len (new_super_index) - 1
            y -= 1
            if y == 0:
                progress += float (YIELD_LIMIT)
                self.__filter_progress = progress / progress_full
                y = YIELD_LIMIT
                yield True
        self.line_offsets = new_line_offsets
        self.line_levels = new_line_levels
        self.super_index = new_super_index
        self.from_super_index = new_from_super_index
        self.logger.debug ("filtering finished")

        self.__filter_progress = 1.
        self.__handle_filter_process_finished ()
        yield False

    def add_filter (self, filter, dispatcher):

        if self.__active_process is not None:
            raise ValueError ("dispatched a filter process already")

        self.__dispatcher = dispatcher
        self.__active_process = self.__filter_process (filter)
        dispatcher (self.__active_process)

    def abort_process (self):

        if self.__active_process is None:
            return

        self.__dispatcher.cancel ()
        self.__active_process = None
        self.__dispatcher = None

    def get_filter_progress (self):

        if self.__active_process is None:
            raise ValueError ("no filter process running")

        return self.__filter_progress

    def __handle_filter_process_finished (self):

        self.__active_process = None
        self.handle_process_finished ()

    def handle_process_finished (self):

        pass

    def line_index_from_super (self, super_line_index):

        if len (self.filters) == 0:
            # Identity.
            return super_line_index

        try:
            return self.from_super_index[super_line_index]
        except KeyError:
            raise IndexError ("super index %i not handled" % (super_line_index,))

    def line_index_to_super (self, line_index):

        if len (self.filters) == 0:
            # Identity.
            return line_index

        return self.super_index[line_index]

    def super_model_changed_range (self):

        range_model = self.super_model
        super_start, super_end = range_model.line_index_range

        # FIXME: This is too simple!
        start_index = self.line_index_from_super (super_start)
        end_index = self.line_index_from_super (super_end)

        last_index = len (self.line_offsets) - 1
        if end_index < last_index:
            self.__remove_range (end_index + 1, last_index)

        if start_index > 0:
            self.__remove_range (0, start_index - 1)

    def __remove_range (self, start, end):

        self.logger.debug ("removing line range first = %i, last = %i",
                           start, end)
        del self.line_offsets[start:end + 1]
        del self.line_levels[start:end + 1]
        for super_index in self.super_index[start:end + 1]:
            del self.from_super_index[super_index]
        del self.super_index[start:end + 1]
        if start == 0:
            for super_index in self.super_index:
                self.from_super_index[super_index] -= end

class Filter (object):

    pass

class DebugLevelFilter (Filter):

    def __init__ (self, debug_level):

        col_id = LogModelBase.COL_LEVEL
        def filter_func (row):
            return row[col_id] != debug_level
        self.filter_func = filter_func

class CategoryFilter (Filter):

    def __init__ (self, category):

        col_id = LogModelBase.COL_CATEGORY
        def category_filter_func (row):
            return row[col_id] != category
        self.filter_func = category_filter_func

class SubRange (object):

    def __init__ (self, l, start, end):

        if start > end:
            raise ValueError ("need start <= end")

        self.l = l
        self.start = start
        self.end = end

    def __getitem__ (self, i):

        return self.l[i + self.start]

    def __len__ (self):

        return self.end - self.start + 1

    def __iter__ (self):

        # FIXME: Use itertools, should be faster!
        l = self.l
        i = self.start
        while i <= self.end:
            yield l[i]
            i += 1

class RangeFilteredLogModel (FilteredLogModelBase):

    def __init__ (self, super_model):

        FilteredLogModelBase.__init__ (self, super_model)

        self.logger = logging.getLogger ("range-filtered-model")

        self.line_index_range = None

    def set_range (self, start_index, last_index):

        self.logger.debug ("setting range to first = %i, last = %i",
                           start_index, last_index)

        self.line_index_range = (start_index, last_index,)
        self.line_offsets = SubRange (self.super_model.line_offsets,
                                      start_index, last_index)
        self.line_levels = SubRange (self.super_model.line_levels,
                                     start_index, last_index)

    def reset (self):

        self.logger.debug ("reset")

        first_index = 0
        last_index = len (self.super_model) - 1

        self.set_range (first_index, last_index,)

    def line_index_to_super (self, line_index):

        start_index = self.line_index_range[0]

        return line_index + start_index

    def line_index_from_super (self, li):

        start, end = self.line_index_range

        if li < start or li > end:
            raise IndexError ("not in range")

        return li - start

# Sync with gst-inspector!
class Column (object):

    """A single list view column, managed by a ColumnManager instance."""

    name = None
    id = None
    label_header = None
    get_modify_func = None
    get_data_func = None
    get_row_data_func = None
    get_sort_func = None

    def __init__ (self):

        view_column = gtk.TreeViewColumn (self.label_header)
        view_column.props.reorderable = True

        self.view_column = view_column

class SizedColumn (Column):

    default_size = None

    def compute_default_size (self, view, model):

        return None

# Sync with gst-inspector?
class TextColumn (SizedColumn):

    font_family = None

    def __init__ (self):

        Column.__init__ (self)

        column = self.view_column
        cell = gtk.CellRendererText ()
        column.pack_start (cell)

        cell.props.yalign = 0.

        if self.font_family:
            cell.props.family = self.font_family
            cell.props.family_set = True

        if self.get_data_func:
            data_func = self.get_data_func ()
            assert data_func
            id_ = self.id
            if id_ is not None:
                def cell_data_func (column, cell, model, tree_iter):
                    data_func (cell.props, model.get_value (tree_iter, id_), model.get_path (tree_iter))
            else:
                cell_data_func = data_func
            column.set_cell_data_func (cell, cell_data_func)
        elif self.get_row_data_func:
            data_func = self.get_row_data_func ()
            assert data_func
            def cell_data_func (column, cell, model, tree_iter):
                data_func (cell.props, model[tree_iter])
            column.set_cell_data_func (cell, cell_data_func)
        elif not self.get_modify_func:
            column.add_attribute (cell, "text", self.id)
        else:
            modify_func = self.get_modify_func ()
            id_ = self.id
            def cell_data_func (column, cell, model, tree_iter):
                cell.props.text = modify_func (model.get (tree_iter, id_)[0])
            column.set_cell_data_func (cell, cell_data_func)

        column.props.resizable = True

    def compute_default_size (self, view, model):

        values = self.get_values_for_size ()
        if not values:
            return SizedColumn.compute_default_size (self, view, model)

        cell = self.view_column.get_cell_renderers ()[0]

        if self.get_modify_func is not None:
            format = self.get_modify_func ()
        else:
            def identity (x):
                return x
            format = identity
        max_width = 0
        for value in values:
            cell.props.text = format (value)
            rect, x, y, w, h = self.view_column.cell_get_size ()
            max_width = max (max_width, w)

        return max_width

    def get_values_for_size (self):

        return ()

class TimeColumn (TextColumn):

    name = "time"
    label_header = _("Time")
    id = LazyLogModel.COL_TIME
    font_family = "monospace"

    @staticmethod
    def get_modify_func ():

        time_args = Data.time_args
        def format_time (value):
            # TODO: This is hard coded to omit hours as well as the last 3
            # digits at the end, since current gst uses g_get_current_time,
            # which has microsecond precision only.
            return time_args (value)[2:-3]

        return format_time

    def get_values_for_size (self):

        values = [0]

        return values

class LevelColumn (TextColumn):

    name = "level"
    label_header = _("L")
    id = LazyLogModel.COL_LEVEL

    def __init__ (self):

        TextColumn.__init__ (self)

        cell = self.view_column.get_cell_renderers ()[0]
        cell.props.xalign = .5

    @staticmethod
    def get_modify_func ():

        def format_level (value):
            return value.name[0]

        return format_level

    @staticmethod
    def get_data_func ():

        theme = LevelColorThemeTango ()
        colors = theme.colors
        def level_data_func (cell_props, level, path):
            cell_props.text = level.name[0]
            cell_colors = colors[level]
            # FIXME: Use GdkColors!
            cell_props.foreground = cell_colors[0]
            if path[0] % 2:
                cell_props.background = cell_colors[1]
            else:
                cell_props.background = cell_colors[2]

        return level_data_func

    def get_values_for_size (self):

        values = [Data.debug_level_log, Data.debug_level_debug,
                  Data.debug_level_info, Data.debug_level_warning,
                  Data.debug_level_error]

        return values

class PidColumn (TextColumn):

    name = "pid"
    label_header = _("PID")
    id = LazyLogModel.COL_PID
    font_family = "monospace"

    @staticmethod
    def get_modify_func ():

        return str

    def get_values_for_size (self):

        return ["999999"]

class ThreadColumn (TextColumn):

    name = "thread"
    label_header = _("Thread")
    id = LazyLogModel.COL_THREAD
    font_family = "monospace"

    @staticmethod
    def get_modify_func ():

        def format_thread (value):
            return "0x%07x" % (value,)

        return format_thread

    def get_values_for_size (self):

        return [int ("ffffff", 16)]

class CategoryColumn (TextColumn):

    name = "category"
    label_header = _("Category")
    id = LazyLogModel.COL_CATEGORY

    def get_values_for_size (self):

        return ["GST_LONG_CATEGORY", "somelongelement"]

class CodeColumn (TextColumn):

    name = "code"
    label_header = _("Code")
    id = None

    @staticmethod
    def get_data_func ():

        filename_id = LogModelBase.COL_FILENAME
        line_number_id = LogModelBase.COL_LINE_NUMBER
        def filename_data_func (column, cell, model, tree_iter):
            args = model.get (tree_iter, filename_id, line_number_id)
            cell.props.text = "%s:%i" % args

        return filename_data_func

    def get_values_for_size (self):

        return ["gstsomefilename.c:1234"]

class FunctionColumn (TextColumn):

    name = "function"
    label_header = _("Function")
    id = LazyLogModel.COL_FUNCTION

    def get_values_for_size (self):

        return ["gst_this_should_be_enough"]

class ObjectColumn (TextColumn):

    name = "object"
    label_header = _("Object")
    id = LazyLogModel.COL_OBJECT

    def get_values_for_size (self):

        return ["longobjectname00"]

class MessageColumn (TextColumn):

    name = "message"
    label_header = _("Message")
    id = LazyLogModel.COL_MESSAGE

    def __init__ (self, *a, **kw):

        self.highlighters = {}

        TextColumn.__init__ (self, *a, **kw)

    def get_row_data_func (self):

        from pango import AttrList, AttrBackground, AttrForeground
        highlighters = self.highlighters
        id_ = self.id

        # FIXME: This should be none; need to investigate
        # `cellrenderertext.props.attributes = None' failure (param conversion
        # error like `treeview.props.model = None').
        no_attrs = AttrList ()

        def message_data_func (props, row):

            props.text = row[id_]
            if not highlighters:
                props.attributes = no_attrs
            for highlighter in highlighters.values ():
                ranges = highlighter (row)
                if not ranges:
                    props.attributes = no_attrs
                else:
                    attrlist = AttrList ()
                    for start, end in ranges:
                        attrlist.insert (AttrBackground (0, 0, 65535, start, end))
                        attrlist.insert (AttrForeground (65535, 65535, 65535, start, end))
                    props.attributes = attrlist

        return message_data_func

    def get_values_for_size (self):

        values = ["Just some good minimum size"]

        return values

class ColumnManager (Common.GUI.Manager):

    column_classes = ()

    @classmethod
    def iter_item_classes (cls):

        return iter (cls.column_classes)

    def __init__ (self):

        self.view = None
        self.actions = None
        self.__columns_changed_id = None
        self.columns = []
        self.column_order = list (self.column_classes)

        self.action_group = gtk.ActionGroup ("ColumnActions")

        def make_entry (col_class):
            return ("show-%s-column" % (col_class.name,),
                    None,
                    col_class.label_header,
                    None,
                    None,
                    None,
                    True,)

        entries = [make_entry (cls) for cls in self.column_classes]
        self.action_group.add_toggle_actions (entries)

    def iter_items (self):

        return iter (self.columns)

    def attach (self):

        for col_class in self.column_classes:
            action = self.get_toggle_action (col_class)
            if action.props.active:
                self._add_column (col_class ())
            action.connect ("toggled",
                            self.__handle_show_column_action_toggled,
                            col_class.name)

        self.__columns_changed_id = self.view.connect ("columns-changed",
                                                       self.__handle_view_columns_changed)

    def detach (self):

        if self.__columns_changed_id is not None:
            self.view.disconnect (self.__columns_changed_id)
            self.__columns_changed_id = None

    def attach_sort (self):

        sort_model = self.view.props.model

        # Inform the sorted tree model of any custom sorting functions.
        for col_class in self.column_classes:
            if col_class.get_sort_func:
                sort_func = col_class.get_sort_func ()
                sort_model.set_sort_func (col_class.id, sort_func)

    def enable_sort (self):

        sort_model = self.view.props.model

        if sort_model:
            self.logger.debug ("activating sort")
            sort_model.set_sort_column_id (*self.default_sort)
            self.default_sort = None
        else:
            self.logger.debug ("not activating sort (no model set)")

    def disable_sort (self):

        self.logger.debug ("deactivating sort")

        sort_model = self.view.props.model

        self.default_sort = tree_sortable_get_sort_column_id (sort_model)

        sort_model.set_sort_column_id (TREE_SORTABLE_UNSORTED_COLUMN_ID,
                                       gtk.SORT_ASCENDING)

    def get_toggle_action (self, column_class):

        action_name = "show-%s-column" % (column_class.name,)
        return self.action_group.get_action (action_name)

    def get_initial_column_order (self):

        return tuple (self.column_classes)

    def _add_column (self, column):

        name = column.name
        pos = self.__get_column_insert_position (column)
        if self.view.props.fixed_height_mode:
            column.view_column.props.sizing = gtk.TREE_VIEW_COLUMN_FIXED
        self.columns.insert (pos, column)
        self.view.insert_column (column.view_column, pos)

    def _remove_column (self, column):

        self.columns.remove (column)
        self.view.remove_column (column.view_column)

    def __get_column_insert_position (self, column):

        col_class = self.find_item_class (name = column.name)
        pos = self.column_order.index (col_class)
        before = self.column_order[:pos]
        shown_names = [col.name for col in self.columns]
        for col_class in before:
            if not col_class.name in shown_names:
                pos -= 1
        return pos

    def __iter_next_hidden (self, column_class):

        pos = self.column_order.index (column_class)
        rest = self.column_order[pos + 1:]
        for next_class in rest:
            try:
                self.find_item (name = next_class.name)
            except KeyError:
                # No instance -- the column is hidden.
                yield next_class
            else:
                break

    def __handle_show_column_action_toggled (self, toggle_action, name):

        if toggle_action.props.active:
            try:
                # This should fail.
                column = self.find_item (name = name)
            except KeyError:
                col_class = self.find_item_class (name = name)
                self._add_column (col_class ())
            else:
                # Out of sync for some reason.
                return
        else:
            try:
                column = self.find_item (name = name)
            except KeyError:
                # Out of sync for some reason.
                return
            else:
                self._remove_column (column)

    def __handle_view_columns_changed (self, element_view):

        view_columns = element_view.get_columns ()
        new_visible = [self.find_item (view_column = column)
                       for column in view_columns]

        # We only care about reordering here.
        if len (new_visible) != len (self.columns):
            return

        if new_visible != self.columns:

            new_order = []
            for column in new_visible:
                col_class = self.find_item_class (name = column.name)
                new_order.append (col_class)
                new_order.extend (self.__iter_next_hidden (col_class))
            
            names = (column.name for column in new_visible)
            self.logger.debug ("visible columns reordered: %s",
                               ", ".join (names))

            self.columns[:] = new_visible
            self.column_order[:] = new_order

class ViewColumnManager (ColumnManager):

    column_classes = (TimeColumn, LevelColumn, PidColumn, ThreadColumn, CategoryColumn,
                      CodeColumn, FunctionColumn, ObjectColumn, MessageColumn,)

    def __init__ (self, state):

        ColumnManager.__init__ (self)

        self.logger = logging.getLogger ("ui.columns")

        self.state = state

    def attach (self, view):

        self.view = view
        view.connect ("notify::model", self.__handle_notify_model)

        order = self.state.column_order
        if len (order) == len (self.column_classes):
            self.column_order[:] = order

        visible = self.state.columns_visible
        if not visible:
            visible = self.column_classes
        for col_class in self.column_classes:
            action = self.get_toggle_action (col_class)
            action.props.active = (col_class in visible)

        ColumnManager.attach (self)

        self.columns_sized = False

    def detach (self):

        self.state.column_order = self.column_order
        self.state.columns_visible = self.columns

        return ColumnManager.detach (self)

    def size_column (self, column, view, model):

        if column.default_size is None:
            default_size = column.compute_default_size (view, model)
        else:
            default_size = column.default_size
        # FIXME: Abstract away fixed size setting in Column class!
        if default_size is None:
            # Dummy fallback:
            column.view_column.props.fixed_width = 50
            self.logger.warning ("%s column does not implement default size", column.name)
        else:
            column.view_column.props.fixed_width = default_size

    def _add_column (self, column):

        result = ColumnManager._add_column (self, column)
        model = self.view.props.model
        self.size_column (column, self.view, model)
        return result

    def _remove_column (self, column):

        column.default_size = column.view_column.props.fixed_width
        return ColumnManager._remove_column (self, column)

    def __handle_notify_model (self, view, gparam):

        if self.columns_sized:
            # Already sized.
            return
        model = self.view.props.model
        if model is None:
            return
        self.logger.debug ("model changed, sizing columns")
        for column in self.iter_items ():
            self.size_column (column, view, model)
        self.columns_sized = True

class LineViewLogModel (FilteredLogModel):

    def __init__ (self, super_model):

        FilteredLogModel.__init__ (self, super_model)

        self.line_offsets = []
        self.line_levels = []

        self.parent_indices = []

    def reset (self):

        del self.line_offsets[:]
        del self.line_levels[:]

    def line_index_to_super (self, line_index):

        return self.parent_indices[line_index]

    def insert_line (self, position, super_line_index):

        if position == -1:
            position = len (self.line_offsets)
        li = super_line_index
        self.line_offsets.insert (position, self.super_model.line_offsets[li])
        self.line_levels.insert (position, self.super_model.line_levels[li])
        self.parent_indices.insert (position, super_line_index)

        path = (position,)
        tree_iter = self.get_iter (path)
        self.row_inserted (path, tree_iter)

    def replace_line (self, line_index, super_line_index):

        li = line_index
        self.line_offsets[li] = self.super_model.line_offsets[super_line_index]
        self.line_levels[li] = self.super_model.line_levels[super_line_index]
        self.parent_indices[li] = super_line_index

        path = (line_index,)
        tree_iter = self.get_iter (path)
        self.row_changed (path, tree_iter)

    def remove_line (self, line_index):

        for l in (self.line_offsets,
                  self.line_levels,
                  self.parent_indices,):
            del l[line_index]

        path = (line_index,)
        self.row_deleted (path)

class WrappingMessageColumn (MessageColumn):

    def wrap_to_width (self, width):

        col = self.view_column
        col.props.max_width = width
        col.get_cells ()[0].props.wrap_width = width
        col.queue_resize ()

class LineViewColumnManager (ColumnManager):

    column_classes = (TimeColumn, WrappingMessageColumn,)

    def __init__ (self):

        ColumnManager.__init__ (self)

    def attach (self, window):

        self.__size_update = None

        self.view = window.widgets.line_view
        self.view.set_size_request (0, 0)
        self.view.connect_after ("size-allocate", self.__handle_size_allocate)
        ColumnManager.attach (self)

    def __update_sizes (self):

        view_width = self.view.get_allocation ().width
        if view_width == self.__size_update:
            # Prevent endless recursion.
            return

        self.__size_update = view_width

        col = self.find_item (name = "time")
        other_width = col.view_column.props.width

        try:
            col = self.find_item (name = "message")
        except KeyError:
            return

        width = view_width - other_width
        col.wrap_to_width (width)

    def __handle_size_allocate (self, self_, allocation):

        self.__update_sizes ()

class LineView (object):

    def __init__ (self):

        self.column_manager = LineViewColumnManager ()

    def attach (self, window):

        self.clear_action = window.actions.clear_line_view
        handler = self.handle_clear_line_view_action_activate
        self.clear_action.connect ("activate", handler)

        self.line_view = window.widgets.line_view
        self.line_view.connect ("row-activated", self.handle_line_view_row_activated)

        ui = window.ui_manager
        self.popup = ui.get_widget ("/ui/context/LineViewContextMenu").get_submenu ()
        Common.GUI.widget_add_popup_menu (self.line_view, self.popup)

        self.log_view = log_view = window.log_view
        log_view.connect ("row-activated", self.handle_log_view_row_activated)
        sel = log_view.get_selection ()
        sel.connect ("changed", self.handle_log_view_selection_changed)

        self.clear_action.props.sensitive = False
        self.column_manager.attach (window)

    def clear (self):

        model = self.line_view.props.model

        if len (model) == 0:
            return

        for i in range (1, len (model)):
            model.remove_line (1)

        self.clear_action.props.sensitive = False

    def handle_attach_log_file (self, window):

        self.line_view.props.model = LineViewLogModel (window.log_model)

    def handle_line_view_row_activated (self, view, path, column):

        line_index = path[0]
        line_model = view.props.model
        parent_index = line_model.line_index_to_super (line_index)
        path = (parent_index,)
        self.log_view.scroll_to_cell (path, use_align = True, row_align = .5)
        sel = self.log_view.get_selection ()
        sel.select_path (path)

    def handle_log_view_row_activated (self, view, path, column):

        log_model = view.props.model
        line_index = path[0]

        super_line_index = log_model.line_index_to_super (line_index)
        line_model = self.line_view.props.model
        if line_model is None:
            return

        if len (line_model):
            timestamps = [row[line_model.COL_TIME] for row in line_model]
            row = log_model[(line_index,)]
            from bisect import bisect_right
            position = bisect_right (timestamps, row[line_model.COL_TIME])
        else:
            position = 0
        if len (line_model) > 1:
            other_index = line_model.line_index_to_super (position - 1)
        else:
            other_index = -1
        if other_index == super_line_index and position != 1:
            # Already have the line.
            pass
        else:
            line_model.insert_line (position, super_line_index)
            self.clear_action.props.sensitive = True

    def handle_log_view_selection_changed (self, selection):

        model, tree_iter = selection.get_selected ()

        if tree_iter is None:
            return

        path = model.get_path (tree_iter)
        line_index = model.line_index_to_super (path[0])

        line_model = self.line_view.props.model
        if line_model is None:
            return
        if len (line_model) == 0:
            line_model.insert_line (0, line_index)
        else:
            line_model.replace_line (0, line_index)

    def handle_clear_line_view_action_activate (self, action):

        self.clear ()

class ProgressDialog (object):

    def __init__ (self, window, title = ""):

        widgets = window.widget_factory.make ("progress_dialog")
        dialog = widgets.progress_dialog
        dialog.connect ("response", self.__handle_dialog_response)

        self.__dialog = dialog
        self.__progress_bar = widgets.progress_bar
        self.__progress_bar.props.text = title

        dialog.set_transient_for (window.gtk_window)
        dialog.show ()

    def __handle_dialog_response (self, dialog, resp):

        self.handle_cancel ()

    def handle_cancel (self):

        pass

    def update (self, progress):

        if self.__progress_bar is None:
            return

        self.__progress_bar.props.fraction = progress

    def destroy (self):

        if self.__dialog is None:
            return
        self.__dialog.destroy ()
        self.__dialog = None
        self.__progress_bar = None

class Window (object):

    def __init__ (self, app):

        self.logger = logging.getLogger ("ui.window")
        self.app = app

        self.dispatcher = None
        self.progress_dialog = None
        self.update_progress_id = None

        self.window_state = Common.GUI.WindowState ()
        self.column_manager = ViewColumnManager (app.state_section)

        self.actions = Common.GUI.Actions ()

        group = gtk.ActionGroup ("MenuActions")
        group.add_actions ([("FileMenuAction", None, _("_File")),
                            ("ViewMenuAction", None, _("_View")),
                            ("ViewColumnsMenuAction", None, _("_Columns")),
                            ("HelpMenuAction", None, _("_Help")),
                            ("LineViewContextMenuAction", None, "")])
        self.actions.add_group (group)

        group = gtk.ActionGroup ("WindowActions")
        group.add_actions ([("new-window", gtk.STOCK_NEW, _("_New Window"), "<Ctrl>N"),
                            ("open-file", gtk.STOCK_OPEN, _("_Open File"), "<Ctrl>O"),
                            ("reload-file", gtk.STOCK_REFRESH, _("_Reload File"), "<Ctrl>R"),
                            ("close-window", gtk.STOCK_CLOSE, _("Close _Window"), "<Ctrl>W"),
                            ("cancel-load", gtk.STOCK_CANCEL, None,),
                            ("clear-line-view", gtk.STOCK_CLEAR, None),
                            ("show-about", gtk.STOCK_ABOUT, None)])
        self.actions.add_group (group)
        self.actions.reload_file.props.sensitive = False

        group = gtk.ActionGroup ("RowActions")
        group.add_actions ([("hide-before-line", None, _("Hide lines before this one")),
                            ("hide-after-line", None, _("Hide lines after this one")),
                            ("show-hidden-lines", None, _("Show hidden lines")),
                            ("edit-copy-line", gtk.STOCK_COPY, _("Copy line"), "<Ctrl>C"),
                            ("edit-copy-message", gtk.STOCK_COPY, _("Copy message"), ""),
                            ("hide-log-level", None, _("Hide log level")),
                            ("hide-log-category", None, _("Hide log category")),
                            ("hide-log-object", None, _("Hide object"))])
        group.props.sensitive = False
        self.actions.add_group (group)

        self.actions.hide_log_object.props.visible = False

        self.actions.add_group (self.column_manager.action_group)

        self.log_file = None
        self.setup_model (LazyLogModel ())

        glade_filename = os.path.join (Main.Paths.data_dir, "gst-debug-viewer.glade")
        self.widget_factory = Common.GUI.WidgetFactory (glade_filename)
        self.widgets = self.widget_factory.make ("main_window")

        ui_filename = os.path.join (Main.Paths.data_dir,
                                    "gst-debug-viewer.ui")
        self.ui_factory = Common.GUI.UIFactory (ui_filename, self.actions)

        self.ui_manager = ui = self.ui_factory.make ()
        menubar = ui.get_widget ("/ui/menubar")        
        self.widgets.vbox_main.pack_start (menubar, False, False, 0)

        self.gtk_window = self.widgets.main_window
        self.gtk_window.add_accel_group (ui.get_accel_group ())
        self.log_view = self.widgets.log_view
        self.log_view.drag_dest_unset ()
        self.log_view.set_search_column (-1)

        self.view_popup = ui.get_widget ("/ui/menubar/ViewMenu").get_submenu ()
        Common.GUI.widget_add_popup_menu (self.log_view, self.view_popup)

        self.line_view = LineView ()

        self.attach ()
        self.column_manager.attach (self.log_view)

    def setup_model (self, model, filter = False):

        self.log_model = model
        self.log_range = RangeFilteredLogModel (self.log_model)
        if filter:
            self.log_filter = FilteredLogModel (self.log_range)
            self.log_filter.handle_process_finished = self.handle_log_filter_process_finished
        else:
            self.log_filter = None

    def get_top_attach_point (self):

        return self.widgets.vbox_main

    def get_side_attach_point (self):

        return self.widgets.hbox_view

    def attach (self):

        self.window_state.attach (window = self.gtk_window,
                                  state = self.app.state_section)

        self.clipboard = gtk.Clipboard (self.gtk_window.get_display (),
                                        gtk.gdk.SELECTION_CLIPBOARD)

        for action_name in ("new-window", "open-file", "reload-file",
                            "close-window", "cancel-load",
                            "hide-before-line", "hide-after-line", "show-hidden-lines",
                            "edit-copy-line", "edit-copy-message",
                            "hide-log-level", "hide-log-category", "hide-log-object",
                            "show-about",):
            name = action_name.replace ("-", "_")
            action = getattr (self.actions, name)
            handler = getattr (self, "handle_%s_action_activate" % (name,))
            action.connect ("activate", handler)

        self.gtk_window.connect ("delete-event", self.handle_window_delete_event)

        self.features = []

        for plugin_feature in self.app.iter_plugin_features ():
            feature = plugin_feature (self.app)
            self.features.append (feature)

        for feature in self.features:
            feature.handle_attach_window (self)

        # FIXME: With multiple selection mode, browsing the list with key
        # up/down slows to a crawl! WTF is wrong with this stupid widget???
        sel = self.log_view.get_selection ()
        sel.set_mode (gtk.SELECTION_BROWSE)

        self.line_view.attach (self)

        self.gtk_window.show ()

    def detach (self):

        self.set_log_file (None)
        for feature in self.features:
            feature.handle_detach_window (self)

        self.window_state.detach ()
        self.column_manager.detach ()

    def get_active_line_index (self):

        selection = self.log_view.get_selection ()
        model, tree_iter = selection.get_selected ()
        if tree_iter is None:
            raise ValueError ("no line selected")
        path = model.get_path (tree_iter)
        return path[0]

    def get_active_line (self):

        selection = self.log_view.get_selection ()
        model, tree_iter = selection.get_selected ()
        if tree_iter is None:
            raise ValueError ("no line selected")
        model = self.log_view.props.model
        return model.get (tree_iter, *LogModelBase.column_ids)

    def close (self, *a, **kw):

        self.logger.debug ("closing window, detaching")
        self.detach ()
        self.gtk_window.hide ()
        self.logger.debug ("requesting close from app")
        self.app.close_window (self)

    def push_view_state (self):

        self.default_index = None

        model = self.log_view.props.model
        if model is None:
            return
        
        try:
            line_index = self.get_active_line_index ()
        except ValueError:
            super_index = None
            self.logger.debug ("no line selected")
        else:
            super_index = model.line_index_to_top (line_index)
            self.logger.debug ("pushing selected line %i (abs %i)",
                               line_index, super_index)

        self.default_index = super_index

    def update_model (self, model = None):

        if model is None:
            model = self.log_view.props.model

        previous_model = self.log_view.props.model

        if previous_model == model:
            # Force update.
            self.log_view.set_model (None)
        self.log_view.props.model = model

    def pop_view_state (self):

        selected_index = self.default_index
        if selected_index is None:
            return

        model = self.log_view.props.model
        if model is None:
            return

        try:
            select_index = model.line_index_from_top (selected_index)
        except IndexError, exc:
            self.logger.debug ("abs line index %i filtered out, not reselecting",
                               selected_index)
        else:
            assert select_index >= 0
            sel = self.log_view.get_selection ()
            path = (select_index,)
            sel.select_path (path)

            # FIXME: Instead of scrolling to the selected row, try to restore
            # the previous visible range.
            self.log_view.scroll_to_cell (path, use_align = True, row_align = .5)

    def update_view (self):

        view = self.log_view
        model = view.props.model

        start_path, end_path = view.get_visible_range ()
        start_index, end_index = start_path[0], end_path[0]

        for line_index in range (start_index, end_index + 1):
            path = (line_index,)
            tree_iter = model.get_iter (path)
            model.row_changed (path, tree_iter)

    def handle_window_delete_event (self, window, event):

        self.actions.close_window.activate ()

    def handle_new_window_action_activate (self, action):

        pass

    def handle_open_file_action_activate (self, action):

        dialog = gtk.FileChooserDialog (None, self.gtk_window,
                                        gtk.FILE_CHOOSER_ACTION_OPEN,
                                        (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,
                                         gtk.STOCK_OPEN, gtk.RESPONSE_ACCEPT,))
        response = dialog.run ()
        dialog.hide ()
        if response == gtk.RESPONSE_ACCEPT:
            self.set_log_file (dialog.get_filename ())
        dialog.destroy ()

    def handle_reload_file_action_activate (self, action):

        if self.log_file is None:
            return

        self.set_log_file (self.log_file.path)

    def handle_cancel_load_action_activate (self, action):

        self.logger.debug ("cancelling data load")

        self.set_log_file (None)

        if self.progress_dialog:
            self.progress_dialog.destroy ()
            self.progress_dialog = None
        if self.update_progress_id is not None:
            gobject.source_remove (self.update_progress_id)
            self.update_progress_id = None

    def handle_close_window_action_activate (self, action):

        self.close ()

    def handle_hide_after_line_action_activate (self, action):

        self.hide_range (after = True)

    def handle_hide_before_line_action_activate (self, action):

        self.hide_range (after = False)

    def hide_range (self, after):

        model = self.log_view.props.model
        try:
            filtered_line_index = self.get_active_line_index ()
        except ValueError:
            return

        if after:
            first_index = model.line_index_to_top (0)
            last_index = model.line_index_to_top (filtered_line_index)

            self.logger.info ("hiding lines after %i (abs %i), first line is abs %i",
                              filtered_line_index,
                              last_index,
                              first_index)
        else:
            first_index = model.line_index_to_top (filtered_line_index)
            last_index = model.line_index_to_top (len (model) - 1)

            self.logger.info ("hiding lines before %i (abs %i), last line is abs %i",
                              filtered_line_index,
                              first_index,
                              last_index)

        self.push_view_state ()
        self.log_range.set_range (first_index, last_index)
        if self.log_filter:
            self.log_filter.super_model_changed_range ()
        self.update_model ()
        self.pop_view_state ()
        self.actions.show_hidden_lines.props.sensitive = True

    def handle_show_hidden_lines_action_activate (self, action):

        self.logger.info ("restoring model filter to show all lines")
        self.push_view_state ()
        self.log_range.reset ()
        self.log_filter = None
        self.update_model (self.log_range)
        self.pop_view_state ()
        self.actions.show_hidden_lines.props.sensitive = False

    def handle_edit_copy_line_action_activate (self, action):

        line_index = self.get_active_line_index ()
        line = self.log_file.get_full_line (line_index)

        # FIXME:
        level = self.log_filter[(line_index,)][LogModelBase.COL_LEVEL]
        line[LogModelBase.COL_LEVEL] = level

        self.clipboard.set_text (line.line_string ())

    def handle_edit_copy_message_action_activate (self, action):

        col_id = LogModelBase.COL_MESSAGE
        self.clipboard.set_text (self.get_active_line ()[col_id])

    def add_model_filter (self, filter):

        self.progress_dialog = ProgressDialog (self, _("Filtering"))
        self.progress_dialog.handle_cancel = self.handle_filter_progress_dialog_cancel
        dispatcher = Common.Data.GSourceDispatcher ()
        self.filter_dispatcher = dispatcher

        # FIXME: Unsetting the model to keep e.g. the dispatched timeline
        # sentinel from collecting data while we filter idly, which slows
        # things down for nothing.
        self.push_view_state ()
        self.log_view.set_model (None)
        if self.log_filter is None:
            self.log_filter = FilteredLogModel (self.log_range)
            self.log_filter.handle_process_finished = self.handle_log_filter_process_finished
        self.log_filter.add_filter (filter, dispatcher = dispatcher)

        gobject.timeout_add (250, self.update_filter_progress)

    def update_filter_progress (self):

        if self.progress_dialog is None:
            return False

        try:
            progress = self.log_filter.get_filter_progress ()
        except ValueError:
            self.logger.warning ("no filter process running")
            return False

        self.progress_dialog.update (progress)

        return True

    def handle_filter_progress_dialog_cancel (self):

        return

        self.progress_dialog.destroy ()
        self.progress_dialog = None

        # FIXME: Implement filter cancelling correctly; the stuff below does
        # not work.
        
        self.log_filter.abort_process ()
        self.log_filter.reset ()
        # FIXME:
        self.actions.show_hidden_lines.activate ()

    def handle_log_filter_process_finished (self):

        self.progress_dialog.destroy ()
        self.progress_dialog = None

        # No push_view_state here, did this in add_model_filter.
        self.update_model (self.log_filter)
        self.pop_view_state ()

        self.actions.show_hidden_lines.props.sensitive = True

    def handle_hide_log_level_action_activate (self, action):

        row = self.get_active_line ()
        debug_level = row[LogModelBase.COL_LEVEL]
        self.add_model_filter (DebugLevelFilter (debug_level))

    def handle_hide_log_category_action_activate (self, action):

        row = self.get_active_line ()
        category = row[LogModelBase.COL_CATEGORY]
        self.add_model_filter (CategoryFilter (category))

    def handle_hide_log_object_action_activate (self, action):

        pass

    def handle_show_about_action_activate (self, action):

        from GstDebugViewer import version

        dialog = self.widget_factory.make_one ("about_dialog")
        dialog.props.version = version
        dialog.run ()
        dialog.destroy ()

    @staticmethod
    def _timestamp_cell_data_func (column, renderer, model, tree_iter):

        ts = model.get_value (tree_iter, LogModel.COL_TIME)
        renderer.props.text = Data.time_args (ts)

    def _message_cell_data_func (self, column, renderer, model, tree_iter):

        offset = model.get_value (tree_iter, LogModel.COL_MESSAGE_OFFSET)
        self.log_file.seek (offset)
        renderer.props.text = strip_escape (self.log_file.readline ().strip ())

    def set_log_file (self, filename):

        if self.log_file is not None:
            for feature in self.features:
                feature.handle_detach_log_file (self, self.log_file)

        if filename is None:
            if self.dispatcher is not None:
                self.dispatcher.cancel ()
            self.dispatcher = None
            self.log_file = None
            self.actions.groups["RowActions"].props.sensitive = False
        else:
            self.logger.debug ("setting log file %r", filename)

            try:
                self.setup_model (LazyLogModel ())
                
                self.dispatcher = Common.Data.GSourceDispatcher ()
                self.log_file = Data.LogFile (filename, self.dispatcher)
            except EnvironmentError, exc:
                try:
                    file_size = os.path.getsize (filename)
                except EnvironmentError:
                    pass
                else:
                    if file_size == 0:
                        # Trying to mmap an empty file results in an invalid
                        # argument error.
                        self.show_error (_("Could not open file"),
                                         _("The selected file is empty"))
                        return
                self.handle_environment_error (exc, filename)
                return

            basename = os.path.basename (filename)
            self.gtk_window.props.title = _("%s - GStreamer Debug Viewer") % (basename,)

            self.log_file.consumers.append (self)
            self.log_file.start_loading ()

    def handle_environment_error (self, exc, filename):

        self.show_error (_("Could not open file"), str (exc))

    def show_error (self, message1, message2):

        dialog = gtk.MessageDialog (self.gtk_window, gtk.DIALOG_MODAL, gtk.MESSAGE_ERROR,
                                    gtk.BUTTONS_OK, message1)
        # The property for secondary text is new in 2.10, so we use this clunky
        # method instead.
        dialog.format_secondary_text (message2)
        dialog.set_default_response (0)
        dialog.run ()
        dialog.destroy ()

    def handle_load_started (self):

        self.logger.debug ("load has started")

        self.progress_dialog = ProgressDialog (self, _("Loading log file"))
        self.progress_dialog.handle_cancel = self.handle_load_progress_dialog_cancel
        self.update_progress_id = gobject.timeout_add (250, self.update_load_progress)

    def handle_load_progress_dialog_cancel (self):

        self.actions.cancel_load.activate ()

    def update_load_progress (self):

        if self.progress_dialog is None:
            self.logger.debug ("progress dialog is gone, removing progress update timeout")
            self.update_progress_id = None
            return False

        progress = self.log_file.get_load_progress ()
        self.progress_dialog.update (progress)

        return True

    def handle_load_finished (self):

        self.logger.debug ("load has finshed")

        self.progress_dialog.destroy ()
        self.progress_dialog = None

        self.log_model.set_log (self.log_file)
        self.log_range.reset ()
        self.log_filter = None

        self.actions.reload_file.props.sensitive = True
        self.actions.groups["RowActions"].props.sensitive = True
        self.actions.show_hidden_lines.props.sensitive = False

        def idle_set ():
            self.log_view.props.model = self.log_range
            self.line_view.handle_attach_log_file (self)
            for feature in self.features:
                feature.handle_attach_log_file (self, self.log_file)
            if len (self.log_range):
                sel = self.log_view.get_selection ()
                sel.select_path ((0,))
            return False

        gobject.idle_add (idle_set)

class AppStateSection (Common.GUI.StateSection):

    _name = "state"

    geometry = Common.GUI.StateInt4 ("window-geometry")
    maximized = Common.GUI.StateBool ("window-maximized")

    column_order = Common.GUI.StateItemList ("column-order", ViewColumnManager)
    columns_visible = Common.GUI.StateItemList ("columns-visible", ViewColumnManager)    

class AppState (Common.GUI.State):

    def __init__ (self, *a, **kw):

        Common.GUI.State.__init__ (self, *a, **kw)

        self.add_section_class (AppStateSection)

class App (object):

    def __init__ (self):

        self.attach ()

    def load_plugins (self):

        from GstDebugViewer import Plugins

        plugin_classes = list (Plugins.load ([os.path.dirname (Plugins.__file__)]))
        self.plugins = []
        for plugin_class in plugin_classes:
            plugin = plugin_class (self)
            self.plugins.append (plugin)

    def iter_plugin_features (self):

        for plugin in self.plugins:
            for feature in plugin.features:
                yield feature

    def attach (self):

        config_home = Common.utils.XDG.CONFIG_HOME

        state_filename = os.path.join (config_home, "gst-debug-viewer", "state")

        self.state = AppState (state_filename)
        self.state_section = self.state.sections["state"]

        self.load_plugins ()

        self.windows = [Window (self)]

    def detach (self):

        # TODO: If we take over deferred saving from the inspector, specify now
        # = True here!
        self.state.save ()

    def run (self):

        try:
            Common.Main.MainLoopWrapper (gtk.main, gtk.main_quit).run ()
        except:
            raise
        else:
            self.detach ()

    def close_window (self, window):

        # GtkTreeView takes some time to go down for large files.  Let's block
        # until the window is hidden:
        gobject.idle_add (gtk.main_quit)
        gtk.main ()
        
        gtk.main_quit ()

import time

class TestParsingPerformance (object):

    def __init__ (self, filename):

        self.main_loop = gobject.MainLoop ()
        self.log_file = Data.LogFile (filename, Common.Data.DefaultDispatcher ())
        self.log_file.consumers.append (self)

    def start (self):

        self.log_file.start_loading ()

    def handle_load_started (self):

        self.start_time = time.time ()

    def handle_load_finished (self):

        diff = time.time () - self.start_time
        print "line cache built in %0.1f ms" % (diff * 1000.,)

        start_time = time.time ()
        model = LazyLogModel (self.log_file)
        for row in model:
            pass
        diff = time.time () - start_time
        print "model iterated in %0.1f ms" % (diff * 1000.,)
        print "overall time spent: %0.1f s" % (time.time () - self.start_time,)

        import resource
        rusage = resource.getrusage (resource.RUSAGE_SELF)
        print "time spent in user mode: %.2f s" % (rusage.ru_utime,)
        print "time spent in system mode: %.2f s" % (rusage.ru_stime,)

def main (options):

    args = options["args"]

    if len (args) > 1 and args[0] == "benchmark":
        test = TestParsingPerformance (args[1])
        test.start ()
        return

    app = App ()

    # TODO: Once we support more than one window, open one window for each
    # supplied filename.
    window = app.windows[0]
    if len (args) > 0:
        window.set_log_file (args[0])

    app.run ()

if __name__ == "__main__":
    main ()