path: root/GstInspector/GUI/filters.py

# -*- coding: utf-8; mode: python; -*-
#
#  GStreamer Inspector - Multimedia system plugin introspection
#
#  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 Inspector GUI.filters module."""

import locale
import logging

import pango
import gobject
import gtk

from GstInspector import Data, utils

from GstInspector.GUI.utils import Manager, _

class FilterModelFactory (Data.ConsumerProxy):

    __metaclass__ = utils.SingletonMeta

    def __init__ (self, data_spec):

        Data.ConsumerProxy.__init__ (self)

        self.model = None
        self.collector = Data.Collector (data_spec)
        self.consumers.append (self.collector)

    def clear (self):

        if self.model is not None:
            self.model.clear ()

    def handle_load_started_after (self):

        Data.ConsumerProxy.handle_load_started_after (self)

        self.clear ()

    def handle_load_finished (self):

        Data.ConsumerProxy.handle_load_finished (self)

        self.fill ()

        self.collector.clear ()

class FilterModelFactoryFlat (FilterModelFactory):

    def __init__ (self, data_spec):

        FilterModelFactory.__init__ (self, data_spec)

        self.model = gtk.ListStore (str)

    def fill (self):

        model = self.model
        collector = self.collector

        for sort_name, item in sorted (((locale.strxfrm (unicode (item, "UTF-8")), item,)
                                        for item in collector.items)):
            model.set (model.append (), 0, item)

class FilterModelFactoryNestedAlpha (FilterModelFactory):

    def __init__ (self, data_spec):

        FilterModelFactory.__init__ (self, data_spec)

        self.model = gtk.TreeStore (str)

    def fill (self):

        model = self.model

        # TODO: This would ideally use a dynamic number of partitions.

        iter1 = model.append (None)
        iter2 = model.append (None)
        iter3 = model.append (None)
        iter4 = model.append (None)

        model.set (iter1, 0, "A-G")
        model.set (iter2, 0, "H-M")
        model.set (iter3, 0, "N-S")
        model.set (iter4, 0, "T-Z")

        for sort_name, item in sorted (((locale.strxfrm (unicode (item, "UTF-8")), item,)
                                        for item in self.collector.items)):
            if item.upper () < "H":
                use_iter = iter1
            elif item.upper () < "N":
                use_iter = iter2
            elif item.upper () < "T":
                use_iter = iter3
            else:
                use_iter = iter4
            model.set (model.append (use_iter), 0, item)

        remove = [row for row in model
                  if model.iter_n_children (row.iter) == 0]
        for row in remove:
            model.remove (row.iter)

class FilterModelFactoryCapsNames (FilterModelFactory):

    def __init__ (self, data_spec):

        FilterModelFactory.__init__ (self, data_spec)

        self.model = gtk.TreeStore (str)
        self.flat_model = gtk.ListStore (str)

    def clear (self):

        FilterModelFactory.clear (self)

        self.flat_model.clear ()

    def fill (self):

        model = self.model
        items = self.collector.items

        raw_names = [n for n in items if "-raw-" in n]
        non_raw_names = [n for n in items if not "-raw-" in n]
        prefixes = set ((name.split ("/")[0] for name in non_raw_names))

        for name in sorted (raw_names):
            model.set (model.append (None), 0, name)

        if raw_names and non_raw_names:
            # Add separator.
            model.set (model.append (None), 0, "")

        for prefix in sorted (prefixes):
            prefix_iter = model.append (None)
            names = [name for name in non_raw_names
                     if name.startswith (prefix)]
            if len (names) == 1:
                model.set (prefix_iter, 0, names[0])
                continue
            model.set (prefix_iter, 0, "%s/" % (prefix,))
            for name in sorted (names):
                model.set (model.append (prefix_iter), 0, name)

        # Fill the flat model (used for completion).  Since the popup doesn't
        # work, don't even bother sorting the list.
        model = self.flat_model
        for item in items:
            model.set (model.append (), 0, item)

