# @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