rename mvc at lvc

1 files changed, 0 insertions, 268 deletions

diff --git a/mvc/widgets/menus.py b/mvc/widgets/menus.py
deleted file mode 100644
index 62b0c68..0000000
--- a/mvc/widgets/menus.py
+++ /dev/null
@@ -1,268 +0,0 @@
-# menus.py
-#
-# Most of these are taken from libs/frontends/widgets/menus.py in the miro
-# project.
-#
-# TODO: merge common bits!
-
-import collections
-
-from mvc import signals
-from mvc.widgets import widgetutil
-from mvc.widgets import widgetset
-from mvc.widgets import app
-
-from mvc.widgets.keyboard import (Shortcut, CTRL, ALT, SHIFT, CMD,
-     MOD, RIGHT_ARROW, LEFT_ARROW, UP_ARROW, DOWN_ARROW, SPACE, ENTER, DELETE,
-     BKSPACE, ESCAPE, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)
-
-# XXX hack:
-
-def _(text, *params):
-    if params:
-       return text % params[0]
-    return text
-
-class MenuItem(widgetset.MenuItem):
-    """Portable MenuItem class.
-
-    This adds group handling to the platform menu items.
-    """
-    # group_map is used for the legacy menu updater code
-    group_map = collections.defaultdict(set)
-
-    def __init__(self, label, name, shortcut=None, groups=None,
-                 **state_labels):
-        widgetset.MenuItem.__init__(self, label, name, shortcut)
-        # state_labels is used for the legacy menu updater code
-        self.state_labels = state_labels
-        if groups:
-            if len(groups) > 1:
-                raise ValueError("only support one group")
-            MenuItem.group_map[groups[0]].add(self)
-
-class MenuItemFetcher(object):
-    """Get MenuItems by their name quickly.  """
-
-    def __init__(self):
-        self._cache = {}
-
-    def __getitem__(self, name):
-        if name in self._cache:
-            return self._cache[name]
-        else:
-            menu_item = app.widgetapp.menubar.find(name)
-            self._cache[name] = menu_item
-            return menu_item
-
-def get_app_menu():
-    """Returns the default menu structure."""
-
-    app_name = "Libre Video Converter"    # XXX HACK
-
-    file_menu = widgetset.Menu(_("_File"), "FileMenu", [
-                    MenuItem(_("_Open"), "Open", Shortcut("o", MOD),
-                             groups=["NonPlaying"]),
-                    MenuItem(_("_Quit"), "Quit", Shortcut("q", MOD)),
-                    ])
-    help_menu = widgetset.Menu(_("_Help"), "HelpMenu", [
-                    MenuItem(_("About %(name)s",
-                               {'name': app_name}),
-                             "About")
-                    ])
-
-    all_menus = [file_menu, help_menu]
-    return all_menus
-
-action_handlers = {}
-group_action_handlers = {}
-
-def on_menubar_activate(menubar, action_name):
-    callback = lookup_handler(action_name)
-    if callback is not None:
-        callback()
-
-def lookup_handler(action_name):
-    """For a given action name, get a callback to handle it.  Return
-    None if no callback is found.
-    """
-
-    retval = _lookup_group_handler(action_name)
-    if retval is None:
-        retval = action_handlers.get(action_name)
-    return retval
-
-def _lookup_group_handler(action_name):
-    try:
-        group_name, callback_arg = action_name.split('-', 1)
-    except ValueError:
-        return None # split return tuple of length 1
-    try:
-        group_handler = group_action_handlers[group_name]
-    except KeyError:
-        return None
-    else:
-        return lambda: group_handler(callback_arg)
-
-def action_handler(name):
-    """Decorator for functions that handle menu actions."""
-    def decorator(func):
-        action_handlers[name] = func
-        return func
-    return decorator
-
-def group_action_handler(action_prefix):
-    def decorator(func):
-        group_action_handlers[action_prefix] = func
-        return func
-    return decorator
-
-# File menu
-@action_handler("Open")
-def on_open():
-    app.widgetapp.choose_file()
-
-@action_handler("Quit")
-def on_quit():
-    app.widgetapp.quit()
-
-# Help menu
-@action_handler("About")
-def on_about():
-    app.widgetapp.about()
-
-class MenuManager(signals.SignalEmitter):
-    """Updates the menu based on the current selection.
-
-    This includes enabling/disabling menu items, changing menu text
-    for plural selection and enabling/disabling the play button.  The
-    play button is obviously not a menu item, but it's pretty closely
-    related
-
-    Whenever code makes a change that could possibly affect which menu
-    items should be enabled/disabled, it should call the
-    update_menus() method.
-
-    Signals:
-    - menus-updated(reasons): Emitted whenever update_menus() is called
-    """
-    def __init__(self):
-        signals.SignalEmitter.__init__(self, 'menus-updated')
-        self.menu_item_fetcher = MenuItemFetcher()
-        #self.subtitle_encoding_updater = SubtitleEncodingMenuUpdater()
-        self.subtitle_encoding_updater = None
-
-    def setup_menubar(self, menubar):
-        """Setup the main miro menubar.
-        """
-        menubar.add_initial_menus(get_app_menu())
-        menubar.connect("activate", on_menubar_activate)
-        self.menu_updaters = []
-
-    def _set_play_pause(self):
-        if ((not app.playback_manager.is_playing
-             or app.playback_manager.is_paused)):
-            label = _('Play')
-        else:
-            label = _('Pause')
-        self.menu_item_fetcher['PlayPauseItem'].set_label(label)
-
-    def add_subtitle_encoding_menu(self, category_label, *encodings):
-        """Set up a subtitles encoding menu.
-
-        This method should be called for each category of subtitle encodings
-        (East Asian, Western European, Unicode, etc).  Pass it the list of
-        encodings for that category.
-
-        :param category_label: human-readable name for the category
-        :param encodings: list of (label, encoding) tuples.  label is a
-            human-readable name, and encoding is a value that we can pass to
-            VideoDisplay.select_subtitle_encoding()
-        """
-        self.subtitle_encoding_updater.add_menu(category_label, encodings)
-
-    def select_subtitle_encoding(self, encoding):
-        if not self.subtitle_encoding_updater.has_encodings():
-            # OSX never sets up the subtitle encoding menu
-            return
-        menu_item_name = self.subtitle_encoding_updater.action_name(encoding)
-        try:
-            self.menu_item_fetcher[menu_item_name].set_state(True)
-        except KeyError:
-            logging.warn("Error enabling subtitle encoding menu item: %s",
-                         menu_item_name)
-
-    def update_menus(self, *reasons):
-        """Call this when a change is made that could change the menus
-
-        Use reasons to describe why the menus could change.  Some MenuUpdater
-        objects will do some optimizations based on that
-        """
-        reasons = set(reasons)
-        self._set_play_pause()
-        for menu_updater in self.menu_updaters:
-            menu_updater.update(reasons)
-        self.emit('menus-updated', reasons)
-
-class MenuUpdater(object):
-    """Base class for objects that dynamically update menus."""
-    def __init__(self, menu_name):
-        self.menu_name = menu_name
-        self.first_update = False
-
-    # we lazily access our menu item, since we are created before the menubar
-    # is fully setup.
-    def get_menu(self):
-        try:
-            return self._menu
-        except AttributeError:
-            self._menu = app.widgetapp.menubar.find(self.menu_name)
-            return self._menu
-    menu = property(get_menu)
-
-    def update(self, reasons):
-        if not self.first_update and not self.should_process_update(reasons):
-            return
-        self.first_update = False
-        self.start_update()
-        if not self.should_show_menu():
-            self.menu.hide()
-            return
-
-        self.menu.show()
-        if self.should_rebuild_menu():
-            self.clear_menu()
-            self.populate_menu()
-        self.update_items()
-
-    def should_process_update(self, reasons):
-        """Test if we should ignore the update call.
-
-        :param reasons: the reasons passed in to MenuManager.update_menus()
-        """
-        return True
-
-    def clear_menu(self):
-        """Remove items from our menu before rebuilding it."""
-        for child in self.menu.get_children():
-            self.menu.remove(child)
-
-    def start_update(self):
-        """Called at the very start of the update method.  """
-        pass
-
-    def should_show_menu(self):
-        """Should we display the menu?  """
-        return True
-
-    def should_rebuild_menu(self):
-        """Should we rebuild the menu structure?"""
-        return False
-
-    def populate_menu(self):
-        """Add MenuItems to our menu."""
-        pass
-
-    def update_items(self):
-        """Update our menu items."""
-        pass