class UIFilter (object):

    name = None
    label = None
    param = None
    sensitive = True
    widget_name = None
    data_spec = None
    model_factory_class = None
    filter_class = None

    @classmethod
    def get_model_factory (cls):

        if cls.data_spec and cls.model_factory_class:
            return cls.model_factory_class (cls.data_spec)
        else:
            return None

    def __init__ (self, manager, widgets):

        self.logger = logging.getLogger ("ui.filter.%s" % (self.name,))
        self.manager = manager

        if self.widget_name:
            self.widget = getattr (widgets, self.widget_name)
        else:
            self.widget = None
        self.model_factory = self.get_model_factory ()
        if self.model_factory:
            self.model = self.model_factory.model
        else:
            self.model = None

        self.default_param = None

    def param_changed (self):

        self.manager.handle_ui_filter_param_changed (self)

    def push_default_param (self):

        # Don't overwrite defaults if the filter is inactive:
        if self.param and not self.default_param:
            self.default_param = self.param
            self.logger.debug ("pushed default param %r",
                               self.default_param)
        else:
            self.logger.debug ("default param not pushed")

    def pop_default_param (self):

        if self.default_param is not None:
            self.param = self.default_param
            self.logger.debug ("popped default param %r",
                               self.default_param)
        else:
            self.logger.debug ("no default param to pop")

    def get_filter_func (self):

        spec = Data.accessor_transform (self.data_spec, "element")
        return self.filter_class (spec, self.param)

class UIFilterNone (UIFilter):

    name = "show-all"
    label = _("Show all elements")

    @staticmethod
    def filter_func (element):
        return True

    def get_filter_func (self):

        return self.filter_func

class UIFilterCombo (UIFilter):

    def _get_param (self):

        active_iter = self.widget.get_active_iter ()
        if active_iter is None:
            # Our model is empty.
            return None
        model = self.widget.props.model
        param = model.get (active_iter, 0)[0]

        return param

    def _set_param (self, param):

        model = self.widget.props.model

        for row in model:
            if row[0] == param:
                # This emits the "changed" signal.
                self.widget.set_active_iter (row.iter)
                break
        else:
            raise KeyError ("no such entry for param %r" % (param,))

    def _get_sensitive (self):

        return len (self.model) > 0

    param = property (_get_param, _set_param)
    sensitive = property (_get_sensitive)
    model_factory_class = FilterModelFactoryFlat

    def __init__ (self, manager, widgets, widget_prefix = None):

        if widget_prefix is None:
            widget_prefix = self.name
        if self.widget_name is None:
            self.widget_name = "%s_filter_param_combo" % (widget_prefix,)

        UIFilter.__init__ (self, manager, widgets)

        self.widget.props.model = self.model

        self.setup_cell_renderer ()

        self.default_param = self.get_initial_default ()
        if self.default_param is not None:
            self.param = self.default_param
            self.default_param = None

        self.widget.connect ("changed", self.handle_combo_box_changed)

    def setup_cell_renderer (self):

        cell = gtk.CellRendererText ()
        # We limit the width to 35 characters.  The automatic size is far too
        # large because of some semi-bogus entries we get (like URLs and almost
        # whole sentences for element.author.)
        cell.props.width_chars = 35
        cell.props.ellipsize = pango.ELLIPSIZE_END

        widget = self.widget
        widget.clear ()
        widget.pack_start (cell, True)
        widget.set_cell_data_func (cell, self.combo_cell_data_func)

    def get_initial_default (self):

        try:
            tree_iter = self.model.get_iter ((0,))
        except ValueError:
            self.logger.debug ("no initial default param: model is empty")
            return None
        else:
            param = self.model.get (tree_iter, 0)[0]
            self.logger.debug ("initial default param is %r", param)
            return param

    def handle_combo_box_changed (self, combo_box):

        self.param_changed ()

    @staticmethod
    def combo_cell_data_func (layout, cell, model, tree_iter):

        cell.props.text = model.get (tree_iter, 0)[0]

    def pop_default_param (self):

        widget = self.widget
        model = widget.props.model

        if self.default_param is None:
            self.param = self.get_initial_default ()
        else:
            try:
                self.param = self.default_param
            except KeyError:
                # The param does not exist in the new data anymore, fall back:
                self.param = self.get_initial_default ()
            self.default_param = None

class UIFilterComboNested (UIFilterCombo):

    def _set_param (self, param):

        model = self.widget.props.model

        for row in model:
            for childrow in row.iterchildren ():
                if childrow[0] == param:
                    # This emits the "changed" signal.
                    self.widget.set_active_iter (childrow.iter)
                    return
        else:
            raise KeyError ("no such entry for param %r" % (param,))

    param = property (UIFilterCombo._get_param, _set_param)

    @staticmethod
    def combo_cell_data_func (layout, cell, model, tree_iter):

        props = cell.props

        props.text = model.get (tree_iter, 0)[0]
        props.sensitive = not model.iter_has_child (tree_iter)

