diff options
Diffstat (limited to 'lvc/widgets/osx/osxmenus.py')
| -rw-r--r-- | lvc/widgets/osx/osxmenus.py | 571 |
1 files changed, 571 insertions, 0 deletions
diff --git a/lvc/widgets/osx/osxmenus.py b/lvc/widgets/osx/osxmenus.py new file mode 100644 index 0000000..91baf3a --- /dev/null +++ b/lvc/widgets/osx/osxmenus.py @@ -0,0 +1,571 @@ +# @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. + +"""menus.py -- Menu handling code.""" + +import logging +import struct + +from objc import nil, NO, YES +import AppKit +from AppKit import * +from Foundation import * + +from lvc import signals +from lvc.widgets import keyboard +# import these names directly into our namespace for easy access +from lvc.widgets.keyboard import Shortcut, MOD + +# XXX hacks +def _(text, *params): + if params: + return text % params[0] + return text + +MODIFIERS_MAP = { + keyboard.MOD: NSCommandKeyMask, + keyboard.CMD: NSCommandKeyMask, + keyboard.SHIFT: NSShiftKeyMask, + keyboard.CTRL: NSControlKeyMask, + keyboard.ALT: NSAlternateKeyMask +} + +if isinstance(NSBackspaceCharacter, int): + backspace = NSBackspaceCharacter +else: + backspace = ord(NSBackspaceCharacter) + +KEYS_MAP = { + keyboard.SPACE: " ", + keyboard.ENTER: "\r", + keyboard.BKSPACE: struct.pack("H", backspace), + keyboard.DELETE: NSDeleteFunctionKey, + keyboard.RIGHT_ARROW: NSRightArrowFunctionKey, + keyboard.LEFT_ARROW: NSLeftArrowFunctionKey, + keyboard.UP_ARROW: NSUpArrowFunctionKey, + keyboard.DOWN_ARROW: NSDownArrowFunctionKey, + '.': '.', + ',': ',' +} +# add function keys +for i in range(1, 13): + portable_key = getattr(keyboard, "F%s" % i) + osx_key = getattr(AppKit, "NSF%sFunctionKey" % i) + KEYS_MAP[portable_key] = osx_key + +REVERSE_MODIFIERS_MAP = dict((i[1], i[0]) for i in MODIFIERS_MAP.items()) +REVERSE_KEYS_MAP = dict((i[1], i[0]) for i in KEYS_MAP.items() + if i[0] != keyboard.BKSPACE) +REVERSE_KEYS_MAP[u'\x7f'] = keyboard.BKSPACE +REVERSE_KEYS_MAP[u'\x1b'] = keyboard.ESCAPE + +def make_modifier_mask(shortcut): + mask = 0 + for modifier in shortcut.modifiers: + mask |= MODIFIERS_MAP[modifier] + return mask + +VIEW_ITEM_MAP = {} + +def _remove_mnemonic(label): + """Remove the underscore used by GTK for mnemonics. + + We totally ignore them on OSX, since they are now deprecated. + """ + return label.replace("_", "") + +def handle_menu_activate(ns_menu_item): + """Handle a menu item being activated. + + This gets called by our application delegate. + """ + + menu_item = ns_menu_item.representedObject() + menu_item.emit("activate") + menubar = menu_item._find_menubar() + if menubar is not None: + menubar.emit("activate", menu_item.name) + +class MenuItemBase(signals.SignalEmitter): + """Base class for MenuItem and Separator""" + def __init__(self): + signals.SignalEmitter.__init__(self) + self.name = None + self.parent = None + + def show(self): + self._menu_item.setHidden_(False) + + def hide(self): + self._menu_item.setHidden_(True) + + def enable(self): + self._menu_item.setEnabled_(True) + + def disable(self): + self._menu_item.setEnabled_(False) + + def remove_from_parent(self): + """Remove this menu item from it's parent Menu.""" + if self.parent is not None: + self.parent.remove(self) + +class MenuItem(MenuItemBase): + """See the GTK version of this method for the current docstring.""" + + # map Miro action names to standard OSX actions. + _STD_ACTION_MAP = { + "HideMiro": (NSApp(), 'hide:'), + "HideOthers": (NSApp(), 'hideOtherApplications:'), + "ShowAll": (NSApp(), 'unhideAllApplications:'), + "Cut": (nil, 'cut:'), + "Copy": (nil, 'copy:'), + "Paste": (nil, 'paste:'), + "Delete": (nil, 'delete:'), + "SelectAll": (nil, 'selectAll:'), + "Zoom": (nil, 'performZoom:'), + "Minimize": (nil, 'performMiniaturize:'), + "BringAllToFront": (nil, 'arrangeInFront:'), + "CloseWindow": (nil, 'performClose:'), + } + + def __init__(self, label, name, shortcut=None): + MenuItemBase.__init__(self) + self.name = name + self._menu_item = self._make_menu_item(label) + self.create_signal('activate') + self._setup_shortcut(shortcut) + + def _make_menu_item(self, label): + menu_item = NSMenuItem.alloc().init() + menu_item.setTitle_(_remove_mnemonic(label)) + # we set ourselves as the represented object for the menu item so we + # can easily translate one to the other + menu_item.setRepresentedObject_(self) + if self.name in self._STD_ACTION_MAP: + menu_item.setTarget_(self._STD_ACTION_MAP[self.name][0]) + menu_item.setAction_(self._STD_ACTION_MAP[self.name][1]) + else: + menu_item.setTarget_(NSApp().delegate()) + menu_item.setAction_('handleMenuActivate:') + return menu_item + + def _setup_shortcut(self, shortcut): + if shortcut is None: + key = '' + modifier_mask = 0 + elif isinstance(shortcut.shortcut, str): + key = shortcut.shortcut + modifier_mask = make_modifier_mask(shortcut) + elif shortcut.shortcut in KEYS_MAP: + key = KEYS_MAP[shortcut.shortcut] + modifier_mask = make_modifier_mask(shortcut) + else: + logging.warn("Don't know how to handle shortcut: %s", shortcut) + return + self._menu_item.setKeyEquivalent_(key) + self._menu_item.setKeyEquivalentModifierMask_(modifier_mask) + + def _change_shortcut(self, shortcut): + self._setup_shortcut(shortcut) + + def set_label(self, new_label): + self._menu_item.setTitle_(new_label) + + def get_label(self): + self._menu_item.title() + + def _find_menubar(self): + """Remove this menu item from it's parent Menu.""" + menu_item = self + while menu_item.parent is not None: + menu_item = menu_item.parent + if isinstance(menu_item, MenuBar): + return menu_item + else: + return None + +class CheckMenuItem(MenuItem): + """See the GTK version of this method for the current docstring.""" + def set_state(self, active): + if active is None: + state = NSMixedState + elif active: + state = NSOnState + else: + state = NSOffState + self._menu_item.setState_(state) + + def get_state(self): + return self._menu_item.state() == NSOnState + + def do_activate(self): + if self._menu_item.state() == NSOffState: + self._menu_item.setState_(NSOnState) + else: + self._menu_item.setState_(NSOffState) + +class RadioMenuItem(CheckMenuItem): + """See the GTK version of this method for the current docstring.""" + def __init__(self, label, name, shortcut=None): + CheckMenuItem.__init__(self, label, name, shortcut) + # The leader of a radio group stores the list of all items in the + # group + self.group_leader = None + self.others_in_group = set() + + def set_group(self, group_item): + if self.group_leader is not None: + raise ValueError("%s is already in a group" % self) + if group_item.group_leader is None: + group_leader = group_item + else: + group_leader = group_item.group_leader + if group_leader.group_leader is not None: + raise AssertionError("group_leader structure is wrong") + self.group_leader = group_leader + group_leader.others_in_group.add(self) + + def remove_from_group(self): + """Remove this RadioMenuItem from its current group.""" + if self.group_leader is not None: + # we have a group leader, remove ourself from their list. + # Note that this code will work even if we're the last item in + # others_in_group. + self.group_leader.others_in_group.remove(self) + self.group_leader = None + elif len(self.others_in_group) > 1: + # we're the group leader, hand off the leader to a different item + first_item = iter(self.others_in_group).next() + for other in self.others_in_group: + if other is first_item: + other.others_in_group = self.others_in_group + other.others_in_group.remove(first_item) + other.group_leader = None + else: + other.group_leader = first_item + self.others_in_group = set() + elif len(self.others_in_group) == 1: + # we're the group leader, but there's only 1 other item. unset + # everything. + for other in self.others_in_group: + other.group_leader = None + self.others_in_group = set() + + def _items_in_group(self): + if self.group_leader is not None: # we have a group leader + yield self.group_leader + for other in self.group_leader.others_in_group: + yield other + elif self.others_in_group: # we're the group leader + yield self + for other in self.others_in_group: + yield other + else: # we don't have a group set + yield self + + def do_activate(self): + for item in self._items_in_group(): + if item is not self: + item.set_state(False) + CheckMenuItem.do_activate(self) + +class Separator(MenuItemBase): + """See the GTK version of this method for the current docstring.""" + def __init__(self): + MenuItemBase.__init__(self) + self._menu_item = NSMenuItem.separatorItem() + +class MenuShell(signals.SignalEmitter): + def __init__(self, nsmenu): + signals.SignalEmitter.__init__(self) + self._menu = nsmenu + self.children = [] + self.parent = None + + def append(self, menu_item): + """Add a menu item to the end of this menu.""" + self.children.append(menu_item) + self._menu.addItem_(menu_item._menu_item) + menu_item.parent = self + + def insert(self, index, menu_item): + """Insert a menu item in the middle of this menu.""" + self.children.insert(index, menu_item) + self._menu.insertItem_atIndex_(menu_item._menu_item, index) + menu_item.parent = self + + def index(self, name): + """Find the position of a child menu item.""" + for i, menu_item in enumerate(self.children): + if menu_item.name == name: + return i + return -1 + + def remove(self, menu_item): + """Remove a child menu item. + + :raises ValueError: menu_item is not a child of this menu + """ + self.children.remove(menu_item) + self._menu.removeItem_(menu_item._menu_item) + menu_item.parent = None + + def get_children(self): + """Get the child menu items in order.""" + return list(self.children) + + def find(self, name): + """Search for a menu or menu item + + This method recursively searches the entire menu structure for a Menu + or MenuItem object with a given name. + + :raises KeyError: name not found + """ + found = self._find(name) + if found is None: + raise KeyError(name) + else: + return found + + def _find(self, name): + """Low-level helper-method for find(). + + :returns: found menu item or None. + """ + for menu_item in self.get_children(): + if menu_item.name == name: + return menu_item + if isinstance(menu_item, Menu): + submenu_find = menu_item._find(name) + if submenu_find is not None: + return submenu_find + return None + +class Menu(MenuShell): + """See the GTK version of this method for the current docstring.""" + def __init__(self, label, name, child_items=None): + MenuShell.__init__(self, NSMenu.alloc().init()) + self._menu.setTitle_(_remove_mnemonic(label)) + # we will enable/disable menu items manually + self._menu.setAutoenablesItems_(False) + self.name = name + if child_items is not None: + for item in child_items: + self.append(item) + self._menu_item = NSMenuItem.alloc().init() + self._menu_item.setTitle_(_remove_mnemonic(label)) + self._menu_item.setSubmenu_(self._menu) + # Hack to set the services menu + if name == "ServicesMenu": + NSApp().setServicesMenu_(self._menu_item) + + def show(self): + self._menu_item.setHidden_(False) + + def hide(self): + self._menu_item.setHidden_(True) + + def enable(self): + self._menu_item.setEnabled_(True) + + def disable(self): + self._menu_item.setEnabled_(False) + +class AppMenu(MenuShell): + """Wrapper for the application menu (AKA the Miro menu) + + We need to special case this because OSX automatically creates the menu + item. + """ + def __init__(self): + MenuShell.__init__(self, NSApp().mainMenu().itemAtIndex_(0).submenu()) + self.name = "Libre Video Converter" + +class MenuBar(MenuShell): + """See the GTK version of this method for the current docstring.""" + def __init__(self): + MenuShell.__init__(self, NSApp().mainMenu()) + self.create_signal('activate') + self._add_app_menu() + + def _add_app_menu(self): + """Add the app menu to this menu bar. + + We need to special case this because OSX automatically adds the + NSMenuItem for the app menu, we just need to set up our wrappers. + """ + self._app_menu = AppMenu() + self.children.append(self._app_menu) + self._app_menu.parent = self + + def add_initial_menus(self, menus): + for menu in menus: + self.append(menu) + self._modify_initial_menus() + + def _extract_menu_item(self, name): + """Helper method for changing the portable menu structure.""" + menu_item = self.find(name) + menu_item.remove_from_parent() + return menu_item + + def _modify_initial_menus(self): + short_appname = "Libre Video Converter" # XXX + + # Application menu + miroMenuItems = [ + self._extract_menu_item("About"), + Separator(), + self._extract_menu_item("Quit") + ] + + for item in miroMenuItems: + self._app_menu.append(item) + + self._app_menu.find("Quit").set_label(_("Quit %(appname)s", + {"appname": short_appname})) + + # Help Menu + #helpItem = self.find("Help") + #helpItem.set_label(_("%(appname)s Help", {"appname": short_appname})) + #helpItem._change_shortcut(Shortcut("?", MOD)) + + self._update_present_menu() + self._connect_to_signals() + + def do_activate(self, name): + # We handle a couple OSX-specific actions here + if name == "PresentActualSize": + NSApp().delegate().present_movie('natural-size') + elif name == "PresentDoubleSize": + NSApp().delegate().present_movie('double-size') + elif name == "PresentHalfSize": + NSApp().delegate().present_movie('half-size') + elif name == "ShowMain": + app.widgetapp.window.nswindow.makeKeyAndOrderFront_(self) + + def _connect_to_signals(self): + return + app.playback_manager.connect("will-play", self._on_playback_change) + app.playback_manager.connect("will-stop", self._on_playback_change) + + def _on_playback_change(self, playback_manager, *args): + self._update_present_menu() + + def _update_present_menu(self): + return + if self._should_enable_present_menu(): + for menu_item in self.present_menu.get_children(): + menu_item.enable() + else: + for menu_item in self.present_menu.get_children(): + menu_item.disable() + + def _should_enable_present_menu(self): + return False + if (app.playback_manager.is_playing and + not app.playback_manager.is_playing_audio): + # we're currently playing video, allow the user to fullscreen + return True + selection_info = app.item_list_controller_manager.get_selection_info() + if (selection_info.has_download and + selection_info.has_file_type('video')): + # A downloaded video is selected, allow the user to start playback + # in fullscreen + return True + return False + +#class ContextMenuHandler(NSObject): +# def initWithCallback_(self, callback): +# self = super(ContextMenuHandler, self).init() +# self.callback = callback +# return self +# +# def handleMenuItem_(self, sender): +# self.callback() +# +#class MiroContextMenu(NSMenu): +# # Works exactly like NSMenu, except it keeps a reference to the menu +# # handler objects. +# def init(self): +# self = super(MiroContextMenu, self).init() +# self.handlers = set() +# return self +# +# def addItem_(self, item): +# if isinstance(item.target(), ContextMenuHandler): +# self.handlers.add(item.target()) +# return NSMenu.addItem_(self, item) +# +def make_context_menu(menu_items): + nsmenu = MiroContextMenu.alloc().init() + for item in menu_items: + if item is None: + nsitem = NSMenuItem.separatorItem() + else: + label, callback = item + nsitem = NSMenuItem.alloc().init() + if isinstance(label, tuple) and len(label) == 2: + label, icon_path = label + image = NSImage.alloc().initWithContentsOfFile_(icon_path) + nsitem.setImage_(image) + if callback is None: + font_size = NSFont.systemFontSize() + font = NSFont.fontWithName_size_("Lucida Sans Italic", font_size) + if font is None: + font = NSFont.systemFontOfSize_(font_size) + attributes = {NSFontAttributeName: font} + attributed_label = NSAttributedString.alloc().initWithString_attributes_(label, attributes) + nsitem.setAttributedTitle_(attributed_label) + else: + nsitem.setTitle_(label) + if isinstance(callback, list): + submenu = make_context_menu(callback) + nsmenu.setSubmenu_forItem_(submenu, nsitem) + else: + handler = ContextMenuHandler.alloc().initWithCallback_(callback) + nsitem.setTarget_(handler) + nsitem.setAction_('handleMenuItem:') + nsmenu.addItem_(nsitem) + return nsmenu + +def translate_event_modifiers(event): + mods = set() + flags = event.modifierFlags() + if flags & NSCommandKeyMask: + mods.add(keyboard.CMD) + if flags & NSControlKeyMask: + mods.add(keyboard.CTRL) + if flags & NSAlternateKeyMask: + mods.add(keyboard.ALT) + if flags & NSShiftKeyMask: + mods.add(keyboard.SHIFT) + return mods |