actiontriggers.py

Go to the documentation of this file.

#  Copyright 2008-2015 Nokia Networks
#  Copyright 2016-     Robot Framework Foundation
#
#  Licensed under the Apache License, Version 2.0 (the "License");
#  you may not use this file except in compliance with the License.
#  You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
#  Unless required by applicable law or agreed to in writing, software
#  distributed under the License is distributed on an "AS IS" BASIS,
#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#  See the License for the specific language governing permissions and
#  limitations under the License.
 
import wx
 
from ..context import IS_WINDOWS, IS_MAC
 
ID_CustomizeToolbar = wx.ID_HIGHEST + 1
 
 
class MenuBar():
 
    def __init__(self, frame):
        self._mb_mb = wx.MenuBar()
        self._name_builder_name_builder = _NameBuilder()
        self._frame_frame = frame
        self._accelerators_accelerators = []
        self._menus_menus = []
        self._create_default_menus_create_default_menus()
 
    
    def take_menu_bar_into_use(self):
        self._frame_frame.SetMenuBar(self._mb_mb)
 
    def _create_default_menus(self):
        for name in ['File', 'Edit', 'Tools', 'Help']:
            self._create_menu_create_menu(name, before_help=False)
 
    def _create_menu(self, name, before_help=True):
        menu = _Menu(self._name_builder_name_builder.get_name(name), self._frame_frame)
        self._insert_menu_insert_menu(menu, before_help)
        return menu
 
    def _insert_menu(self, menu, before_help):
        if before_help:
            index = [m.name for m in self._menus_menus].index('&Help')
        else:
            index = len(self._menus_menus)
        self._menus_menus.insert(index, menu)
        self._mb_mb.Insert(index, menu.wx_menu, menu.name)
 
    def register(self, action):
        menu = self._find_menu_find_menu(action.menu_name)
        if not menu:
            menu = self._create_menu_create_menu(action.menu_name)
        menu.add_menu_item(action)
 
    def _find_menu(self, name):
        registered = self._name_builder_name_builder.get_registered_name(name)
        if not registered:
            return None
        for menu in self._menus_menus:
            if menu.name == registered:
                return menu
 
 
class _Menu():
 
    def __init__(self, name, frame):
        self.namename = name
        self._frame_frame = frame
        self.wx_menuwx_menu = wx.Menu()
        self._menu_items_menu_items = {}
        self._name_builder_name_builder = _NameBuilder()
        self._open_open = False
        self._frame_frame.Bind(wx.EVT_MENU_OPEN, self.OnMenuOpenOnMenuOpen)
        self._frame_frame.Bind(wx.EVT_MENU_CLOSE, self.OnMenuCloseOnMenuClose)
 
    def OnMenuOpen(self, event):
        if self.wx_menuwx_menu == event.GetMenu() and not self._open_open:
            self._open_open = True
            for menu_item in self._menu_items_menu_items.values():
                menu_item.refresh_availability()
        event.Skip()
 
    def OnMenuClose(self, event):
        if self._open_open:
            self._open_open = False
            for menu_item in self._menu_items_menu_items.values():
                menu_item.set_enabled()
        event.Skip()
 
    def add_menu_item(self, action):
        menu_item = self._construct_menu_item_construct_menu_item(action)
        self._menu_items_menu_items[menu_item.id] = menu_item
        menu_item.register(action)
 
    def _construct_menu_item(self, action):
        if action.is_separator():
            return self._create_separator_create_separator(action)
        menu_item = self._get_menu_item_get_menu_item(action)
        if not menu_item:
            menu_item = self._create_menu_item_create_menu_item(action)
        return menu_item
 
    def _create_separator(self, action):
        menu_item = SeparatorMenuItem(self._frame_frame, self, action)
        pos = action.get_insertion_index(self.wx_menuwx_menu)
        menu_item.set_wx_menu_item(self.wx_menuwx_menu.InsertSeparator(pos))
        return menu_item
 
    def _get_menu_item(self, action):
        for menu_item in self._menu_items_menu_items.values():
            if self._names_equal_names_equal(menu_item, action):
                return menu_item
        return None
 
    def _names_equal(self, menu_item, action):
        return menu_item.name == self._get_name_get_name(action, build_new=False)
 
    def _get_name(self, action, build_new):
        get_name = build_new and self._name_builder_name_builder.get_name or \
                                 self._name_builder_name_builder.get_registered_name
        if not action.shortcut:  # DEBUG not action.shortcut:
            return get_name(action.name)
        sht = action.get_shortcut()
        if sht:
            return '%s    (%s)' % (get_name(action.name), sht)
        return '%s' % get_name(action.name)
 
    def _create_menu_item(self, action):
        name_with_accelerator = self._get_name_get_name(action, build_new=True)
        menu_item = MenuItem(self._frame_frame, self, name_with_accelerator)
        pos = action.get_insertion_index(self.wx_menuwx_menu)
        wx_menu_item = wx.MenuItem(self.wx_menuwx_menu, menu_item.id, menu_item.name, action.doc)
        if action.icon:
            wx_menu_item.SetBitmap(action.icon)
        wx_menu_item = self.wx_menuwx_menu.Insert(pos, wx_menu_item)
        menu_item.set_wx_menu_item(wx_menu_item)
        return menu_item
 
    def remove_menu_item(self, id):
        self.wx_menuwx_menu.Delete(id)
        del(self._menu_items_menu_items[id])
 
 