class UIFilterAuthor (UIFilterComboNested):

    name = "author"
    data_spec = "element.authors.name"
    model_factory_class = FilterModelFactoryNestedAlpha
    filter_class = Data.FilterIn
    label = _("Author")

    def get_initial_default (self):

        try:
            tree_iter = self.model.get_iter ((0, 0,))
        except ValueError:
            self.logger.debug ("no initial default param: model is empty")
            return None
        else:
            param = self.model.get (tree_iter, 0)[0]
            self.logger.debug ("initial default param is %r", param)
            return param

class UIFilterCapsName (UIFilterComboNested):

    def _get_param (self):

        return self.widget.get_active_text ()

    def _set_param (self, param):

        entry = self.widget.get_child ()
        # This emits the "changed" signal.
        entry.props.text = param

    name = "caps_name"
    widget_name = "caps_filter_param_combo_entry"
    data_spec = "element.pads.caps.name"
    model_factory_class = FilterModelFactoryCapsNames
    filter_class = Data.FilterInIn
    # TRANSLATORS: The term "Caps" refers to a GStreamer data structure.
    label = _("Caps name")
    param = property (_get_param, _set_param)

    def __init__ (self, manager, widgets):

        UIFilterComboNested.__init__ (self, manager, widgets)

        self.id = None

        flat_model = self.model_factory.flat_model
        entry = self.widget.get_child ()
        comp = gtk.EntryCompletion ()
        comp.props.model = flat_model
        comp.props.text_column = 0
        comp.props.inline_completion = True
        # TODO: Would be nice to have the popup, but it doesn't work correctly.
        # It gets the wrong size and apparently does not render any text.
        comp.props.popup_completion = False
        entry.set_completion (comp)

    def setup_cell_renderer (self):

        widget = self.widget

        widget.props.text_column = 0
        widget.set_row_separator_func (self.row_separator_func)

    def get_initial_default (self):

        return ""

    def handle_combo_box_changed (self, widget):

        # We idly defer signalling the change, which will trigger refiltering.
        # This helps against sluggishness during typing, which occurs because
        # of TreeView slowness (the filtering itself is fast).

        if self.id is not None:
            # Already queued up.
            return

        def emit_change_deferred ():

            self.param_changed ()
            self.id = None
            return False

        self.id = gobject.idle_add (emit_change_deferred, priority = gobject.PRIORITY_LOW)

    def pop_default_param (self):

        if self.default_param is not None:
            # TODO: Ensure that we also set the active iter somehow, to make
            # the scroll wheel work as expected.
            self.param = self.default_param

    @staticmethod
    def row_separator_func (model, tree_iter):

        return model.get (tree_iter, 0)[0] == ""

class UIFilterKlass (UIFilterCombo):

    name = "klass"
    data_spec = "element.klasses"
    filter_class = Data.FilterIn
    label = _("Classification")

class UIFilterInterface (UIFilterCombo):

    name = "interface"
    data_spec = "element.interfaces"
    filter_class = Data.FilterIn
    label = _("Interface")

class UIFilterLicense (UIFilterCombo):

    name = "license"
    data_spec = "plugin.license"
    filter_class = Data.FilterEq
    label = _("License")

class UIFilterSource (UIFilterCombo):

    name = "source"
    data_spec = "plugin.source"
    filter_class = Data.FilterEq
    label = _("Source module")

class UIFilterPackage (UIFilterCombo):

    name = "package"
    data_spec = "plugin.package"
    filter_class = Data.FilterEq
    label = _("Binary package")

class UIFilterParentClass (UIFilterCombo):

    name = "parent"
    data_spec = "element.parent_classes"
    filter_class = Data.FilterIn
    label = _("Parent class")

class UIFilterURIProtocols (UIFilterCombo):

    name = "uri_protocol"
    data_spec = "element.uri_protocols"
    filter_class = Data.FilterIn
    label = _("URI protocol")

    @staticmethod
    def combo_cell_data_func (layout, cell, model, tree_iter):

        cell.props.text = "%s://" % (model.get (tree_iter, 0)[0],)

