/** \file hotkeys.c * \brief Gtk3 custom hotkeys handling * * Provides custom keyboard shortcuts for the Gtk3 UI. * * \author Bas Wassink */ /* * This file is part of VICE, the Versatile Commodore Emulator. * See README for copyright notice. * * 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., 59 Temple Place, Suite 330, Boston, MA * 02111-1307 USA. */ /* Resources manipulated in this file: * * $VICERES HotkeyFile all */ #include "vice.h" #include #include #include #include #include #include #include "archdep.h" #include "debug_gtk3.h" #include "cmdline.h" #include "lib.h" #include "log.h" #include "machine.h" #include "parser.h" #include "textfilereader.h" #include "ui.h" #include "uiapi.h" #include "uiactions.h" #include "uihotkeys.h" #include "uimenu.h" #include "util.h" #include "version.h" #include "vice_gtk3.h" #ifdef USE_SVN_REVISION #include "svnversion.h" #endif #include "hotkeys.h" /** \brief Reference to the accelerator group * * Global accelerator group used for all accelerators in UI. */ static GtkAccelGroup *accel_group = NULL; /** \brief Check if window ID is valid * * Check if \a window_id is either #PRIMARY_WINDOW or #SECONDARY_WINDOW. * * Logs an error if \a window_id is invalid. * * \param[in] window_id window ID */ static gboolean valid_window_id(gint window_id) { if (window_id != PRIMARY_WINDOW && window_id != SECONDARY_WINDOW) { log_error(LOG_DEFAULT, "Invalid window ID of %d.", window_id); return FALSE; } return TRUE; } /** \brief Callback that forwards accelerator codes * * \param[in] accel_grp accelerator group (unused) * \param[in] acceleratable ? (unused) * \param[in] keyval GDK keyval (unused) * \param[in] modifiers GDK key modifier(s) (unused) * \param[in] action UI action ID */ static gboolean handle_accelerator(GtkAccelGroup *accel_grp, GObject *acceleratable, guint keyval, GdkModifierType modifiers, gpointer action) { ui_action_trigger(GPOINTER_TO_INT(action)); return TRUE; } /** \brief Set up a closure to trigger UI action for a hotkey * * Create a closure to trigger UI \a action for \a keysym and \a modifier. * This way hotkeys will work in fullscreen and also when there's no menu item * associated with \a action. * * \param[in] action UI action ID * \param[in] keysym Gdk keysym * \param[in] modifier Gdk modifier mask * \param[in] unlocked connect accelator non-lockeding */ static void connect_accelerator(int action, guint keysym, GdkModifierType modifier, bool unlocked) { GClosure *closure = g_cclosure_new(G_CALLBACK(handle_accelerator), GINT_TO_POINTER(action), NULL); if (unlocked) { gtk_accel_group_connect(accel_group, keysym, modifier, GTK_ACCEL_MASK, closure); } else { vice_locking_gtk_accel_group_connect(accel_group, keysym, modifier, GTK_ACCEL_MASK, closure); } } /** \brief Set accelerator for menu item, using new API * * \param[in] item runtime menu item * \param[in] arch_keysym Gkd keysym * \param[in] arch_modmask Gdk modifier mask * * \note This only sets the \a item's accelerator, it does not connect any * handler, the handler is set up during menu creation in uimenu.c. */ static void set_menu_item_accel(GtkWidget *item, uint32_t arch_keysym, uint32_t arch_modmask) { GtkWidget *label = gtk_bin_get_child(GTK_BIN(item)); #if 0 debug_gtk3("called with keysym %04x, mask %08x, item = %p", arch_keysym, arch_modmask, (const void*)item); #endif if (label != NULL) { gtk_accel_label_set_accel(GTK_ACCEL_LABEL(label), arch_keysym, arch_modmask); } } /** \brief Clear accelerator from runtime menu item * * \param[in] item runtime menu item */ static void clear_menu_item_accel(GtkWidget *item) { GtkWidget *label = gtk_bin_get_child(GTK_BIN(item)); gtk_accel_label_set_accel(GTK_ACCEL_LABEL(label), 0, 0); } /** \brief Remove accelerator from global accelerator group * * \param[in] keysym Gdk keysym * \param[in] modifier Gdk modifier mask * * \return `TRUE` on success */ gboolean vhk_gtk_remove_accelerator(guint keysym, GdkModifierType modifier) { return gtk_accel_group_disconnect_key(accel_group, keysym, modifier); } /** \brief Create accelerator group and add it to \a window * * \param[in] window top level window * * \note Allocating the accel group in ui_hotkeys_arch_init() cannot be done * since it's too late in the UI setup process. */ void vhk_gtk_init_accelerators(GtkWidget *window) { /* single accelerator group for both windows */ if (accel_group == NULL) { accel_group = gtk_accel_group_new(); } gtk_window_add_accel_group(GTK_WINDOW(window), accel_group); } /** \brief Get accelerator label for hotkey in \a map * * \param[in] map hotkey map * * \return accelerator label or `NULL` when no hotkey defined * * \note The value returned is allocated by Gtk and should be freed after * use with g_free() * * \todo Rename */ gchar *vhk_gtk_get_accel_label_by_map(const ui_action_map_t *map) { if (map->arch_keysym > 0) { return gtk_accelerator_get_label(map->arch_keysym, map->arch_modmask); } return NULL; } /** \brief Get accelerator label for UI action, if any * * \param[in] action UI action ID * * \return accelerator label or `NULL when \a action not found or no hotkey * exists for the \a action * * \todo Rename */ gchar *vhk_gtk_get_accel_label_by_action(int action) { ui_action_map_t *map = ui_action_map_get(action); if (map != NULL) { return vhk_gtk_get_accel_label_by_map(map); } return NULL; } /** \brief Get runtime menu item for UI action and main window * * \param[in] action UI action ID * \param[in] window_id window ID (`PRIMARY_WINDOW` or `SECONDARY_WINDOW`) * * \return menu item or `NULL` when not found * * TODO: Nothing Gtk-specific in this function: could be moved to shared * code and return a `void*`. */ GtkWidget *vhk_gtk_get_menu_item_by_action_for_window(int action, int window_id) { if (valid_window_id(window_id)) { ui_action_map_t *map = ui_action_map_get(action); if (map != NULL) { return map->menu_item[window_id]; } } return NULL; } /** \brief Set accelerator label to the hotkey associated with UI action * * Look up \a action and if found set the accelerator label of \a item to the * hotkey defined for \a action, if the action is not found the accelerator * label will be cleared. * This allows context menus to display an accelerator next to an item. Only * sets the label of a menu item, no action handler is set for the item. * * \param[in] item runtime menu item * \param[in] action UI action ID */ void vhk_gtk_set_menu_item_accel_label(GtkWidget *item, int action) { ui_action_map_t *map; GtkWidget *label; label = gtk_bin_get_child(GTK_BIN(item)); map = ui_action_map_get(action); if (map != NULL) { gtk_accel_label_set_accel(GTK_ACCEL_LABEL(label), map->arch_keysym, map->arch_modmask); } else { gtk_accel_label_set_accel(GTK_ACCEL_LABEL(label), 0, 0); } } /** \brief Check/uncheck check menu item while blocking its handler * * Set a checkbox menu item's state while blocking the 'activate' handler so * the handler won't recursively call itself. * * \param[in] item GtkCheckMenuItem instance * \param[in] checked new check button state */ void vhk_gtk_set_check_item_blocked(GtkWidget *item, gboolean checked) { gulong handler_id = GPOINTER_TO_ULONG(g_object_get_data(G_OBJECT(item), "HandlerID")); g_signal_handler_block(item, handler_id); gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), checked); g_signal_handler_unblock(item, handler_id); } /** \brief Check/uncheck check menu item(s) mapped to UI action * * Set menu item or items (x128) that are registered for UI \a action to * \a checked. * * \note This will usually suffice for most items, but in cases where x128 * can have different states for a menu item per window (status bar * enable/disable, fullscreen, fulllscreen-decorations) the function * vhk_gtk_set_check_item_blocked_by_action_for_window() is available. * * \param[in] action UI action ID * \param[in] checked new checked state for menu item(s) */ void vhk_gtk_set_check_item_blocked_by_action(int action, gboolean checked) { ui_action_map_t *map = ui_action_map_get(action); if (map != NULL) { if (map->menu_item[PRIMARY_WINDOW] != NULL) { vhk_gtk_set_check_item_blocked(map->menu_item[PRIMARY_WINDOW], checked); } if (map->menu_item[SECONDARY_WINDOW] != NULL) { vhk_gtk_set_check_item_blocked(map->menu_item[SECONDARY_WINDOW], checked); } } } /** \brief Check/uncheck check menu item mapped to UI action for a window * * Set menu item for a main window that is registered for UI \a action to * \a checked. * * \param[in] action UI action ID * \param[in] window_id window ID (`PRIMARY_WINDOW` or `SECONDARY_WINDOW`) * \param[in] checked new checked state for menu item(s) */ void vhk_gtk_set_check_item_blocked_by_action_for_window(int action, int window_id, gboolean checked) { if (valid_window_id(window_id)) { ui_action_map_t *map = ui_action_map_get(action); if (map != NULL) { vhk_gtk_set_check_item_blocked(map->menu_item[window_id], checked); } } } /****************************************************************************** * Virtual method implementations of the interface in src/uiapi.h * *****************************************************************************/ /* * Helpers functions */ /** \brief Create gtk3-specific hotkey data object * * Create object with a reference to the menu item declaration for a UI action * and signal handler IDs to allow the UI code to block/unblock signal handlers. * The menu item declaration contains a bool indicating whether to connect a * signal handler directly or through the VICE locking mechanism. The signal * handler IDs are used to temporarily block signal handlers from triggering * when updating their menu items' state (e.g. check/radio buttons). * * \param[in] decl UI menu item declaration * * \return new gtk3-specific hotkey data object * * \note Free object with vhk_map_gtk_free() */ vhk_gtk_map_t *vhk_gtk_map_new(const ui_menu_item_t *decl) { vhk_gtk_map_t *arch_map; arch_map = lib_malloc(sizeof *arch_map); arch_map->decl = decl; arch_map->handler[PRIMARY_WINDOW] = 0; arch_map->handler[SECONDARY_WINDOW] = 0; return arch_map; } /** \brief Free memory used by gtk3-specific hotkey data object * * Free memory used by \a arch_map and its members. * * \param[in] arch_map gtk3-specific hotkey data object */ void vhk_gtk_map_free(vhk_gtk_map_t *arch_map) { if (arch_map != NULL) { lib_free(arch_map); } } /* * API implementations */ /** \brief Virtual method for obtaining Gdk modifier mask from VICE modifier mask * * Get GDK modifier mask bit from VICE modifier mask bit * * \param[in] vice_mod VICE modifier mask bit * * \return GDK modifier mask bit * * \note Only works on single-bit values, for combined values we'll need * another (UI-agnostic) function. */ uint32_t ui_hotkeys_arch_modifier_to_arch(uint32_t vice_mod) { switch (vice_mod) { case VHK_MOD_ALT: /* fall through */ case VHK_MOD_OPTION: return GDK_MOD1_MASK; case VHK_MOD_COMMAND: /* fall through */ case VHK_MOD_META: return GDK_META_MASK; case VHK_MOD_CONTROL: return GDK_CONTROL_MASK; case VHK_MOD_HYPER: return GDK_HYPER_MASK; case VHK_MOD_SHIFT: return GDK_SHIFT_MASK; case VHK_MOD_SUPER: return GDK_SUPER_MASK; default: return 0; } } /** \brief VICE modifier mask bit from GDK modifier mask bit * * \param[in] arch_mod GDK modifier mask bit * * \return VICE modifier mask bit * * \note Returns different values on MacOS vs normal OSes. */ uint32_t ui_hotkeys_arch_modifier_from_arch(uint32_t arch_mod) { switch (arch_mod) { case GDK_MOD1_MASK: #ifdef MACOS_COMPILE return VHK_MOD_OPTION; #else return VHK_MOD_ALT; #endif case GDK_META_MASK: #ifdef MACOS_COMPILE return VHK_MOD_COMMAND; #else return VHK_MOD_META; #endif case GDK_CONTROL_MASK: return VHK_MOD_CONTROL; case GDK_HYPER_MASK: return VHK_MOD_HYPER; case GDK_SHIFT_MASK: return VHK_MOD_SHIFT; case GDK_SUPER_MASK: return VHK_MOD_SUPER; default: return 0; } } /** \brief Translate VICE keysym to UI keysym * * \param[in] vice_keysym VICE-specific keysym * * \return UI-specific keysym * * \see src/arch/shared/hotkeys/vhkkeysyms.h */ uint32_t ui_hotkeys_arch_keysym_to_arch(uint32_t vice_keysym) { /* Compyx was clever here, using X11 keysyms for VICE, which happen to * also be used by Gdk ;) */ return vice_keysym; } /** \brief Translate UI keysym to VICE keysym * * \param[in] arch_keysym UI-specific keysym * * \return VICE-specific keysym * * \see src/arch/shared/hotkeys/vhkkeysyms.h */ uint32_t ui_hotkeys_arch_keysym_from_arch(uint32_t arch_keysym) { if (arch_keysym == GDK_KEY_VoidSymbol) { arch_keysym = 0; } return arch_keysym; } /** \brief Translate a full modifier mask from VICE to Gdk * * \param[in] vice_modmask VICE modifier mask * * \return Gdk modifier mask * * \todo We might be able to move this into shared/hotkeys, reducing the * number of virtual methods required for a UI. */ uint32_t ui_hotkeys_arch_modmask_to_arch(uint32_t vice_modmask) { uint32_t mask = 0; uint32_t bit = 0; while (vice_modmask != 0) { /* printf("%s(): vice_modmask = %08x\n", __func__, vice_modmask);*/ /* add UI modifier translated from VICE modifier */ mask |= ui_hotkeys_arch_modifier_to_arch(vice_modmask & (1u << bit)); /* clear VICE modifier */ vice_modmask &= ~(1u << bit); bit++; } return mask; } /** \brief Translate a full modifier mask from Gdk to VICE * * \param[in] arch_modmask Gdk modifier mask * * \return VICE modifier mask * * \todo We might be able to move this into shared/hotkeys, reducing the * number of virtual methods required for a UI. */ uint32_t ui_hotkeys_arch_modmask_from_arch(uint32_t arch_modmask) { uint32_t mask = 0; uint32_t bit = 0; while (arch_modmask != 0) { mask |= ui_hotkeys_arch_modifier_from_arch(arch_modmask & (1u << bit)); arch_modmask &= ~(1u << bit); bit++; } return mask; } /* Install hotkey, see src/uiapi.h for docblock */ void ui_hotkeys_arch_install_by_map(ui_action_map_t *map) { const vhk_gtk_map_t *arch_map; const ui_menu_item_t *item_decl; gboolean unlocked = FALSE; /* get arch-specific data and try to get `unlocked` property of the * signal handler */ arch_map = map->user_data; if (arch_map != NULL) { item_decl = arch_map->decl; if (item_decl != NULL) { unlocked = item_decl->unlocked; } } #if 0 debug_gtk3("connecting accelerator"); #endif connect_accelerator(map->action, map->arch_keysym, map->arch_modmask, unlocked); if (map->menu_item[PRIMARY_WINDOW] != NULL) { #if 0 debug_gtk3("got primary menu item"); #endif set_menu_item_accel(map->menu_item[PRIMARY_WINDOW], map->arch_keysym, map->arch_modmask); } /* x128 */ if (map->menu_item[SECONDARY_WINDOW] != NULL) { #if 0 debug_gtk3("got secondary menu item"); #endif set_menu_item_accel(map->menu_item[SECONDARY_WINDOW], map->arch_keysym, map->arch_modmask); } } /* Remove hotkey, see src/uiapi.h for docblock */ void ui_hotkeys_arch_remove_by_map(ui_action_map_t *map) { #if 0 printf("%s(): action = %d (%s)\n", __func__, map->action, ui_action_get_name(map->action)); printf("%s(): vice keysym/modmask: %04x/%08x, arch keysym/modmask: %04x/%08x\n", __func__, map->vice_keysym, map->vice_modmask, map->arch_keysym, map->arch_modmask); #endif /* remove accelator from Gtk accel group */ vhk_gtk_remove_accelerator(map->arch_keysym, map->arch_modmask); /* remove accelerator labels from menu items */ if (map->menu_item[PRIMARY_WINDOW] != NULL) { clear_menu_item_accel(map->menu_item[PRIMARY_WINDOW]); } /* x128 */ if (map->menu_item[SECONDARY_WINDOW] != NULL) { clear_menu_item_accel(map->menu_item[SECONDARY_WINDOW]); } } /** \brief Initialize Gtk3-specific hotkeys resources * * \note Does *not* initialize command line options or vice resources, that * is done separately in hotkeys_cmdline_options_init() and * hotkeys_resources_init(). */ void ui_hotkeys_arch_init(void) { } /** \brief Gtk3-specific hotkeys shutdown function * * Implements virtual method in uiapi.h that's called on generic hotkeys shut * down. * Frees the Gtk3-specific hotkey data in the generic hotkeys array. */ void ui_hotkeys_arch_shutdown(void) { int action; for (action = 0; action < ACTION_ID_COUNT; action++) { ui_action_map_t *map = ui_action_map_get(action); if (map != NULL) { vhk_gtk_map_t *arch_map = map->user_data; if (arch_map != NULL) { vhk_gtk_map_free(arch_map); } map->user_data = NULL; } } g_object_unref(accel_group); }