rename mvc at lvc

1 files changed, 0 insertions, 220 deletions

diff --git a/mvc/widgets/tableselection.py b/mvc/widgets/tableselection.py
deleted file mode 100644
index d087d34..0000000
--- a/mvc/widgets/tableselection.py
+++ /dev/null
@@ -1,220 +0,0 @@
-# @Base: Miro - an RSS based video player application
-# Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011
-# Participatory Culture Foundation
-#
-# 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 2 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, write to the Free Software
-# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
-#
-# In addition, as a special exception, the copyright holders give
-# permission to link the code of portions of this program with the OpenSSL
-# library.
-#
-# You must obey the GNU General Public License in all respects for all of
-# the code used other than OpenSSL. If you modify file(s) with this
-# exception, you may extend this exception to your version of the file(s),
-# but you are not obligated to do so. If you do not wish to do so, delete
-# this exception statement from your version. If you delete this exception
-# statement from all source files in the program, then also delete it here.
-
-"""tableselection.py -- High-level selection management. Subclasses defined in
-the platform tableview modules provide the platform-specific methods used here.
-"""
-
-from contextlib import contextmanager
-
-from mvc.errors import WidgetActionError, WidgetUsageError
-
-class SelectionOwnerMixin(object):
-    """Encapsulates the selection functionality of a TableView, for
-    consistent behavior across platforms.
-
-    Emits:
-    :signal selection-changed: the selection has been changed
-    :signal selection-invalid: the item selected can no longer be selected
-    :signal deselected: all items have been deselected
-    """
-    def __init__(self):
-        self._ignore_selection_changed = 0
-        self._allow_multiple_select = None
-        self.create_signal('selection-changed')
-        self.create_signal('selection-invalid')
-        self.create_signal('deselected')
-
-    @property
-    def allow_multiple_select(self):
-        """Return whether the widget allows multiple selection."""
-        if self._allow_multiple_select is None:
-            self._allow_multiple_select = self._get_allow_multiple_select()
-        return self._allow_multiple_select
-
-    @allow_multiple_select.setter
-    def allow_multiple_select(self, allow):
-        """Set whether to allow multiple selection; this method is expected
-        always to work.
-        """
-        if self._allow_multiple_select != allow:
-            self._set_allow_multiple_select(allow)
-            self._allow_multiple_select = allow
-
-    @property
-    def num_rows_selected(self):
-        """Override on platforms with a way to count rows without having to
-        retrieve them.
-        """
-        if self.allow_multiple_select:
-            return len(self._get_selected_iters())
-        else:
-            return int(self._get_selected_iter() is not None)
-
-    def select(self, iter_, signal=False):
-        """Try to select an iter.
-
-        :raises WidgetActionError: iter does not exist or is not selectable
-        """
-        self.select_iters((iter_,), signal)
-
-    def select_iters(self, iters, signal=False):
-        """Try to select multiple iters (signaling at most once).
-
-        :raises WidgetActionError: iter does not exist or is not selectable
-        """
-        with self._ignoring_changes(not signal):
-            for iter_ in iters:
-                self._select(iter_)
-        if not all(self._is_selected(iter_) for iter_ in iters):
-            raise WidgetActionError("the specified iter cannot be selected")
-
-    def is_selected(self, iter_):
-        """Test if an iter is selected"""
-        return self._is_selected(iter_)
-
-    def unselect(self, iter_):
-        """Unselect an Iter. Fails silently if the Iter is not selected.
-        """
-        self._validate_iter(iter_)
-        with self._ignoring_changes():
-            self._unselect(iter_)
-
-    def unselect_iters(self, iters):
-        """Unselect iters. Fails silently if the iters are not selected."""
-        with self._ignoring_changes():
-            for iter_ in iters:
-                self.unselect(iter_)
-
-    def unselect_all(self, signal=True):
-        """Unselect all. emits only the 'deselected' signal."""
-        with self._ignoring_changes():
-            self._unselect_all()
-            if signal:
-                self.emit('deselected')
-
-    def on_selection_changed(self, _widget_or_notification):
-        """When we receive a selection-changed signal, we forward it if we're
-        not in a 'with _ignoring_changes' block. Selection-changed
-        handlers are run in an ignoring block, and anything that changes the
-        selection to reflect the current state.
-        """
-        # don't bother sending out a second selection-changed signal if
-        # the handler changes the selection (#15767)
-        if not self._ignore_selection_changed:
-            with self._ignoring_changes():
-                self.emit('selection-changed')
-
-    def get_selection_as_strings(self):
-        """Returns the current selection as a list of strings.
-        """
-        return [self._iter_to_string(iter_) for iter_ in self.get_selection()]
-
-    def set_selection_as_strings(self, selected):
-        """Given a list of selection strings, selects each Iter represented by
-        the strings.
-
-        Raises WidgetActionError upon failure.
-        """
-        # iter may not be destringable (yet) - bounds error
-        # destringed iter not selectable if parent isn't open (yet)
-        self.set_selection(self._iter_from_string(sel) for sel in selected)
-
-    def get_cursor(self):
-        """Get the location of the keyboard cursor for the tableview.
-
-        Returns a string that represents the row that the keyboard cursor is
-        on.
-        """
-
-    def set_cursor(self, location):
-        """Set the location of the keyboard cursor for the tableview.
-
-        :param location: return value from a call to get_cursor()
-
-        Raises WidgetActionError upon failure.
-        """
-
-    def get_selection(self):
-        """Returns a list of GTK Iters. Works regardless of whether multiple
-        selection is enabled.
-        """
-        return self._get_selected_iters()
-
-    def get_selected(self):
-        """Return the single selected item.
-
-        :raises WidgetUsageError: multiple selection is enabled
-        """
-        if self.allow_multiple_select:
-            raise WidgetUsageError("table allows multiple selection")
-        return self._get_selected_iter()
-
-    def _validate_iter(self, iter_):
-        """Check whether an iter is valid.
-
-        :raises WidgetDomainError: the iter is not valid
-        :raises WidgetActionError: there is no model right now
-        """
-
-    @contextmanager
-    def _ignoring_changes(self, ignoring=True):
-        """Use this with with to prevent sending signals when we're changing
-        our own selection; that way, when we get a signal, we know it's
-        something important.
-        """
-        if ignoring:
-            self._ignore_selection_changed += 1
-        try:
-            yield
-        finally:
-            if ignoring:
-                self._ignore_selection_changed -= 1
-
-    @contextmanager
-    def preserving_selection(self):
-        """Prevent selection changes in a block from having any effect or
-        sticking - no signals will be sent, and the selection will be restored
-        to its original value when the block exits.
-        """
-        iters = self._get_selected_iters()
-        with self._ignoring_changes():
-            try:
-                yield
-            finally:
-                self.set_selection(iters)
-
-    def set_selection(self, iters, signal=False):
-        """Set the selection to the given iters, replacing any previous
-        selection and signaling at most once.
-        """
-        self.unselect_all(signal=False)
-        for iter_ in iters:
-            self.select(iter_, signal=False)
-        if signal: self.emit('selection-changed')