class _NameBuilder():
 
    def __init__(self):
        self._names_names = {}
        self._accelerators_accelerators = []
 
    def get_name(self, name):
        registered = self.get_registered_nameget_registered_name(name)
        if registered:
            return registered
        try:
            name = self._use_given_accelerator_use_given_accelerator(name)
        except ValueError:
            name = self._generate_accelerator_generate_accelerator(name)
        self._register_register(name)
        return name
 
    def get_registered_name(self, name):
        try:
            return self._names_names[name.replace('&', '').upper()]
        except KeyError:
            return None
 
    def _register(self, name):
        self._names_names[name.replace('&', '').upper()] = name
 
    def _use_given_accelerator(self, name):
        index = name.find('&') + 1
        if 0 < index < len(name) and self._accelerator_is_free_accelerator_is_free(name[index]):
            return name
        raise ValueError
 
    def _generate_accelerator(self, name):
        name = name.replace('&', '')
        for pos, char in enumerate(name):
            if self._accelerator_is_free_accelerator_is_free(char):
                return '%s&%s' % (name[:pos], name[pos:])
        return name
 
    def _accelerator_is_free(self, char):
        char = char.upper()
        if char not in self._accelerators_accelerators and char != u' ':
            self._accelerators_accelerators.append(char)
            return True
        return False
 
 
class _MenuItem():
 
    def __init__(self, frame, menu, name):
        self._frame_frame = frame
        self._menu_menu = menu
        self.namename = name
        self._action_delegator_action_delegator = ActionDelegator(self._frame_frame)
        self.idid = self._action_delegator_action_delegator.id
 
    def set_wx_menu_item(self, wx_menu_item):
        self._wx_menu_item_wx_menu_item = wx_menu_item
 
    def register(self, action):
        self._action_delegator_action_delegator.add(action)
        action.register(self)
 
    def unregister(self, action):
        if self._action_delegator_action_delegator.remove(action):
            self._menu_menu.remove_menu_item(self.idid)
 
    def refresh_availability(self):
        self._wx_menu_item_wx_menu_item.Enable(self._is_enabled())
 
    def set_enabled(self):
        self._wx_menu_item_wx_menu_item.Enable(True)
 
 
class MenuItem(_MenuItem):
 
    def _is_enabled(self):
        return self._action_delegator_action_delegator.is_active()
 
 
class SeparatorMenuItem(_MenuItem):
 
    def set_wx_menu_item(self, wx_menu_item):
        _MenuItem.set_wx_menu_item(self, wx_menu_item)
        # Should get  ITEM_SEPARATOR
        self.ididid = wx.ID_SEPARATOR
 
    def _is_enabled(self):
        return False
 
    def set_enabled(self):
        pass
 
 
class _RideSearchMenuItem():
 
    def __init__(self, handler, icon):
        self._handler_handler = handler
        self.iconicon = icon
 
    def __call__(self, *args, **kwargs):
        self._handler_handler(*args, **kwargs)
 
 
class ToolBarButton():
 
    def __init__(self, frame, toolbar, action):
        self._toolbar_toolbar = toolbar
        self.iconicon = action.icon
        self._action_delegator_action_delegator = ActionDelegator(frame)
        self.idid = self._action_delegator_action_delegator.id
 
    def register(self, action):
        self._action_delegator_action_delegator.add(action)
        action.register(self)
        action.inform_changes_in_enabled_status(self)
 
    def unregister(self, action):
        if self._action_delegator_action_delegator.remove(action):
            self._toolbar_toolbar.remove_toolbar_button(self)
 
    def enabled_status_changed(self, action):
        self._toolbar_toolbar.enabled_status_changed(self.idid, action)
 
 
class ShortcutRegistry():
 
    def __init__(self, frame):
        self._frame_frame = frame
        self._actions_actions = {}
 
    def register(self, action):
        if action.has_shortcut() and action.has_action():
            delegator = self._actions_actions.setdefault(action.get_shortcut(),
                                                 ActionDelegator(self._frame_frame,
                                                 action.shortcut))
            delegator.add(action)
            action.register(self)
            self._update_accelerator_table_update_accelerator_table()
 
    def unregister(self, action):
        key = action.get_shortcut()
        if self._actions_actions[key].remove(action):
            del(self._actions_actions[key])
        self._update_accelerator_table_update_accelerator_table()
 
    def _update_accelerator_table(self):
        accelerators = []
        for delegator in self._actions_actions.values():
            try:
                flags, key_code = delegator.shortcut.parse()
            except TypeError:
                continue
            accelerators.append(wx.AcceleratorEntry(flags, key_code,
                                                    delegator.id))
        self._frame_frame.SetAcceleratorTable(wx.AcceleratorTable(accelerators))
 
 
class ActionDelegator():
 
    def __init__(self, frame, shortcut=None):
        self._frame_frame = frame
        self.shortcutshortcut = shortcut
        self.idid = wx.NewIdRef()
        self._actions_actions = []
 
    def add(self, action):
        self._actions_actions.append(action)
        if len(self._actions_actions) == 1:
            self._frame_frame.Bind(wx.EVT_MENU, self, id=self.idid)
 
    
    def remove(self, action):
        self._actions_actions.remove(action)
        if len(self._actions_actions) == 0:
            self._frame_frame.Unbind(wx.EVT_MENU, id=self.idid)
            return True
        return False
 
    def is_active(self):
        for action in self._actions_actions:
            if action.is_active():
                return True
        return False
 
    def __call__(self, event):
        for action in self._actions_actions:
            action.act(event)
        if not (IS_WINDOWS or IS_MAC):
            event.Skip()