class FilterManager (Manager):

    """GUI manager that handles the filter selection combo box and the notebook
    containing the parameter selectors for the available filters.  The
    individual parameter selector pages are handled by specific objects derived
    from the UIFilter class."""

    filter_classes = (UIFilterNone, UIFilterAuthor, UIFilterCapsName,
                      UIFilterInterface, UIFilterKlass, UIFilterLicense,
                      UIFilterPackage, UIFilterParentClass, UIFilterSource,
                      UIFilterURIProtocols,)

    @classmethod
    def iter_item_classes (cls):

        return iter (cls.filter_classes)

    def _get_active (self):

        combo = self.combo
        model = combo.props.model
        active_iter = combo.get_active_iter ()

        if active_iter is None:
            return None
        else:
            return model.get (active_iter, 1)[0]

    def _set_active (self, ui_filter):

        for row in self.combo.props.model:

            label, other_ui_filter = row

            if not label:
                # Separator.
                continue

            if ui_filter == other_ui_filter:
                self.combo.set_active_iter (row.iter)
                break

        else:
            raise KeyError ("no such UIFilter object %r" % (ui_filter,))

    active = property (_get_active, _set_active)

    def __init__ (self):

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

        self.disabled = False
        self.default_active = None

    def attach (self, inspector_window):

        self.app = inspector_window.app
        widgets = inspector_window.widgets

        self.set_filter_func = inspector_window.element_view.set_filter_func

        self.combo = widgets.filter_combo
        self.book = widgets.filter_params_book
        self.book.hide ()

        model = gtk.ListStore (str, object)
        self.combo.set_row_separator_func (self.row_separator_func)
        self.combo.props.model = model

        # The first filter is special.
        ui_filter = UIFilterNone (self, widgets)
        model.set (model.append (),
                   0, ui_filter.label,
                   1, ui_filter)
        model.set (model.append (),
                   0, "",
                   1, None)

        # Now add the rest.
        classes = self.filter_classes[1:]
        ui_filters = tuple ((cls (self, widgets) for cls in classes))
        labels = [ui_filter.label for ui_filter in ui_filters]
        sort_labels = [locale.strxfrm (label) for label in labels]
        for sort_label, label, ui_filter in sorted (zip (sort_labels,
                                                         labels,
                                                         ui_filters)):
            model.set (model.append (),
                       0, label,
                       1, ui_filter)

        self.combo.props.active = 0
        self.combo.connect ("changed", self.handle_filter_combo_changed)
        self.combo.set_row_separator_func (self.row_separator_func)

        filter_class = self.app.state.filter
        default_param = self.app.state.filter_param

        if not filter_class:
            filter_class = UIFilterNone
            self.logger.debug ("no default filter in saved state, using %r",
                               filter_class.name)
        else:
            self.logger.debug ("restored default filter %r with param %r from state",
                               filter_class.name, default_param)

        ui_filter = self.find_item (name = filter_class.name)
        ui_filter.default_param = default_param
        self.default_active = ui_filter

        self.active = self.find_item (name = "show-all")

    def detach (self):

        if self.default_active:
            active = self.default_active
        else:
            active = self.active
        state = self.app.state

        state.filter = active
        state.filter_param = active.param

    def handle_filter_combo_changed (self, combo_box):

        ui_filter = self.active

        if ui_filter.widget:
            self.book.show ()
            child = ui_filter.widget
            pos = self.book.child_get (child, "position")[0]
            self.book.props.page = pos
        else:
            self.book.hide ()

        if not ui_filter.sensitive:
            return

        if self.disabled:
            return

        func = ui_filter.get_filter_func ()
        self.set_filter_func (func)

    def handle_ui_filter_param_changed (self, ui_filter):

        # Called when a UIFilter instance has changed its parameter.

        active_ui_filter = self.active
        if ui_filter != active_ui_filter:
            return

        if self.disabled:
            return

        func = ui_filter.get_filter_func ()
        self.set_filter_func (func)

    @staticmethod
    def row_separator_func (model, tree_iter):

        return model.get (tree_iter, 0)[0] == ""

    def iter_items (self):

        for label, ui_filter in self.combo.props.model:
            if not ui_filter:
                # Either "show-all" or separator.
                continue
            yield ui_filter

    def handle_load_started (self):

        self.disable ()

        for ui_filter in self.iter_items ():
            ui_filter.push_default_param ()

    def handle_load_finished (self):

        for ui_filter in self.iter_items ():
            ui_filter.pop_default_param ()

        self.enable ()

    def disable (self):

        if self.disabled:
            return

        self.disabled = True

        show_all = self.find_item (name = "show-all")
        self.set_filter_func (show_all.get_filter_func ())

    def enable (self):

        if not self.disabled:
            return

        self.disabled = False

        ui_filter = self.active
        if not ui_filter.sensitive:
            self.active = self.find_item (name = "show-all")
            self.logger.debug ("filter %s lost sensitivity, switched to show-all",
                               ui_filter.name)
        elif ui_filter.name != "show-all":
            self.set_filter_func (ui_filter.get_filter_func ())

    def push_default_active (self):

        self.default_active = self.active
        self.active = self.find_item (name = "show-all")

    def pop_default_active (self):

        if self.default_active is None:
            raise ValueError ("not attached")
        elif self.default_active == self.active:
            return

        self.active = self.default_active
        self.default_active = None

del _
from gettext import gettext as _