AuroraMiddleware/gtk2
1
0
Fork 0
forked from AuroraMiddleware/gtk
Code Issues Pull Requests Projects Releases Wiki Activity
9536eb654b
gtk2/gtk/gtkactionmuxer.c

1470 lines
45 KiB
C
Raw Normal View History

add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
/*
* Copyright © 2011 Canonical Limited
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the licence, or (at your option) any later version.
*
* This library 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
Change FSF Address
2012-02-27 13:01:10 +00:00
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
*
* Author: Ryan Lortie <desrt@desrt.ca>
*/
#include "config.h"
Rename GtkActionMuxer's private header Follow the naming policy for private headers.
2018-02-02 09:13:10 +00:00
#include "gtkactionmuxerprivate.h"
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
Rename a bunch of private headers We want to follow the convention that all private headers have names ending in private.h
2019-06-10 03:10:13 +00:00
#include "gtkactionobservableprivate.h"
#include "gtkactionobserverprivate.h"
widget: fix class private data usage to be _init() safe Before this commit, adding GtkWidgetAction to class private data would require copying the actions to each subclass as they were built or modified. This was convenient in that it is a sort of "copy on write" semantic. However, due to the way that GTypeInstance works with base _init() functions, the "g_class" pointer in GTypeInstance is updated as each _init() function is called. That means you cannot access the subclasses class private data, but only the parent class private data. If instead we use a singly linked list of GtkWidgetAction, each subclass has their own "head" yet all subclasses share the tail of the GtkWidgetAction chain. This creates one bit of complexity though. You need a stable way to know which "bit" is the "enabled" bit of the action so we can track enabled GAction state. That is easily solved by calculating the distance to the end of the chain for a given action so that base classes sort ahead of subclasses. Since the parent class always knows its parent's actions, the position is stable. A new dynamic bitarray helper also helps us avoid allocations in all the current cases (up to 64 actions per widget) and dynamically switches to malloc if that is to ever be exceeded.
2020-03-20 16:22:29 +00:00
#include "gtkbitmaskprivate.h"
Intern all signal names beforehand This avoids pointless allocations
2015-09-12 13:13:00 +00:00
#include "gtkintl.h"
gtk: fix all uses of g_cclosure_marshal_generic This adds specific marshallers for all of the locations where a generic marshaller is being used. It also provides va_marshallers to reduce the chances that we get stack traces from perf going through ffi_call_unix64. This is forward ported from gtk-3-24. # Conflicts: # gtk/gtkeventcontrollerkey.c # gtk/gtkeventcontrollermotion.c # gtk/gtkgesture.c # gtk/gtkgesturemultipress.c
2019-06-02 21:07:27 +00:00
#include "gtkmarshalers.h"
widget: fix class private data usage to be _init() safe Before this commit, adding GtkWidgetAction to class private data would require copying the actions to each subclass as they were built or modified. This was convenient in that it is a sort of "copy on write" semantic. However, due to the way that GTypeInstance works with base _init() functions, the "g_class" pointer in GTypeInstance is updated as each _init() function is called. That means you cannot access the subclasses class private data, but only the parent class private data. If instead we use a singly linked list of GtkWidgetAction, each subclass has their own "head" yet all subclasses share the tail of the GtkWidgetAction chain. This creates one bit of complexity though. You need a stable way to know which "bit" is the "enabled" bit of the action so we can track enabled GAction state. That is easily solved by calculating the distance to the end of the chain for a given action so that base classes sort ahead of subclasses. Since the parent class always knows its parent's actions, the position is stable. A new dynamic bitarray helper also helps us avoid allocations in all the current cases (up to 64 actions per widget) and dynamically switches to malloc if that is to ever be exceeded.
2020-03-20 16:22:29 +00:00
#include "gtkwidgetprivate.h"
Replace stateful actions by property actions The only cases of stateful actions we've seen so far have been boolean properties, and we don't really want to add much state handling API, so lets just go with property actions for now. Adapt the only user in GtkText.
2019-06-22 20:18:05 +00:00
#include "gsettings-mapping.h"
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
#include <string.h>
actionmuxer: Use an array for accels We have a lot of accels across all the muxers, but the vast majority has just one or two, so an array is going to be smaller and faster for this.
2020-07-19 19:11:35 +00:00
typedef struct
{
char *action_and_target;
char *accel;
} GtkAccel;
static void
gtk_accel_clear (GtkAccel *accel)
{
g_free (accel->action_and_target);
g_free (accel->accel);
}
#define GDK_ARRAY_NAME gtk_accels
#define GDK_ARRAY_TYPE_NAME GtkAccels
#define GDK_ARRAY_ELEMENT_TYPE GtkAccel
#define GDK_ARRAY_FREE_FUNC gtk_accel_clear
#define GDK_ARRAY_BY_VALUE 1
#define GDK_ARRAY_PREALLOC 2
#include "gdk/gdkarrayimpl.c"
static guint
gtk_accels_find (GtkAccels *accels,
const char *action_and_target)
{
guint i;
for (i = 0; i < gtk_accels_get_size (accels); i++)
{
GtkAccel *accel = gtk_accels_index (accels, i);
if (strcmp (accel->action_and_target, action_and_target) == 0)
return i;
}
return G_MAXUINT;
}
static void
gtk_accels_replace (GtkAccels *accels,
const char *action_and_target,
const char *primary_accel)
{
guint position;
position = gtk_accels_find (accels, action_and_target);
if (position < gtk_accels_get_size (accels))
{
GtkAccel *accel = gtk_accels_index (accels, position);
g_free (accel->accel);
accel->accel = g_strdup (primary_accel);
}
else
{
GtkAccel accel;
accel.action_and_target = g_strdup (action_and_target);
accel.accel = g_strdup (primary_accel);
gtk_accels_append (accels, &accel);
}
}
static void
gtk_accels_remove (GtkAccels *accels,
const char *action_and_target)
{
guint position;
position = gtk_accels_find (accels, action_and_target);
if (position < gtk_accels_get_size (accels))
gdkarray: Add a "stolen" boolean to splice() If set to TRUE, does not call the free func for the removed items. This can be used to move items between arrays without having to do the refcounting dance.
2020-12-23 19:04:29 +00:00
gtk_accels_splice (accels, position, 1, FALSE, NULL, 0);
actionmuxer: Use an array for accels We have a lot of accels across all the muxers, but the vast majority has just one or two, so an array is going to be smaller and faster for this.
2020-07-19 19:11:35 +00:00
}
docs: mark gtkdoc blocks as private for internal only API
2014-01-22 02:47:34 +00:00
/*< private >
actionmuxer: Drop SECTION This is private.
2021-03-02 03:34:47 +00:00
* GtkActionMuxer:
*
* GtkActionMuxer aggregates and monitors actions from multiple sources.
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
*
gtk: Clean up docs syntax Replace leftover gtk-doc syntax (#Type) with backquotes.
2021-05-20 13:17:04 +00:00
* `GtkActionMuxer` is `GtkActionObservable` and `GtkActionObserver` that
* offers a `GActionGroup`-like api and is capable of containing other
* `GActionGroup` instances. `GtkActionMuxer` does not implement the
* `GActionGroup` interface because it requires excessive signal emissions
* and has poor scalability. We use the `GtkActionObserver` machinery
actionmuxer: Update docs and clean up headers Update the doc comment at the top to describe the current functionality of GtkActionMuxer.
2020-07-19 21:04:11 +00:00
* instead to propagate changes between action muxer instances and
* to other users.
*
gtk: Clean up docs syntax Replace leftover gtk-doc syntax (#Type) with backquotes.
2021-05-20 13:17:04 +00:00
* Beyond action groups, `GtkActionMuxer` can incorporate actions that
actionmuxer: Update docs and clean up headers Update the doc comment at the top to describe the current functionality of GtkActionMuxer.
2020-07-19 21:04:11 +00:00
* are associated with widget classes (*class actions*) and actions
* that are associated with the parent widget, allowing for recursive
* lookup.
*
gtk: Clean up docs syntax Replace leftover gtk-doc syntax (#Type) with backquotes.
2021-05-20 13:17:04 +00:00
* In addition to the action attributes provided by `GActionGroup`,
* `GtkActionMuxer` maintains a *primary accelerator* string for
actionmuxer: Update docs and clean up headers Update the doc comment at the top to describe the current functionality of GtkActionMuxer.
2020-07-19 21:04:11 +00:00
* actions that can be shown in menuitems.
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
*
Fix a typo
2011-12-16 03:20:42 +00:00
* The typical use is aggregating all of the actions applicable to a
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
* particular context into a single action group, with namespacing.
*
* Consider the case of two action groups -- one containing actions
docs: use proper quotations instead of '*'
2014-02-07 19:03:49 +00:00
* applicable to an entire application (such as “quit”) and one
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
* containing actions applicable to a particular window in the
docs: use proper quotations instead of '*'
2014-02-07 19:03:49 +00:00
* application (such as “fullscreen”).
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
*
* In this case, each of these action groups could be added to a
gtk: Clean up docs syntax Replace leftover gtk-doc syntax (#Type) with backquotes.
2021-05-20 13:17:04 +00:00
* `GtkActionMuxer` with the prefixes “app” and “win”, respectively.
actionmuxer: Update docs and clean up headers Update the doc comment at the top to describe the current functionality of GtkActionMuxer.
2020-07-19 21:04:11 +00:00
* This would expose the actions as “app.quit” and “win.fullscreen”
gtk: Clean up docs syntax Replace leftover gtk-doc syntax (#Type) with backquotes.
2021-05-20 13:17:04 +00:00
* on the `GActionGroup`-like interface presented by the `GtkActionMuxer`.
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
*
gtk: Clean up docs syntax Replace leftover gtk-doc syntax (#Type) with backquotes.
2021-05-20 13:17:04 +00:00
* Activations and state change requests on the `GtkActionMuxer` are
actionmuxer: Update docs and clean up headers Update the doc comment at the top to describe the current functionality of GtkActionMuxer.
2020-07-19 21:04:11 +00:00
* wired through to the underlying actions in the expected way.
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
*
docs: use proper quotes
2014-02-05 18:07:34 +00:00
* This class is typically only used at the site of “consumption” of
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
* actions (eg: when displaying a menu that contains many actions on
* different objects).
Undoccommentify action muxer files
2011-12-01 11:30:10 +00:00
*/
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
static void gtk_action_muxer_observable_iface_init (GtkActionObservableInterface *iface);
actionmuxer: Stop implementing GActionGroup Instead of implementing the GActionGroup interface and using its signals for propagating changes up and down the muxer hierarchy, use the GtkActionObserver mechanism. This cuts down on the signal emission overhead.
2020-07-19 05:17:23 +00:00
static void gtk_action_muxer_observer_iface_init (GtkActionObserverInterface *iface);
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
typedef GObjectClass GtkActionMuxerClass;
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
struct _GtkActionMuxer
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
{
GObject parent_instance;
actionmuxer: Use an array for accels We have a lot of accels across all the muxers, but the vast majority has just one or two, so an array is going to be smaller and faster for this.
2020-07-19 19:11:35 +00:00
GtkActionMuxer *parent;
GtkWidget *widget;
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
GHashTable *observed_actions;
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
GHashTable *groups;
actionmuxer: Use an array for accels We have a lot of accels across all the muxers, but the vast majority has just one or two, so an array is going to be smaller and faster for this.
2020-07-19 19:11:35 +00:00
GtkAccels primary_accels;
widget: fix class private data usage to be _init() safe Before this commit, adding GtkWidgetAction to class private data would require copying the actions to each subclass as they were built or modified. This was convenient in that it is a sort of "copy on write" semantic. However, due to the way that GTypeInstance works with base _init() functions, the "g_class" pointer in GTypeInstance is updated as each _init() function is called. That means you cannot access the subclasses class private data, but only the parent class private data. If instead we use a singly linked list of GtkWidgetAction, each subclass has their own "head" yet all subclasses share the tail of the GtkWidgetAction chain. This creates one bit of complexity though. You need a stable way to know which "bit" is the "enabled" bit of the action so we can track enabled GAction state. That is easily solved by calculating the distance to the end of the chain for a given action so that base classes sort ahead of subclasses. Since the parent class always knows its parent's actions, the position is stable. A new dynamic bitarray helper also helps us avoid allocations in all the current cases (up to 64 actions per widget) and dynamically switches to malloc if that is to ever be exceeded.
2020-03-20 16:22:29 +00:00
GtkBitmask *widget_actions_disabled;
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
};
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
G_DEFINE_TYPE_WITH_CODE (GtkActionMuxer, gtk_action_muxer, G_TYPE_OBJECT,
actionmuxer: Stop implementing GActionGroup Instead of implementing the GActionGroup interface and using its signals for propagating changes up and down the muxer hierarchy, use the GtkActionObserver mechanism. This cuts down on the signal emission overhead.
2020-07-19 05:17:23 +00:00
G_IMPLEMENT_INTERFACE (GTK_TYPE_ACTION_OBSERVER, gtk_action_muxer_observer_iface_init)
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
G_IMPLEMENT_INTERFACE (GTK_TYPE_ACTION_OBSERVABLE, gtk_action_muxer_observable_iface_init))
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
enum
{
PROP_0,
PROP_PARENT,
Give the action muxer a widget This will be used in the future to obtain widget class actions.
2019-06-15 23:08:39 +00:00
PROP_WIDGET,
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
NUM_PROPERTIES
};
static GParamSpec *properties[NUM_PROPERTIES];
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
typedef struct
{
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
GtkActionMuxer *muxer;
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
GSList *watchers;
Replace "gchar" with "char"
2020-07-24 18:40:36 +00:00
char *fullname;
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
} Action;
typedef struct
{
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
GtkActionMuxer *muxer;
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
GActionGroup *group;
Replace "gchar" with "char"
2020-07-24 18:40:36 +00:00
char *prefix;
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
gulong handler_ids[4];
} Group;
widget: fix class private data usage to be _init() safe Before this commit, adding GtkWidgetAction to class private data would require copying the actions to each subclass as they were built or modified. This was convenient in that it is a sort of "copy on write" semantic. However, due to the way that GTypeInstance works with base _init() functions, the "g_class" pointer in GTypeInstance is updated as each _init() function is called. That means you cannot access the subclasses class private data, but only the parent class private data. If instead we use a singly linked list of GtkWidgetAction, each subclass has their own "head" yet all subclasses share the tail of the GtkWidgetAction chain. This creates one bit of complexity though. You need a stable way to know which "bit" is the "enabled" bit of the action so we can track enabled GAction state. That is easily solved by calculating the distance to the end of the chain for a given action so that base classes sort ahead of subclasses. Since the parent class always knows its parent's actions, the position is stable. A new dynamic bitarray helper also helps us avoid allocations in all the current cases (up to 64 actions per widget) and dynamically switches to malloc if that is to ever be exceeded.
2020-03-20 16:22:29 +00:00
static inline guint
get_action_position (GtkWidgetAction *action)
{
guint slot;
/* We use the length of @action to the end of the chain as the slot so that
* we have stable positions for any class or it's subclasses. Doing so helps
* us avoid having mutable arrays in the class data as we will not have
* access to the ClassPrivate data during instance _init() functions.
*/
for (slot = 0; action->next != NULL; slot++, action = action->next) {}
return slot;
}
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
static void
action muxer: cosmetics
2019-06-15 22:04:19 +00:00
gtk_action_muxer_append_group_actions (const char *prefix,
Group *group,
Allow registering actions per-class Add a facility to register and install actions at class init time. The intended use for these actions is for a) context and other model-based menus b) key bindings Most of these actions are going to be stateless, so add separate apis for the simple and stateful cases. We avoid creating an action group for these by teaching the action muxer about these actions. The action muxer also maintains the enabled state for these actions.
2019-06-14 12:12:10 +00:00
GHashTable *actions)
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
{
Replace "gchar" with "char"
2020-07-24 18:40:36 +00:00
char **group_actions;
char **action;
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
group_actions = g_action_group_list_actions (group->group);
for (action = group_actions; *action; action++)
{
Allow registering actions per-class Add a facility to register and install actions at class init time. The intended use for these actions is for a) context and other model-based menus b) key bindings Most of these actions are going to be stateless, so add separate apis for the simple and stateful cases. We avoid creating an action group for these by teaching the action muxer about these actions. The action muxer also maintains the enabled state for these actions.
2019-06-14 12:12:10 +00:00
char *name = g_strconcat (prefix, ".", *action, NULL);
g_hash_table_add (actions, name);
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
}
g_strfreev (group_actions);
}
Add gtk_action_muxer_list_actions This is needed to reinstate the actions support in the inspector.
2020-07-19 05:55:13 +00:00
char **
actionmuxer: Make it possible to enumerate local actions This will be useful for exposing actions via the AT-SPI Actions interface. Update all callers.
2020-10-15 20:18:36 +00:00
gtk_action_muxer_list_actions (GtkActionMuxer *muxer,
gboolean local_only)
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
{
Allow registering actions per-class Add a facility to register and install actions at class init time. The intended use for these actions is for a) context and other model-based menus b) key bindings Most of these actions are going to be stateless, so add separate apis for the simple and stateful cases. We avoid creating an action group for these by teaching the action muxer about these actions. The action muxer also maintains the enabled state for these actions.
2019-06-14 12:12:10 +00:00
GHashTable *actions;
char **keys;
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
Add gtk_action_muxer_list_actions This is needed to reinstate the actions support in the inspector.
2020-07-19 05:55:13 +00:00
actions = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
gactionmuxer: Fix list_actions The code there before was just completely wrong https://bugzilla.gnome.org/show_bug.cgi?id=673200
2012-03-30 18:05:46 +00:00
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
for ( ; muxer != NULL; muxer = muxer->parent)
{
action muxer: cosmetics
2019-06-15 22:04:19 +00:00
GHashTableIter iter;
const char *prefix;
Group *group;
widget: fix class private data usage to be _init() safe Before this commit, adding GtkWidgetAction to class private data would require copying the actions to each subclass as they were built or modified. This was convenient in that it is a sort of "copy on write" semantic. However, due to the way that GTypeInstance works with base _init() functions, the "g_class" pointer in GTypeInstance is updated as each _init() function is called. That means you cannot access the subclasses class private data, but only the parent class private data. If instead we use a singly linked list of GtkWidgetAction, each subclass has their own "head" yet all subclasses share the tail of the GtkWidgetAction chain. This creates one bit of complexity though. You need a stable way to know which "bit" is the "enabled" bit of the action so we can track enabled GAction state. That is easily solved by calculating the distance to the end of the chain for a given action so that base classes sort ahead of subclasses. Since the parent class always knows its parent's actions, the position is stable. A new dynamic bitarray helper also helps us avoid allocations in all the current cases (up to 64 actions per widget) and dynamically switches to malloc if that is to ever be exceeded.
2020-03-20 16:22:29 +00:00
if (muxer->widget)
Allow registering actions per-class Add a facility to register and install actions at class init time. The intended use for these actions is for a) context and other model-based menus b) key bindings Most of these actions are going to be stateless, so add separate apis for the simple and stateful cases. We avoid creating an action group for these by teaching the action muxer about these actions. The action muxer also maintains the enabled state for these actions.
2019-06-14 12:12:10 +00:00
{
widget: fix class private data usage to be _init() safe Before this commit, adding GtkWidgetAction to class private data would require copying the actions to each subclass as they were built or modified. This was convenient in that it is a sort of "copy on write" semantic. However, due to the way that GTypeInstance works with base _init() functions, the "g_class" pointer in GTypeInstance is updated as each _init() function is called. That means you cannot access the subclasses class private data, but only the parent class private data. If instead we use a singly linked list of GtkWidgetAction, each subclass has their own "head" yet all subclasses share the tail of the GtkWidgetAction chain. This creates one bit of complexity though. You need a stable way to know which "bit" is the "enabled" bit of the action so we can track enabled GAction state. That is easily solved by calculating the distance to the end of the chain for a given action so that base classes sort ahead of subclasses. Since the parent class always knows its parent's actions, the position is stable. A new dynamic bitarray helper also helps us avoid allocations in all the current cases (up to 64 actions per widget) and dynamically switches to malloc if that is to ever be exceeded.
2020-03-20 16:22:29 +00:00
GtkWidgetClass *klass = GTK_WIDGET_GET_CLASS (muxer->widget);
GtkWidgetClassPrivate *priv = klass->priv;
GtkWidgetAction *action;
Allow registering actions per-class Add a facility to register and install actions at class init time. The intended use for these actions is for a) context and other model-based menus b) key bindings Most of these actions are going to be stateless, so add separate apis for the simple and stateful cases. We avoid creating an action group for these by teaching the action muxer about these actions. The action muxer also maintains the enabled state for these actions.
2019-06-14 12:12:10 +00:00
widget: fix class private data usage to be _init() safe Before this commit, adding GtkWidgetAction to class private data would require copying the actions to each subclass as they were built or modified. This was convenient in that it is a sort of "copy on write" semantic. However, due to the way that GTypeInstance works with base _init() functions, the "g_class" pointer in GTypeInstance is updated as each _init() function is called. That means you cannot access the subclasses class private data, but only the parent class private data. If instead we use a singly linked list of GtkWidgetAction, each subclass has their own "head" yet all subclasses share the tail of the GtkWidgetAction chain. This creates one bit of complexity though. You need a stable way to know which "bit" is the "enabled" bit of the action so we can track enabled GAction state. That is easily solved by calculating the distance to the end of the chain for a given action so that base classes sort ahead of subclasses. Since the parent class always knows its parent's actions, the position is stable. A new dynamic bitarray helper also helps us avoid allocations in all the current cases (up to 64 actions per widget) and dynamically switches to malloc if that is to ever be exceeded.
2020-03-20 16:22:29 +00:00
for (action = priv->actions; action; action = action->next)
g_hash_table_add (actions, g_strdup (action->name));
Allow registering actions per-class Add a facility to register and install actions at class init time. The intended use for these actions is for a) context and other model-based menus b) key bindings Most of these actions are going to be stateless, so add separate apis for the simple and stateful cases. We avoid creating an action group for these by teaching the action muxer about these actions. The action muxer also maintains the enabled state for these actions.
2019-06-14 12:12:10 +00:00
}
actionmuxer: Create observed_actions and groups on demand The vast majority of action muxers don't have observers or groups, so we can avoid the overhead of carrying all these empty hash tables.
2020-07-19 13:45:12 +00:00
if (muxer->groups)
{
g_hash_table_iter_init (&iter, muxer->groups);
while (g_hash_table_iter_next (&iter, (gpointer *)&prefix, (gpointer *)&group))
gtk_action_muxer_append_group_actions (prefix, group, actions);
}
actionmuxer: Make it possible to enumerate local actions This will be useful for exposing actions via the AT-SPI Actions interface. Update all callers.
2020-10-15 20:18:36 +00:00
if (local_only)
break;
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
}
gactionmuxer: Fix list_actions The code there before was just completely wrong https://bugzilla.gnome.org/show_bug.cgi?id=673200
2012-03-30 18:05:46 +00:00
Allow registering actions per-class Add a facility to register and install actions at class init time. The intended use for these actions is for a) context and other model-based menus b) key bindings Most of these actions are going to be stateless, so add separate apis for the simple and stateful cases. We avoid creating an action group for these by teaching the action muxer about these actions. The action muxer also maintains the enabled state for these actions.
2019-06-14 12:12:10 +00:00
keys = (char **)g_hash_table_get_keys_as_array (actions, NULL);
g_hash_table_steal_all (actions);
g_hash_table_unref (actions);
return (char **)keys;
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
}
static Group *
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
gtk_action_muxer_find_group (GtkActionMuxer *muxer,
Replace "gchar" with "char"
2020-07-24 18:40:36 +00:00
const char *full_name,
const char **action_name)
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
{
Replace "gchar" with "char"
2020-07-24 18:40:36 +00:00
const char *dot;
char *prefix;
action muxer: Change inheritance Previously, we would not look any further for an action once we found a match for the prefix, defining inheritance by groups. Change this to inheritance for individual actions, since we are moving towards individual actions as the main ingredient in GTKs action support.
2019-06-22 22:51:23 +00:00
const char *name;
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
Group *group;
actionmuxer: Create observed_actions and groups on demand The vast majority of action muxers don't have observers or groups, so we can avoid the overhead of carrying all these empty hash tables.
2020-07-19 13:45:12 +00:00
if (!muxer->groups)
return NULL;
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
dot = strchr (full_name, '.');
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
if (!dot)
return NULL;
action muxer: Change inheritance Previously, we would not look any further for an action once we found a match for the prefix, defining inheritance by groups. Change this to inheritance for individual actions, since we are moving towards individual actions as the main ingredient in GTKs action support.
2019-06-22 22:51:23 +00:00
name = dot + 1;
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
prefix = g_strndup (full_name, dot - full_name);
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
group = g_hash_table_lookup (muxer->groups, prefix);
g_free (prefix);
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
if (action_name)
action muxer: Change inheritance Previously, we would not look any further for an action once we found a match for the prefix, defining inheritance by groups. Change this to inheritance for individual actions, since we are moving towards individual actions as the main ingredient in GTKs action support.
2019-06-22 22:51:23 +00:00
*action_name = name;
if (group &&
g_action_group_has_action (group->group, name))
return group;
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
action muxer: Change inheritance Previously, we would not look any further for an action once we found a match for the prefix, defining inheritance by groups. Change this to inheritance for individual actions, since we are moving towards individual actions as the main ingredient in GTKs action support.
2019-06-22 22:51:23 +00:00
return NULL;
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
}
action muxer: Add some convenience api Instead of duplicating this code in multiple places, add an api to look up an action group for a prefixed name, and return the unprefixed name at the same time.
2019-06-14 17:41:45 +00:00
GActionGroup *
gtk_action_muxer_find (GtkActionMuxer *muxer,
const char *action_name,
const char **unprefixed_name)
{
Group *group;
group = gtk_action_muxer_find_group (muxer, action_name, unprefixed_name);
action muxer: Change inheritance Previously, we would not look any further for an action once we found a match for the prefix, defining inheritance by groups. Change this to inheritance for individual actions, since we are moving towards individual actions as the main ingredient in GTKs action support.
2019-06-22 22:51:23 +00:00
if (group)
return group->group;
action muxer: Add some convenience api Instead of duplicating this code in multiple places, add an api to look up an action group for a prefixed name, and return the unprefixed name at the same time.
2019-06-14 17:41:45 +00:00
action muxer: Change inheritance Previously, we would not look any further for an action once we found a match for the prefix, defining inheritance by groups. Change this to inheritance for individual actions, since we are moving towards individual actions as the main ingredient in GTKs action support.
2019-06-22 22:51:23 +00:00
return NULL;
action muxer: Add some convenience api Instead of duplicating this code in multiple places, add an api to look up an action group for a prefixed name, and return the unprefixed name at the same time.
2019-06-14 17:41:45 +00:00
}
muxer: add helper to get group by name This is useful when you need to read a group back out of the muxer.
2020-12-03 03:41:16 +00:00
GActionGroup *
gtk_action_muxer_get_group (GtkActionMuxer *muxer,
const char *group_name)
{
Group *group;
group = g_hash_table_lookup (muxer->groups, group_name);
if (group)
return group->group;
return NULL;
}
actionmuxer: Create observed_actions and groups on demand The vast majority of action muxers don't have observers or groups, so we can avoid the overhead of carrying all these empty hash tables.
2020-07-19 13:45:12 +00:00
static inline Action *
find_observers (GtkActionMuxer *muxer,
const char *action_name)
{
if (muxer->observed_actions)
return g_hash_table_lookup (muxer->observed_actions, action_name);
return NULL;
}
Allow registering actions per-class Add a facility to register and install actions at class init time. The intended use for these actions is for a) context and other model-based menus b) key bindings Most of these actions are going to be stateless, so add separate apis for the simple and stateful cases. We avoid creating an action group for these by teaching the action muxer about these actions. The action muxer also maintains the enabled state for these actions.
2019-06-14 12:12:10 +00:00
void
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
gtk_action_muxer_action_enabled_changed (GtkActionMuxer *muxer,
Replace "gchar" with "char"
2020-07-24 18:40:36 +00:00
const char *action_name,
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
gboolean enabled)
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
{
widget: fix class private data usage to be _init() safe Before this commit, adding GtkWidgetAction to class private data would require copying the actions to each subclass as they were built or modified. This was convenient in that it is a sort of "copy on write" semantic. However, due to the way that GTypeInstance works with base _init() functions, the "g_class" pointer in GTypeInstance is updated as each _init() function is called. That means you cannot access the subclasses class private data, but only the parent class private data. If instead we use a singly linked list of GtkWidgetAction, each subclass has their own "head" yet all subclasses share the tail of the GtkWidgetAction chain. This creates one bit of complexity though. You need a stable way to know which "bit" is the "enabled" bit of the action so we can track enabled GAction state. That is easily solved by calculating the distance to the end of the chain for a given action so that base classes sort ahead of subclasses. Since the parent class always knows its parent's actions, the position is stable. A new dynamic bitarray helper also helps us avoid allocations in all the current cases (up to 64 actions per widget) and dynamically switches to malloc if that is to ever be exceeded.
2020-03-20 16:22:29 +00:00
GtkWidgetAction *iter;
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
Action *action;
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
GSList *node;
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
widget: fix class private data usage to be _init() safe Before this commit, adding GtkWidgetAction to class private data would require copying the actions to each subclass as they were built or modified. This was convenient in that it is a sort of "copy on write" semantic. However, due to the way that GTypeInstance works with base _init() functions, the "g_class" pointer in GTypeInstance is updated as each _init() function is called. That means you cannot access the subclasses class private data, but only the parent class private data. If instead we use a singly linked list of GtkWidgetAction, each subclass has their own "head" yet all subclasses share the tail of the GtkWidgetAction chain. This creates one bit of complexity though. You need a stable way to know which "bit" is the "enabled" bit of the action so we can track enabled GAction state. That is easily solved by calculating the distance to the end of the chain for a given action so that base classes sort ahead of subclasses. Since the parent class always knows its parent's actions, the position is stable. A new dynamic bitarray helper also helps us avoid allocations in all the current cases (up to 64 actions per widget) and dynamically switches to malloc if that is to ever be exceeded.
2020-03-20 16:22:29 +00:00
if (muxer->widget)
Allow registering actions per-class Add a facility to register and install actions at class init time. The intended use for these actions is for a) context and other model-based menus b) key bindings Most of these actions are going to be stateless, so add separate apis for the simple and stateful cases. We avoid creating an action group for these by teaching the action muxer about these actions. The action muxer also maintains the enabled state for these actions.
2019-06-14 12:12:10 +00:00
{
widget: fix class private data usage to be _init() safe Before this commit, adding GtkWidgetAction to class private data would require copying the actions to each subclass as they were built or modified. This was convenient in that it is a sort of "copy on write" semantic. However, due to the way that GTypeInstance works with base _init() functions, the "g_class" pointer in GTypeInstance is updated as each _init() function is called. That means you cannot access the subclasses class private data, but only the parent class private data. If instead we use a singly linked list of GtkWidgetAction, each subclass has their own "head" yet all subclasses share the tail of the GtkWidgetAction chain. This creates one bit of complexity though. You need a stable way to know which "bit" is the "enabled" bit of the action so we can track enabled GAction state. That is easily solved by calculating the distance to the end of the chain for a given action so that base classes sort ahead of subclasses. Since the parent class always knows its parent's actions, the position is stable. A new dynamic bitarray helper also helps us avoid allocations in all the current cases (up to 64 actions per widget) and dynamically switches to malloc if that is to ever be exceeded.
2020-03-20 16:22:29 +00:00
GtkWidgetClass *klass = GTK_WIDGET_GET_CLASS (muxer->widget);
GtkWidgetClassPrivate *priv = klass->priv;
for (iter = priv->actions; iter; iter = iter->next)
Allow registering actions per-class Add a facility to register and install actions at class init time. The intended use for these actions is for a) context and other model-based menus b) key bindings Most of these actions are going to be stateless, so add separate apis for the simple and stateful cases. We avoid creating an action group for these by teaching the action muxer about these actions. The action muxer also maintains the enabled state for these actions.
2019-06-14 12:12:10 +00:00
{
widget: fix class private data usage to be _init() safe Before this commit, adding GtkWidgetAction to class private data would require copying the actions to each subclass as they were built or modified. This was convenient in that it is a sort of "copy on write" semantic. However, due to the way that GTypeInstance works with base _init() functions, the "g_class" pointer in GTypeInstance is updated as each _init() function is called. That means you cannot access the subclasses class private data, but only the parent class private data. If instead we use a singly linked list of GtkWidgetAction, each subclass has their own "head" yet all subclasses share the tail of the GtkWidgetAction chain. This creates one bit of complexity though. You need a stable way to know which "bit" is the "enabled" bit of the action so we can track enabled GAction state. That is easily solved by calculating the distance to the end of the chain for a given action so that base classes sort ahead of subclasses. Since the parent class always knows its parent's actions, the position is stable. A new dynamic bitarray helper also helps us avoid allocations in all the current cases (up to 64 actions per widget) and dynamically switches to malloc if that is to ever be exceeded.
2020-03-20 16:22:29 +00:00
if (strcmp (action_name, iter->name) == 0)
Allow registering actions per-class Add a facility to register and install actions at class init time. The intended use for these actions is for a) context and other model-based menus b) key bindings Most of these actions are going to be stateless, so add separate apis for the simple and stateful cases. We avoid creating an action group for these by teaching the action muxer about these actions. The action muxer also maintains the enabled state for these actions.
2019-06-14 12:12:10 +00:00
{
widget: fix class private data usage to be _init() safe Before this commit, adding GtkWidgetAction to class private data would require copying the actions to each subclass as they were built or modified. This was convenient in that it is a sort of "copy on write" semantic. However, due to the way that GTypeInstance works with base _init() functions, the "g_class" pointer in GTypeInstance is updated as each _init() function is called. That means you cannot access the subclasses class private data, but only the parent class private data. If instead we use a singly linked list of GtkWidgetAction, each subclass has their own "head" yet all subclasses share the tail of the GtkWidgetAction chain. This creates one bit of complexity though. You need a stable way to know which "bit" is the "enabled" bit of the action so we can track enabled GAction state. That is easily solved by calculating the distance to the end of the chain for a given action so that base classes sort ahead of subclasses. Since the parent class always knows its parent's actions, the position is stable. A new dynamic bitarray helper also helps us avoid allocations in all the current cases (up to 64 actions per widget) and dynamically switches to malloc if that is to ever be exceeded.
2020-03-20 16:22:29 +00:00
guint position = get_action_position (iter);
muxer->widget_actions_disabled =
_gtk_bitmask_set (muxer->widget_actions_disabled, position, !enabled);
Allow registering actions per-class Add a facility to register and install actions at class init time. The intended use for these actions is for a) context and other model-based menus b) key bindings Most of these actions are going to be stateless, so add separate apis for the simple and stateful cases. We avoid creating an action group for these by teaching the action muxer about these actions. The action muxer also maintains the enabled state for these actions.
2019-06-14 12:12:10 +00:00
break;
}
}
}
widget: fix class private data usage to be _init() safe Before this commit, adding GtkWidgetAction to class private data would require copying the actions to each subclass as they were built or modified. This was convenient in that it is a sort of "copy on write" semantic. However, due to the way that GTypeInstance works with base _init() functions, the "g_class" pointer in GTypeInstance is updated as each _init() function is called. That means you cannot access the subclasses class private data, but only the parent class private data. If instead we use a singly linked list of GtkWidgetAction, each subclass has their own "head" yet all subclasses share the tail of the GtkWidgetAction chain. This creates one bit of complexity though. You need a stable way to know which "bit" is the "enabled" bit of the action so we can track enabled GAction state. That is easily solved by calculating the distance to the end of the chain for a given action so that base classes sort ahead of subclasses. Since the parent class always knows its parent's actions, the position is stable. A new dynamic bitarray helper also helps us avoid allocations in all the current cases (up to 64 actions per widget) and dynamically switches to malloc if that is to ever be exceeded.
2020-03-20 16:22:29 +00:00
actionmuxer: Create observed_actions and groups on demand The vast majority of action muxers don't have observers or groups, so we can avoid the overhead of carrying all these empty hash tables.
2020-07-19 13:45:12 +00:00
action = find_observers (muxer, action_name);
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
for (node = action ? action->watchers : NULL; node; node = node->next)
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
gtk_action_observer_action_enabled_changed (node->data, GTK_ACTION_OBSERVABLE (muxer), action_name, enabled);
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
}
static void
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
gtk_action_muxer_group_action_enabled_changed (GActionGroup *action_group,
Replace "gchar" with "char"
2020-07-24 18:40:36 +00:00
const char *action_name,
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
gboolean enabled,
gpointer user_data)
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
{
Group *group = user_data;
Replace "gchar" with "char"
2020-07-24 18:40:36 +00:00
char *fullname;
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
fullname = g_strconcat (group->prefix, ".", action_name, NULL);
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
gtk_action_muxer_action_enabled_changed (group->muxer, fullname, enabled);
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
g_free (fullname);
}
Allow registering actions per-class Add a facility to register and install actions at class init time. The intended use for these actions is for a) context and other model-based menus b) key bindings Most of these actions are going to be stateless, so add separate apis for the simple and stateful cases. We avoid creating an action group for these by teaching the action muxer about these actions. The action muxer also maintains the enabled state for these actions.
2019-06-14 12:12:10 +00:00
void
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
gtk_action_muxer_action_state_changed (GtkActionMuxer *muxer,
Replace "gchar" with "char"
2020-07-24 18:40:36 +00:00
const char *action_name,
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
GVariant *state)
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
{
Action *action;
GSList *node;
actionmuxer: Create observed_actions and groups on demand The vast majority of action muxers don't have observers or groups, so we can avoid the overhead of carrying all these empty hash tables.
2020-07-19 13:45:12 +00:00
action = find_observers (muxer, action_name);
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
for (node = action ? action->watchers : NULL; node; node = node->next)
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
gtk_action_observer_action_state_changed (node->data, GTK_ACTION_OBSERVABLE (muxer), action_name, state);
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
}
static void
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
gtk_action_muxer_group_action_state_changed (GActionGroup *action_group,
Replace "gchar" with "char"
2020-07-24 18:40:36 +00:00
const char *action_name,
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
GVariant *state,
gpointer user_data)
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
{
Group *group = user_data;
Replace "gchar" with "char"
2020-07-24 18:40:36 +00:00
char *fullname;
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
fullname = g_strconcat (group->prefix, ".", action_name, NULL);
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
gtk_action_muxer_action_state_changed (group->muxer, fullname, state);
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
g_free (fullname);
}
actionmuxer: Stop implementing GActionGroup Instead of implementing the GActionGroup interface and using its signals for propagating changes up and down the muxer hierarchy, use the GtkActionObserver mechanism. This cuts down on the signal emission overhead.
2020-07-19 05:17:23 +00:00
static gboolean action_muxer_query_action (GtkActionMuxer *muxer,
const char *action_name,
gboolean *enabled,
const GVariantType **parameter_type,
const GVariantType **state_type,
GVariant **state_hint,
GVariant **state,
gboolean recurse);
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
Speed up action muxer setup We don't need to duplicate all these action names and emit all these signals if nobody is listening.
2020-04-24 04:52:17 +00:00
static void
notify_observers_added (GtkActionMuxer *muxer,
GtkActionMuxer *parent)
{
GHashTableIter iter;
const char *action_name;
Action *action;
actionmuxer: Create observed_actions and groups on demand The vast majority of action muxers don't have observers or groups, so we can avoid the overhead of carrying all these empty hash tables.
2020-07-19 13:45:12 +00:00
if (!muxer->observed_actions)
return;
Speed up action muxer setup We don't need to duplicate all these action names and emit all these signals if nobody is listening.
2020-04-24 04:52:17 +00:00
g_hash_table_iter_init (&iter, muxer->observed_actions);
while (g_hash_table_iter_next (&iter, (gpointer *)&action_name, (gpointer *)&action))
{
const GVariantType *parameter_type;
gboolean enabled;
GVariant *state;
GSList *node;
if (!action->watchers)
continue;
action muxer: Propagate accel changes When we set a new parent on an action muxer, accels may change, so call primary_accel_changed for involved actions.
2021-06-17 12:35:59 +00:00
for (node = action ? action->watchers : NULL; node; node = node->next)
gtk_action_observer_primary_accel_changed (node->data, GTK_ACTION_OBSERVABLE (muxer),
action_name, NULL);
actionmuxer: Stop implementing GActionGroup Instead of implementing the GActionGroup interface and using its signals for propagating changes up and down the muxer hierarchy, use the GtkActionObserver mechanism. This cuts down on the signal emission overhead.
2020-07-19 05:17:23 +00:00
gtk_action_observable_register_observer (GTK_ACTION_OBSERVABLE (parent), action_name, GTK_ACTION_OBSERVER (muxer));
if (!action_muxer_query_action (parent, action_name,
&enabled, &parameter_type,
NULL, NULL, &state,
TRUE))
Speed up action muxer setup We don't need to duplicate all these action names and emit all these signals if nobody is listening.
2020-04-24 04:52:17 +00:00
continue;
for (node = action->watchers; node; node = node->next)
actionmuxer: Add some more api We want to drop the GActionGroup interface from GtkActionMuxer, so add the necessary api directly to GtkActionMuxer itself.
2020-07-19 02:28:53 +00:00
{
gtk_action_observer_action_added (node->data,
GTK_ACTION_OBSERVABLE (muxer),
action_name, parameter_type, enabled, state);
}
Speed up action muxer setup We don't need to duplicate all these action names and emit all these signals if nobody is listening.
2020-04-24 04:52:17 +00:00
if (state)
g_variant_unref (state);
}
}
static void
notify_observers_removed (GtkActionMuxer *muxer,
GtkActionMuxer *parent)
{
GHashTableIter iter;
const char *action_name;
Action *action;
actionmuxer: Create observed_actions and groups on demand The vast majority of action muxers don't have observers or groups, so we can avoid the overhead of carrying all these empty hash tables.
2020-07-19 13:45:12 +00:00
if (!muxer->observed_actions)
return;
Speed up action muxer setup We don't need to duplicate all these action names and emit all these signals if nobody is listening.
2020-04-24 04:52:17 +00:00
g_hash_table_iter_init (&iter, muxer->observed_actions);
Speed up action muxer setup more Don't emit signals for group insertion/removal if nobody is listening.
2020-04-24 05:11:13 +00:00
while (g_hash_table_iter_next (&iter, (gpointer *)&action_name, (gpointer *)&action))
Speed up action muxer setup We don't need to duplicate all these action names and emit all these signals if nobody is listening.
2020-04-24 04:52:17 +00:00
{
GSList *node;
actionmuxer: Stop implementing GActionGroup Instead of implementing the GActionGroup interface and using its signals for propagating changes up and down the muxer hierarchy, use the GtkActionObserver mechanism. This cuts down on the signal emission overhead.
2020-07-19 05:17:23 +00:00
gtk_action_observable_unregister_observer (GTK_ACTION_OBSERVABLE (parent), action_name, GTK_ACTION_OBSERVER (muxer));
Speed up action muxer setup We don't need to duplicate all these action names and emit all these signals if nobody is listening.
2020-04-24 04:52:17 +00:00
for (node = action->watchers; node; node = node->next)
actionmuxer: Add some more api We want to drop the GActionGroup interface from GtkActionMuxer, so add the necessary api directly to GtkActionMuxer itself.
2020-07-19 02:28:53 +00:00
{
gtk_action_observer_action_removed (node->data,
GTK_ACTION_OBSERVABLE (muxer),
action_name);
}
Speed up action muxer setup We don't need to duplicate all these action names and emit all these signals if nobody is listening.
2020-04-24 04:52:17 +00:00
}
}
static void
actionmuxer: Stop implementing GActionGroup Instead of implementing the GActionGroup interface and using its signals for propagating changes up and down the muxer hierarchy, use the GtkActionObserver mechanism. This cuts down on the signal emission overhead.
2020-07-19 05:17:23 +00:00
gtk_action_muxer_action_added (GtkActionMuxer *muxer,
const char *action_name,
const GVariantType *parameter_type,
gboolean enabled,
GVariant *state)
Speed up action muxer setup We don't need to duplicate all these action names and emit all these signals if nobody is listening.
2020-04-24 04:52:17 +00:00
{
actionmuxer: Stop implementing GActionGroup Instead of implementing the GActionGroup interface and using its signals for propagating changes up and down the muxer hierarchy, use the GtkActionObserver mechanism. This cuts down on the signal emission overhead.
2020-07-19 05:17:23 +00:00
Action *action;
GSList *node;
Speed up action muxer setup We don't need to duplicate all these action names and emit all these signals if nobody is listening.
2020-04-24 04:52:17 +00:00
actionmuxer: Create observed_actions and groups on demand The vast majority of action muxers don't have observers or groups, so we can avoid the overhead of carrying all these empty hash tables.
2020-07-19 13:45:12 +00:00
action = find_observers (muxer, action_name);
actionmuxer: Stop implementing GActionGroup Instead of implementing the GActionGroup interface and using its signals for propagating changes up and down the muxer hierarchy, use the GtkActionObserver mechanism. This cuts down on the signal emission overhead.
2020-07-19 05:17:23 +00:00
for (node = action ? action->watchers : NULL; node; node = node->next)
gtk_action_observer_action_added (node->data,
GTK_ACTION_OBSERVABLE (muxer),
action_name, parameter_type, enabled, state);
Speed up action muxer setup We don't need to duplicate all these action names and emit all these signals if nobody is listening.
2020-04-24 04:52:17 +00:00
}
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
static void
actionmuxer: Stop implementing GActionGroup Instead of implementing the GActionGroup interface and using its signals for propagating changes up and down the muxer hierarchy, use the GtkActionObserver mechanism. This cuts down on the signal emission overhead.
2020-07-19 05:17:23 +00:00
gtk_action_muxer_action_added_to_group (GActionGroup *action_group,
Replace "gchar" with "char"
2020-07-24 18:40:36 +00:00
const char *action_name,
actionmuxer: Stop implementing GActionGroup Instead of implementing the GActionGroup interface and using its signals for propagating changes up and down the muxer hierarchy, use the GtkActionObserver mechanism. This cuts down on the signal emission overhead.
2020-07-19 05:17:23 +00:00
gpointer user_data)
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
{
actionmuxer: Stop implementing GActionGroup Instead of implementing the GActionGroup interface and using its signals for propagating changes up and down the muxer hierarchy, use the GtkActionObserver mechanism. This cuts down on the signal emission overhead.
2020-07-19 05:17:23 +00:00
Group *group = user_data;
GtkActionMuxer *muxer = group->muxer;
Action *action;
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
const GVariantType *parameter_type;
gboolean enabled;
GVariant *state;
actionmuxer: Stop implementing GActionGroup Instead of implementing the GActionGroup interface and using its signals for propagating changes up and down the muxer hierarchy, use the GtkActionObserver mechanism. This cuts down on the signal emission overhead.
2020-07-19 05:17:23 +00:00
char *fullname;
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
actionmuxer: Stop implementing GActionGroup Instead of implementing the GActionGroup interface and using its signals for propagating changes up and down the muxer hierarchy, use the GtkActionObserver mechanism. This cuts down on the signal emission overhead.
2020-07-19 05:17:23 +00:00
fullname = g_strconcat (group->prefix, ".", action_name, NULL);
actionmuxer: Create observed_actions and groups on demand The vast majority of action muxers don't have observers or groups, so we can avoid the overhead of carrying all these empty hash tables.
2020-07-19 13:45:12 +00:00
if (muxer->parent)
gtk_action_observable_unregister_observer (GTK_ACTION_OBSERVABLE (muxer->parent),
fullname,
GTK_ACTION_OBSERVER (muxer));
action = find_observers (muxer, fullname);
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
if (action && action->watchers &&
actionmuxer: Stop implementing GActionGroup Instead of implementing the GActionGroup interface and using its signals for propagating changes up and down the muxer hierarchy, use the GtkActionObserver mechanism. This cuts down on the signal emission overhead.
2020-07-19 05:17:23 +00:00
g_action_group_query_action (action_group, action_name,
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
&enabled, &parameter_type, NULL, NULL, &state))
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
{
actionmuxer: Stop implementing GActionGroup Instead of implementing the GActionGroup interface and using its signals for propagating changes up and down the muxer hierarchy, use the GtkActionObserver mechanism. This cuts down on the signal emission overhead.
2020-07-19 05:17:23 +00:00
gtk_action_muxer_action_added (muxer, fullname, parameter_type, enabled, state);
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
if (state)
g_variant_unref (state);
}
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
actionmuxer: Stop implementing GActionGroup Instead of implementing the GActionGroup interface and using its signals for propagating changes up and down the muxer hierarchy, use the GtkActionObserver mechanism. This cuts down on the signal emission overhead.
2020-07-19 05:17:23 +00:00
g_free (fullname);
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
}
static void
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
gtk_action_muxer_action_removed (GtkActionMuxer *muxer,
actionmuxer: Stop implementing GActionGroup Instead of implementing the GActionGroup interface and using its signals for propagating changes up and down the muxer hierarchy, use the GtkActionObserver mechanism. This cuts down on the signal emission overhead.
2020-07-19 05:17:23 +00:00
const char *action_name)
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
{
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
Action *action;
GSList *node;
actionmuxer: Create observed_actions and groups on demand The vast majority of action muxers don't have observers or groups, so we can avoid the overhead of carrying all these empty hash tables.
2020-07-19 13:45:12 +00:00
action = find_observers (muxer, action_name);
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
for (node = action ? action->watchers : NULL; node; node = node->next)
actionmuxer: Stop implementing GActionGroup Instead of implementing the GActionGroup interface and using its signals for propagating changes up and down the muxer hierarchy, use the GtkActionObserver mechanism. This cuts down on the signal emission overhead.
2020-07-19 05:17:23 +00:00
gtk_action_observer_action_removed (node->data, GTK_ACTION_OBSERVABLE (muxer), action_name);
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
}
static void
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
gtk_action_muxer_action_removed_from_group (GActionGroup *action_group,
Replace "gchar" with "char"
2020-07-24 18:40:36 +00:00
const char *action_name,
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
gpointer user_data)
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
{
Group *group = user_data;
actionmuxer: Stop implementing GActionGroup Instead of implementing the GActionGroup interface and using its signals for propagating changes up and down the muxer hierarchy, use the GtkActionObserver mechanism. This cuts down on the signal emission overhead.
2020-07-19 05:17:23 +00:00
GtkActionMuxer *muxer = group->muxer;
char *fullname;
Action *action;
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
actionmuxer: Stop implementing GActionGroup Instead of implementing the GActionGroup interface and using its signals for propagating changes up and down the muxer hierarchy, use the GtkActionObserver mechanism. This cuts down on the signal emission overhead.
2020-07-19 05:17:23 +00:00
fullname = g_strconcat (group->prefix, ".", action_name, NULL);
gtk_action_muxer_action_removed (muxer, fullname);
g_free (fullname);
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
actionmuxer: Create observed_actions and groups on demand The vast majority of action muxers don't have observers or groups, so we can avoid the overhead of carrying all these empty hash tables.
2020-07-19 13:45:12 +00:00
action = find_observers (muxer, action_name);
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
actionmuxer: Stop implementing GActionGroup Instead of implementing the GActionGroup interface and using its signals for propagating changes up and down the muxer hierarchy, use the GtkActionObserver mechanism. This cuts down on the signal emission overhead.
2020-07-19 05:17:23 +00:00
if (action && action->watchers &&
!action_muxer_query_action (muxer, action_name,
NULL, NULL, NULL, NULL, NULL, FALSE))
{
if (muxer->parent)
gtk_action_observable_register_observer (GTK_ACTION_OBSERVABLE (muxer->parent),
action_name,
GTK_ACTION_OBSERVER (muxer));
}
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
}
GtkActionMuxer: store primary accels Reuse the existing infrastructure in GtkActionMuxer for propagation of accelerator information: in particular, what accel label ought to appear on menu items for a particular action and target. This is a good idea because we want accels to travel along with the actions that they're tied to and reusing GtkActionMuxer will allow us to do that without creating another hierarchy of a different class for the sole purpose of filling in accel labels on menu items. Doing it this ways also allows those who copy/paste GtkActionMuxer to insert the accels for themselves. Add a new method on the GtkActionObserver interface to report changes. This patch introduces a new concept: "action and target" notation for actions. This format looks like so: "'target'|app.action" or for non-targeted actions: "|app.action" and it is used over a number of possible alternative formats for some good reasons: - it's very easy to get a nul-terminated action name out of this format when we need it, by using strrchr('|') + 1 - we can also get the target out of it using g_variant_parse() because this function takes a pointer to a 'limit' character that is not parsed past: we use the '|' for this - it's extremely easy to hash on this format (just use a normal string hash) vs. attempting to hash on a string plus a GVariant A close contender was to use detailed action strings here, but these are not used for two reasons: - it's not possible to easily get the action name or target out of the strings without more work than the "action and target" format requires - we still intend to use detailed action strings on API (since they are a lot nicer to look at) but detailed action strings can be given in non-canonical forms (eg: 'foo::bar' and 'foo("bar")' are equivalent) so we'd have to go through a normalisation step anyway. Since we're doing that already, we may as well convert to a more convenient internal format. This new "action and target" format is going to start appearing in a lot more places as action descriptions are introduced. I suspect that nobody is using '|' in their action names, but in case I am proven wrong, we can always switch to using something more exotic as a separator character (such as '\x01' or '\xff' or the like).
2013-07-10 02:37:17 +00:00
static void
gtk_action_muxer_primary_accel_changed (GtkActionMuxer *muxer,
Replace "gchar" with "char"
2020-07-24 18:40:36 +00:00
const char *action_name,
const char *action_and_target)
GtkActionMuxer: store primary accels Reuse the existing infrastructure in GtkActionMuxer for propagation of accelerator information: in particular, what accel label ought to appear on menu items for a particular action and target. This is a good idea because we want accels to travel along with the actions that they're tied to and reusing GtkActionMuxer will allow us to do that without creating another hierarchy of a different class for the sole purpose of filling in accel labels on menu items. Doing it this ways also allows those who copy/paste GtkActionMuxer to insert the accels for themselves. Add a new method on the GtkActionObserver interface to report changes. This patch introduces a new concept: "action and target" notation for actions. This format looks like so: "'target'|app.action" or for non-targeted actions: "|app.action" and it is used over a number of possible alternative formats for some good reasons: - it's very easy to get a nul-terminated action name out of this format when we need it, by using strrchr('|') + 1 - we can also get the target out of it using g_variant_parse() because this function takes a pointer to a 'limit' character that is not parsed past: we use the '|' for this - it's extremely easy to hash on this format (just use a normal string hash) vs. attempting to hash on a string plus a GVariant A close contender was to use detailed action strings here, but these are not used for two reasons: - it's not possible to easily get the action name or target out of the strings without more work than the "action and target" format requires - we still intend to use detailed action strings on API (since they are a lot nicer to look at) but detailed action strings can be given in non-canonical forms (eg: 'foo::bar' and 'foo("bar")' are equivalent) so we'd have to go through a normalisation step anyway. Since we're doing that already, we may as well convert to a more convenient internal format. This new "action and target" format is going to start appearing in a lot more places as action descriptions are introduced. I suspect that nobody is using '|' in their action names, but in case I am proven wrong, we can always switch to using something more exotic as a separator character (such as '\x01' or '\xff' or the like).
2013-07-10 02:37:17 +00:00
{
Action *action;
GSList *node;
if (!action_name)
action_name = strrchr (action_and_target, '|') + 1;
actionmuxer: Create observed_actions and groups on demand The vast majority of action muxers don't have observers or groups, so we can avoid the overhead of carrying all these empty hash tables.
2020-07-19 13:45:12 +00:00
action = find_observers (muxer, action_name);
GtkActionMuxer: store primary accels Reuse the existing infrastructure in GtkActionMuxer for propagation of accelerator information: in particular, what accel label ought to appear on menu items for a particular action and target. This is a good idea because we want accels to travel along with the actions that they're tied to and reusing GtkActionMuxer will allow us to do that without creating another hierarchy of a different class for the sole purpose of filling in accel labels on menu items. Doing it this ways also allows those who copy/paste GtkActionMuxer to insert the accels for themselves. Add a new method on the GtkActionObserver interface to report changes. This patch introduces a new concept: "action and target" notation for actions. This format looks like so: "'target'|app.action" or for non-targeted actions: "|app.action" and it is used over a number of possible alternative formats for some good reasons: - it's very easy to get a nul-terminated action name out of this format when we need it, by using strrchr('|') + 1 - we can also get the target out of it using g_variant_parse() because this function takes a pointer to a 'limit' character that is not parsed past: we use the '|' for this - it's extremely easy to hash on this format (just use a normal string hash) vs. attempting to hash on a string plus a GVariant A close contender was to use detailed action strings here, but these are not used for two reasons: - it's not possible to easily get the action name or target out of the strings without more work than the "action and target" format requires - we still intend to use detailed action strings on API (since they are a lot nicer to look at) but detailed action strings can be given in non-canonical forms (eg: 'foo::bar' and 'foo("bar")' are equivalent) so we'd have to go through a normalisation step anyway. Since we're doing that already, we may as well convert to a more convenient internal format. This new "action and target" format is going to start appearing in a lot more places as action descriptions are introduced. I suspect that nobody is using '|' in their action names, but in case I am proven wrong, we can always switch to using something more exotic as a separator character (such as '\x01' or '\xff' or the like).
2013-07-10 02:37:17 +00:00
for (node = action ? action->watchers : NULL; node; node = node->next)
actionmuxer: Stop implementing GActionGroup Instead of implementing the GActionGroup interface and using its signals for propagating changes up and down the muxer hierarchy, use the GtkActionObserver mechanism. This cuts down on the signal emission overhead.
2020-07-19 05:17:23 +00:00
gtk_action_observer_primary_accel_changed (node->data, GTK_ACTION_OBSERVABLE (muxer),
action_name, action_and_target);
GtkActionMuxer: store primary accels Reuse the existing infrastructure in GtkActionMuxer for propagation of accelerator information: in particular, what accel label ought to appear on menu items for a particular action and target. This is a good idea because we want accels to travel along with the actions that they're tied to and reusing GtkActionMuxer will allow us to do that without creating another hierarchy of a different class for the sole purpose of filling in accel labels on menu items. Doing it this ways also allows those who copy/paste GtkActionMuxer to insert the accels for themselves. Add a new method on the GtkActionObserver interface to report changes. This patch introduces a new concept: "action and target" notation for actions. This format looks like so: "'target'|app.action" or for non-targeted actions: "|app.action" and it is used over a number of possible alternative formats for some good reasons: - it's very easy to get a nul-terminated action name out of this format when we need it, by using strrchr('|') + 1 - we can also get the target out of it using g_variant_parse() because this function takes a pointer to a 'limit' character that is not parsed past: we use the '|' for this - it's extremely easy to hash on this format (just use a normal string hash) vs. attempting to hash on a string plus a GVariant A close contender was to use detailed action strings here, but these are not used for two reasons: - it's not possible to easily get the action name or target out of the strings without more work than the "action and target" format requires - we still intend to use detailed action strings on API (since they are a lot nicer to look at) but detailed action strings can be given in non-canonical forms (eg: 'foo::bar' and 'foo("bar")' are equivalent) so we'd have to go through a normalisation step anyway. Since we're doing that already, we may as well convert to a more convenient internal format. This new "action and target" format is going to start appearing in a lot more places as action descriptions are introduced. I suspect that nobody is using '|' in their action names, but in case I am proven wrong, we can always switch to using something more exotic as a separator character (such as '\x01' or '\xff' or the like).
2013-07-10 02:37:17 +00:00
}
Replace stateful actions by property actions The only cases of stateful actions we've seen so far have been boolean properties, and we don't really want to add much state handling API, so lets just go with property actions for now. Adapt the only user in GtkText.
2019-06-22 20:18:05 +00:00
static GVariant *
prop_action_get_state (GtkWidget *widget,
GtkWidgetAction *action)
{
GValue value = G_VALUE_INIT;
GVariant *result;
g_value_init (&value, action->pspec->value_type);
g_object_get_property (G_OBJECT (widget), action->pspec->name, &value);
result = g_settings_set_mapping (&value, action->state_type, NULL);
g_value_unset (&value);
return g_variant_ref_sink (result);
}
static GVariant *
prop_action_get_state_hint (GtkWidget *widget,
GtkWidgetAction *action)
{
if (action->pspec->value_type == G_TYPE_INT)
{
GParamSpecInt *pspec = (GParamSpecInt *)action->pspec;
return g_variant_new ("(ii)", pspec->minimum, pspec->maximum);
}
else if (action->pspec->value_type == G_TYPE_UINT)
{
GParamSpecUInt *pspec = (GParamSpecUInt *)action->pspec;
return g_variant_new ("(uu)", pspec->minimum, pspec->maximum);
}
else if (action->pspec->value_type == G_TYPE_FLOAT)
{
GParamSpecFloat *pspec = (GParamSpecFloat *)action->pspec;
return g_variant_new ("(dd)", (double)pspec->minimum, (double)pspec->maximum);
}
else if (action->pspec->value_type == G_TYPE_DOUBLE)
{
GParamSpecDouble *pspec = (GParamSpecDouble *)action->pspec;
return g_variant_new ("(dd)", pspec->minimum, pspec->maximum);
}
return NULL;
}
static void
prop_action_set_state (GtkWidget *widget,
GtkWidgetAction *action,
GVariant *state)
{
GValue value = G_VALUE_INIT;
g_value_init (&value, action->pspec->value_type);
g_settings_get_mapping (&value, state, NULL);
g_object_set_property (G_OBJECT (widget), action->pspec->name, &value);
g_value_unset (&value);
}
static void
prop_action_activate (GtkWidget *widget,
GtkWidgetAction *action,
GVariant *parameter)
{
if (action->pspec->value_type == G_TYPE_BOOLEAN)
{
gboolean value;
g_return_if_fail (parameter == NULL);
g_object_get (G_OBJECT (widget), action->pspec->name, &value, NULL);
value = !value;
g_object_set (G_OBJECT (widget), action->pspec->name, value, NULL);
}
else
{
g_return_if_fail (parameter != NULL && g_variant_is_of_type (parameter, action->state_type));
prop_action_set_state (widget, action, parameter);
}
}
static void
prop_action_notify (GObject *object,
GParamSpec *pspec,
gpointer user_data)
{
Speed up class action hookup No need to construct a detailed signal name for every action when we can just look up the signal ID once and use the quark that the GParamSpec already has. Also, we don't need to loop over the actions every time we get a notification.
2020-04-29 00:22:26 +00:00
GtkWidget *widget = GTK_WIDGET (object);
GtkWidgetAction *action = user_data;
GtkActionMuxer *muxer = _gtk_widget_get_action_muxer (widget, TRUE);
Replace stateful actions by property actions The only cases of stateful actions we've seen so far have been boolean properties, and we don't really want to add much state handling API, so lets just go with property actions for now. Adapt the only user in GtkText.
2019-06-22 20:18:05 +00:00
GVariant *state;
Speed up class action hookup No need to construct a detailed signal name for every action when we can just look up the signal ID once and use the quark that the GParamSpec already has. Also, we don't need to loop over the actions every time we get a notification.
2020-04-29 00:22:26 +00:00
g_assert (muxer->widget == widget);
widget: fix class private data usage to be _init() safe Before this commit, adding GtkWidgetAction to class private data would require copying the actions to each subclass as they were built or modified. This was convenient in that it is a sort of "copy on write" semantic. However, due to the way that GTypeInstance works with base _init() functions, the "g_class" pointer in GTypeInstance is updated as each _init() function is called. That means you cannot access the subclasses class private data, but only the parent class private data. If instead we use a singly linked list of GtkWidgetAction, each subclass has their own "head" yet all subclasses share the tail of the GtkWidgetAction chain. This creates one bit of complexity though. You need a stable way to know which "bit" is the "enabled" bit of the action so we can track enabled GAction state. That is easily solved by calculating the distance to the end of the chain for a given action so that base classes sort ahead of subclasses. Since the parent class always knows its parent's actions, the position is stable. A new dynamic bitarray helper also helps us avoid allocations in all the current cases (up to 64 actions per widget) and dynamically switches to malloc if that is to ever be exceeded.
2020-03-20 16:22:29 +00:00
g_assert (action->pspec == pspec);
Replace stateful actions by property actions The only cases of stateful actions we've seen so far have been boolean properties, and we don't really want to add much state handling API, so lets just go with property actions for now. Adapt the only user in GtkText.
2019-06-22 20:18:05 +00:00
Speed up class action hookup No need to construct a detailed signal name for every action when we can just look up the signal ID once and use the quark that the GParamSpec already has. Also, we don't need to loop over the actions every time we get a notification.
2020-04-29 00:22:26 +00:00
state = prop_action_get_state (widget, action);
Replace stateful actions by property actions The only cases of stateful actions we've seen so far have been boolean properties, and we don't really want to add much state handling API, so lets just go with property actions for now. Adapt the only user in GtkText.
2019-06-22 20:18:05 +00:00
gtk_action_muxer_action_state_changed (muxer, action->name, state);
g_variant_unref (state);
}
static void
prop_actions_connect (GtkActionMuxer *muxer)
{
widget: fix class private data usage to be _init() safe Before this commit, adding GtkWidgetAction to class private data would require copying the actions to each subclass as they were built or modified. This was convenient in that it is a sort of "copy on write" semantic. However, due to the way that GTypeInstance works with base _init() functions, the "g_class" pointer in GTypeInstance is updated as each _init() function is called. That means you cannot access the subclasses class private data, but only the parent class private data. If instead we use a singly linked list of GtkWidgetAction, each subclass has their own "head" yet all subclasses share the tail of the GtkWidgetAction chain. This creates one bit of complexity though. You need a stable way to know which "bit" is the "enabled" bit of the action so we can track enabled GAction state. That is easily solved by calculating the distance to the end of the chain for a given action so that base classes sort ahead of subclasses. Since the parent class always knows its parent's actions, the position is stable. A new dynamic bitarray helper also helps us avoid allocations in all the current cases (up to 64 actions per widget) and dynamically switches to malloc if that is to ever be exceeded.
2020-03-20 16:22:29 +00:00
GtkWidgetClassPrivate *priv;
GtkWidgetAction *action;
GtkWidgetClass *klass;
Speed up class action hookup No need to construct a detailed signal name for every action when we can just look up the signal ID once and use the quark that the GParamSpec already has. Also, we don't need to loop over the actions every time we get a notification.
2020-04-29 00:22:26 +00:00
guint signal_id;
widget: fix class private data usage to be _init() safe Before this commit, adding GtkWidgetAction to class private data would require copying the actions to each subclass as they were built or modified. This was convenient in that it is a sort of "copy on write" semantic. However, due to the way that GTypeInstance works with base _init() functions, the "g_class" pointer in GTypeInstance is updated as each _init() function is called. That means you cannot access the subclasses class private data, but only the parent class private data. If instead we use a singly linked list of GtkWidgetAction, each subclass has their own "head" yet all subclasses share the tail of the GtkWidgetAction chain. This creates one bit of complexity though. You need a stable way to know which "bit" is the "enabled" bit of the action so we can track enabled GAction state. That is easily solved by calculating the distance to the end of the chain for a given action so that base classes sort ahead of subclasses. Since the parent class always knows its parent's actions, the position is stable. A new dynamic bitarray helper also helps us avoid allocations in all the current cases (up to 64 actions per widget) and dynamically switches to malloc if that is to ever be exceeded.
2020-03-20 16:22:29 +00:00
if (!muxer->widget)
return;
Replace stateful actions by property actions The only cases of stateful actions we've seen so far have been boolean properties, and we don't really want to add much state handling API, so lets just go with property actions for now. Adapt the only user in GtkText.
2019-06-22 20:18:05 +00:00
widget: fix class private data usage to be _init() safe Before this commit, adding GtkWidgetAction to class private data would require copying the actions to each subclass as they were built or modified. This was convenient in that it is a sort of "copy on write" semantic. However, due to the way that GTypeInstance works with base _init() functions, the "g_class" pointer in GTypeInstance is updated as each _init() function is called. That means you cannot access the subclasses class private data, but only the parent class private data. If instead we use a singly linked list of GtkWidgetAction, each subclass has their own "head" yet all subclasses share the tail of the GtkWidgetAction chain. This creates one bit of complexity though. You need a stable way to know which "bit" is the "enabled" bit of the action so we can track enabled GAction state. That is easily solved by calculating the distance to the end of the chain for a given action so that base classes sort ahead of subclasses. Since the parent class always knows its parent's actions, the position is stable. A new dynamic bitarray helper also helps us avoid allocations in all the current cases (up to 64 actions per widget) and dynamically switches to malloc if that is to ever be exceeded.
2020-03-20 16:22:29 +00:00
klass = GTK_WIDGET_GET_CLASS (muxer->widget);
priv = klass->priv;
if (!priv->actions)
Replace stateful actions by property actions The only cases of stateful actions we've seen so far have been boolean properties, and we don't really want to add much state handling API, so lets just go with property actions for now. Adapt the only user in GtkText.
2019-06-22 20:18:05 +00:00
return;
Speed up class action hookup No need to construct a detailed signal name for every action when we can just look up the signal ID once and use the quark that the GParamSpec already has. Also, we don't need to loop over the actions every time we get a notification.
2020-04-29 00:22:26 +00:00
signal_id = g_signal_lookup ("notify", G_TYPE_OBJECT);
widget: fix class private data usage to be _init() safe Before this commit, adding GtkWidgetAction to class private data would require copying the actions to each subclass as they were built or modified. This was convenient in that it is a sort of "copy on write" semantic. However, due to the way that GTypeInstance works with base _init() functions, the "g_class" pointer in GTypeInstance is updated as each _init() function is called. That means you cannot access the subclasses class private data, but only the parent class private data. If instead we use a singly linked list of GtkWidgetAction, each subclass has their own "head" yet all subclasses share the tail of the GtkWidgetAction chain. This creates one bit of complexity though. You need a stable way to know which "bit" is the "enabled" bit of the action so we can track enabled GAction state. That is easily solved by calculating the distance to the end of the chain for a given action so that base classes sort ahead of subclasses. Since the parent class always knows its parent's actions, the position is stable. A new dynamic bitarray helper also helps us avoid allocations in all the current cases (up to 64 actions per widget) and dynamically switches to malloc if that is to ever be exceeded.
2020-03-20 16:22:29 +00:00
for (action = priv->actions; action; action = action->next)
Replace stateful actions by property actions The only cases of stateful actions we've seen so far have been boolean properties, and we don't really want to add much state handling API, so lets just go with property actions for now. Adapt the only user in GtkText.
2019-06-22 20:18:05 +00:00
{
if (!action->pspec)
continue;
Speed up class action hookup No need to construct a detailed signal name for every action when we can just look up the signal ID once and use the quark that the GParamSpec already has. Also, we don't need to loop over the actions every time we get a notification.
2020-04-29 00:22:26 +00:00
g_signal_connect_closure_by_id (muxer->widget,
signal_id,
g_param_spec_get_name_quark (action->pspec),
g_cclosure_new (G_CALLBACK (prop_action_notify),
action,
NULL),
FALSE);
Replace stateful actions by property actions The only cases of stateful actions we've seen so far have been boolean properties, and we don't really want to add much state handling API, so lets just go with property actions for now. Adapt the only user in GtkText.
2019-06-22 20:18:05 +00:00
}
}
actionmuxer: Stop implementing GActionGroup Instead of implementing the GActionGroup interface and using its signals for propagating changes up and down the muxer hierarchy, use the GtkActionObserver mechanism. This cuts down on the signal emission overhead.
2020-07-19 05:17:23 +00:00
static gboolean
action_muxer_query_action (GtkActionMuxer *muxer,
Replace "gchar" with "char"
2020-07-24 18:40:36 +00:00
const char *action_name,
actionmuxer: Stop implementing GActionGroup Instead of implementing the GActionGroup interface and using its signals for propagating changes up and down the muxer hierarchy, use the GtkActionObserver mechanism. This cuts down on the signal emission overhead.
2020-07-19 05:17:23 +00:00
gboolean *enabled,
const GVariantType **parameter_type,
const GVariantType **state_type,
GVariant **state_hint,
GVariant **state,
gboolean recurse)
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
{
widget: fix class private data usage to be _init() safe Before this commit, adding GtkWidgetAction to class private data would require copying the actions to each subclass as they were built or modified. This was convenient in that it is a sort of "copy on write" semantic. However, due to the way that GTypeInstance works with base _init() functions, the "g_class" pointer in GTypeInstance is updated as each _init() function is called. That means you cannot access the subclasses class private data, but only the parent class private data. If instead we use a singly linked list of GtkWidgetAction, each subclass has their own "head" yet all subclasses share the tail of the GtkWidgetAction chain. This creates one bit of complexity though. You need a stable way to know which "bit" is the "enabled" bit of the action so we can track enabled GAction state. That is easily solved by calculating the distance to the end of the chain for a given action so that base classes sort ahead of subclasses. Since the parent class always knows its parent's actions, the position is stable. A new dynamic bitarray helper also helps us avoid allocations in all the current cases (up to 64 actions per widget) and dynamically switches to malloc if that is to ever be exceeded.
2020-03-20 16:22:29 +00:00
GtkWidgetAction *action;
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
Group *group;
Replace "gchar" with "char"
2020-07-24 18:40:36 +00:00
const char *unprefixed_name;
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
widget: fix class private data usage to be _init() safe Before this commit, adding GtkWidgetAction to class private data would require copying the actions to each subclass as they were built or modified. This was convenient in that it is a sort of "copy on write" semantic. However, due to the way that GTypeInstance works with base _init() functions, the "g_class" pointer in GTypeInstance is updated as each _init() function is called. That means you cannot access the subclasses class private data, but only the parent class private data. If instead we use a singly linked list of GtkWidgetAction, each subclass has their own "head" yet all subclasses share the tail of the GtkWidgetAction chain. This creates one bit of complexity though. You need a stable way to know which "bit" is the "enabled" bit of the action so we can track enabled GAction state. That is easily solved by calculating the distance to the end of the chain for a given action so that base classes sort ahead of subclasses. Since the parent class always knows its parent's actions, the position is stable. A new dynamic bitarray helper also helps us avoid allocations in all the current cases (up to 64 actions per widget) and dynamically switches to malloc if that is to ever be exceeded.
2020-03-20 16:22:29 +00:00
if (muxer->widget)
Allow registering actions per-class Add a facility to register and install actions at class init time. The intended use for these actions is for a) context and other model-based menus b) key bindings Most of these actions are going to be stateless, so add separate apis for the simple and stateful cases. We avoid creating an action group for these by teaching the action muxer about these actions. The action muxer also maintains the enabled state for these actions.
2019-06-14 12:12:10 +00:00
{
widget: fix class private data usage to be _init() safe Before this commit, adding GtkWidgetAction to class private data would require copying the actions to each subclass as they were built or modified. This was convenient in that it is a sort of "copy on write" semantic. However, due to the way that GTypeInstance works with base _init() functions, the "g_class" pointer in GTypeInstance is updated as each _init() function is called. That means you cannot access the subclasses class private data, but only the parent class private data. If instead we use a singly linked list of GtkWidgetAction, each subclass has their own "head" yet all subclasses share the tail of the GtkWidgetAction chain. This creates one bit of complexity though. You need a stable way to know which "bit" is the "enabled" bit of the action so we can track enabled GAction state. That is easily solved by calculating the distance to the end of the chain for a given action so that base classes sort ahead of subclasses. Since the parent class always knows its parent's actions, the position is stable. A new dynamic bitarray helper also helps us avoid allocations in all the current cases (up to 64 actions per widget) and dynamically switches to malloc if that is to ever be exceeded.
2020-03-20 16:22:29 +00:00
GtkWidgetClass *klass = GTK_WIDGET_GET_CLASS (muxer->widget);
GtkWidgetClassPrivate *priv = klass->priv;
Allow registering actions per-class Add a facility to register and install actions at class init time. The intended use for these actions is for a) context and other model-based menus b) key bindings Most of these actions are going to be stateless, so add separate apis for the simple and stateful cases. We avoid creating an action group for these by teaching the action muxer about these actions. The action muxer also maintains the enabled state for these actions.
2019-06-14 12:12:10 +00:00
widget: fix class private data usage to be _init() safe Before this commit, adding GtkWidgetAction to class private data would require copying the actions to each subclass as they were built or modified. This was convenient in that it is a sort of "copy on write" semantic. However, due to the way that GTypeInstance works with base _init() functions, the "g_class" pointer in GTypeInstance is updated as each _init() function is called. That means you cannot access the subclasses class private data, but only the parent class private data. If instead we use a singly linked list of GtkWidgetAction, each subclass has their own "head" yet all subclasses share the tail of the GtkWidgetAction chain. This creates one bit of complexity though. You need a stable way to know which "bit" is the "enabled" bit of the action so we can track enabled GAction state. That is easily solved by calculating the distance to the end of the chain for a given action so that base classes sort ahead of subclasses. Since the parent class always knows its parent's actions, the position is stable. A new dynamic bitarray helper also helps us avoid allocations in all the current cases (up to 64 actions per widget) and dynamically switches to malloc if that is to ever be exceeded.
2020-03-20 16:22:29 +00:00
for (action = priv->actions; action; action = action->next)
Allow registering actions per-class Add a facility to register and install actions at class init time. The intended use for these actions is for a) context and other model-based menus b) key bindings Most of these actions are going to be stateless, so add separate apis for the simple and stateful cases. We avoid creating an action group for these by teaching the action muxer about these actions. The action muxer also maintains the enabled state for these actions.
2019-06-14 12:12:10 +00:00
{
widget: fix class private data usage to be _init() safe Before this commit, adding GtkWidgetAction to class private data would require copying the actions to each subclass as they were built or modified. This was convenient in that it is a sort of "copy on write" semantic. However, due to the way that GTypeInstance works with base _init() functions, the "g_class" pointer in GTypeInstance is updated as each _init() function is called. That means you cannot access the subclasses class private data, but only the parent class private data. If instead we use a singly linked list of GtkWidgetAction, each subclass has their own "head" yet all subclasses share the tail of the GtkWidgetAction chain. This creates one bit of complexity though. You need a stable way to know which "bit" is the "enabled" bit of the action so we can track enabled GAction state. That is easily solved by calculating the distance to the end of the chain for a given action so that base classes sort ahead of subclasses. Since the parent class always knows its parent's actions, the position is stable. A new dynamic bitarray helper also helps us avoid allocations in all the current cases (up to 64 actions per widget) and dynamically switches to malloc if that is to ever be exceeded.
2020-03-20 16:22:29 +00:00
guint position;
Allow registering actions per-class Add a facility to register and install actions at class init time. The intended use for these actions is for a) context and other model-based menus b) key bindings Most of these actions are going to be stateless, so add separate apis for the simple and stateful cases. We avoid creating an action group for these by teaching the action muxer about these actions. The action muxer also maintains the enabled state for these actions.
2019-06-14 12:12:10 +00:00
widget: fix class private data usage to be _init() safe Before this commit, adding GtkWidgetAction to class private data would require copying the actions to each subclass as they were built or modified. This was convenient in that it is a sort of "copy on write" semantic. However, due to the way that GTypeInstance works with base _init() functions, the "g_class" pointer in GTypeInstance is updated as each _init() function is called. That means you cannot access the subclasses class private data, but only the parent class private data. If instead we use a singly linked list of GtkWidgetAction, each subclass has their own "head" yet all subclasses share the tail of the GtkWidgetAction chain. This creates one bit of complexity though. You need a stable way to know which "bit" is the "enabled" bit of the action so we can track enabled GAction state. That is easily solved by calculating the distance to the end of the chain for a given action so that base classes sort ahead of subclasses. Since the parent class always knows its parent's actions, the position is stable. A new dynamic bitarray helper also helps us avoid allocations in all the current cases (up to 64 actions per widget) and dynamically switches to malloc if that is to ever be exceeded.
2020-03-20 16:22:29 +00:00
if (strcmp (action->name, action_name) != 0)
continue;
Allow registering actions per-class Add a facility to register and install actions at class init time. The intended use for these actions is for a) context and other model-based menus b) key bindings Most of these actions are going to be stateless, so add separate apis for the simple and stateful cases. We avoid creating an action group for these by teaching the action muxer about these actions. The action muxer also maintains the enabled state for these actions.
2019-06-14 12:12:10 +00:00
widget: fix class private data usage to be _init() safe Before this commit, adding GtkWidgetAction to class private data would require copying the actions to each subclass as they were built or modified. This was convenient in that it is a sort of "copy on write" semantic. However, due to the way that GTypeInstance works with base _init() functions, the "g_class" pointer in GTypeInstance is updated as each _init() function is called. That means you cannot access the subclasses class private data, but only the parent class private data. If instead we use a singly linked list of GtkWidgetAction, each subclass has their own "head" yet all subclasses share the tail of the GtkWidgetAction chain. This creates one bit of complexity though. You need a stable way to know which "bit" is the "enabled" bit of the action so we can track enabled GAction state. That is easily solved by calculating the distance to the end of the chain for a given action so that base classes sort ahead of subclasses. Since the parent class always knows its parent's actions, the position is stable. A new dynamic bitarray helper also helps us avoid allocations in all the current cases (up to 64 actions per widget) and dynamically switches to malloc if that is to ever be exceeded.
2020-03-20 16:22:29 +00:00
position = get_action_position (action);
if (enabled)
*enabled = !_gtk_bitmask_get (muxer->widget_actions_disabled, position);
if (parameter_type)
*parameter_type = action->parameter_type;
if (state_type)
*state_type = action->state_type;
if (state_hint)
*state_hint = NULL;
if (state)
*state = NULL;
Allow registering actions per-class Add a facility to register and install actions at class init time. The intended use for these actions is for a) context and other model-based menus b) key bindings Most of these actions are going to be stateless, so add separate apis for the simple and stateful cases. We avoid creating an action group for these by teaching the action muxer about these actions. The action muxer also maintains the enabled state for these actions.
2019-06-14 12:12:10 +00:00
widget: fix class private data usage to be _init() safe Before this commit, adding GtkWidgetAction to class private data would require copying the actions to each subclass as they were built or modified. This was convenient in that it is a sort of "copy on write" semantic. However, due to the way that GTypeInstance works with base _init() functions, the "g_class" pointer in GTypeInstance is updated as each _init() function is called. That means you cannot access the subclasses class private data, but only the parent class private data. If instead we use a singly linked list of GtkWidgetAction, each subclass has their own "head" yet all subclasses share the tail of the GtkWidgetAction chain. This creates one bit of complexity though. You need a stable way to know which "bit" is the "enabled" bit of the action so we can track enabled GAction state. That is easily solved by calculating the distance to the end of the chain for a given action so that base classes sort ahead of subclasses. Since the parent class always knows its parent's actions, the position is stable. A new dynamic bitarray helper also helps us avoid allocations in all the current cases (up to 64 actions per widget) and dynamically switches to malloc if that is to ever be exceeded.
2020-03-20 16:22:29 +00:00
if (action->pspec)
{
if (state)
*state = prop_action_get_state (muxer->widget, action);
if (state_hint)
*state_hint = prop_action_get_state_hint (muxer->widget, action);
Allow registering actions per-class Add a facility to register and install actions at class init time. The intended use for these actions is for a) context and other model-based menus b) key bindings Most of these actions are going to be stateless, so add separate apis for the simple and stateful cases. We avoid creating an action group for these by teaching the action muxer about these actions. The action muxer also maintains the enabled state for these actions.
2019-06-14 12:12:10 +00:00
}
widget: fix class private data usage to be _init() safe Before this commit, adding GtkWidgetAction to class private data would require copying the actions to each subclass as they were built or modified. This was convenient in that it is a sort of "copy on write" semantic. However, due to the way that GTypeInstance works with base _init() functions, the "g_class" pointer in GTypeInstance is updated as each _init() function is called. That means you cannot access the subclasses class private data, but only the parent class private data. If instead we use a singly linked list of GtkWidgetAction, each subclass has their own "head" yet all subclasses share the tail of the GtkWidgetAction chain. This creates one bit of complexity though. You need a stable way to know which "bit" is the "enabled" bit of the action so we can track enabled GAction state. That is easily solved by calculating the distance to the end of the chain for a given action so that base classes sort ahead of subclasses. Since the parent class always knows its parent's actions, the position is stable. A new dynamic bitarray helper also helps us avoid allocations in all the current cases (up to 64 actions per widget) and dynamically switches to malloc if that is to ever be exceeded.
2020-03-20 16:22:29 +00:00
return TRUE;
}
Allow registering actions per-class Add a facility to register and install actions at class init time. The intended use for these actions is for a) context and other model-based menus b) key bindings Most of these actions are going to be stateless, so add separate apis for the simple and stateful cases. We avoid creating an action group for these by teaching the action muxer about these actions. The action muxer also maintains the enabled state for these actions.
2019-06-14 12:12:10 +00:00
}
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
group = gtk_action_muxer_find_group (muxer, action_name, &unprefixed_name);
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
if (group)
return g_action_group_query_action (group->group, unprefixed_name, enabled,
parameter_type, state_type, state_hint, state);
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
actionmuxer: Stop implementing GActionGroup Instead of implementing the GActionGroup interface and using its signals for propagating changes up and down the muxer hierarchy, use the GtkActionObserver mechanism. This cuts down on the signal emission overhead.
2020-07-19 05:17:23 +00:00
if (muxer->parent && recurse)
return gtk_action_muxer_query_action (muxer->parent, action_name,
enabled, parameter_type,
state_type, state_hint, state);
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
return FALSE;
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
}
actionmuxer: Stop implementing GActionGroup Instead of implementing the GActionGroup interface and using its signals for propagating changes up and down the muxer hierarchy, use the GtkActionObserver mechanism. This cuts down on the signal emission overhead.
2020-07-19 05:17:23 +00:00
gboolean
gtk_action_muxer_query_action (GtkActionMuxer *muxer,
Replace "gchar" with "char"
2020-07-24 18:40:36 +00:00
const char *action_name,
actionmuxer: Stop implementing GActionGroup Instead of implementing the GActionGroup interface and using its signals for propagating changes up and down the muxer hierarchy, use the GtkActionObserver mechanism. This cuts down on the signal emission overhead.
2020-07-19 05:17:23 +00:00
gboolean *enabled,
const GVariantType **parameter_type,
const GVariantType **state_type,
GVariant **state_hint,
GVariant **state)
{
return action_muxer_query_action (muxer, action_name,
enabled, parameter_type,
state_type, state_hint, state,
TRUE);
}
actionmuxer: Add some more api We want to drop the GActionGroup interface from GtkActionMuxer, so add the necessary api directly to GtkActionMuxer itself.
2020-07-19 02:28:53 +00:00
gboolean
gtk_action_muxer_has_action (GtkActionMuxer *muxer,
const char *action_name)
{
actionmuxer: Stop implementing GActionGroup Instead of implementing the GActionGroup interface and using its signals for propagating changes up and down the muxer hierarchy, use the GtkActionObserver mechanism. This cuts down on the signal emission overhead.
2020-07-19 05:17:23 +00:00
return action_muxer_query_action (muxer, action_name,
NULL, NULL, NULL, NULL, NULL,
TRUE);
actionmuxer: Add some more api We want to drop the GActionGroup interface from GtkActionMuxer, so add the necessary api directly to GtkActionMuxer itself.
2020-07-19 02:28:53 +00:00
}
void
gtk_action_muxer_activate_action (GtkActionMuxer *muxer,
Replace "gchar" with "char"
2020-07-24 18:40:36 +00:00
const char *action_name,
actionmuxer: Add some more api We want to drop the GActionGroup interface from GtkActionMuxer, so add the necessary api directly to GtkActionMuxer itself.
2020-07-19 02:28:53 +00:00
GVariant *parameter)
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
{
Replace "gchar" with "char"
2020-07-24 18:40:36 +00:00
const char *unprefixed_name;
widget: fix class private data usage to be _init() safe Before this commit, adding GtkWidgetAction to class private data would require copying the actions to each subclass as they were built or modified. This was convenient in that it is a sort of "copy on write" semantic. However, due to the way that GTypeInstance works with base _init() functions, the "g_class" pointer in GTypeInstance is updated as each _init() function is called. That means you cannot access the subclasses class private data, but only the parent class private data. If instead we use a singly linked list of GtkWidgetAction, each subclass has their own "head" yet all subclasses share the tail of the GtkWidgetAction chain. This creates one bit of complexity though. You need a stable way to know which "bit" is the "enabled" bit of the action so we can track enabled GAction state. That is easily solved by calculating the distance to the end of the chain for a given action so that base classes sort ahead of subclasses. Since the parent class always knows its parent's actions, the position is stable. A new dynamic bitarray helper also helps us avoid allocations in all the current cases (up to 64 actions per widget) and dynamically switches to malloc if that is to ever be exceeded.
2020-03-20 16:22:29 +00:00
Group *group;
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
widget: fix class private data usage to be _init() safe Before this commit, adding GtkWidgetAction to class private data would require copying the actions to each subclass as they were built or modified. This was convenient in that it is a sort of "copy on write" semantic. However, due to the way that GTypeInstance works with base _init() functions, the "g_class" pointer in GTypeInstance is updated as each _init() function is called. That means you cannot access the subclasses class private data, but only the parent class private data. If instead we use a singly linked list of GtkWidgetAction, each subclass has their own "head" yet all subclasses share the tail of the GtkWidgetAction chain. This creates one bit of complexity though. You need a stable way to know which "bit" is the "enabled" bit of the action so we can track enabled GAction state. That is easily solved by calculating the distance to the end of the chain for a given action so that base classes sort ahead of subclasses. Since the parent class always knows its parent's actions, the position is stable. A new dynamic bitarray helper also helps us avoid allocations in all the current cases (up to 64 actions per widget) and dynamically switches to malloc if that is to ever be exceeded.
2020-03-20 16:22:29 +00:00
if (muxer->widget)
Allow registering actions per-class Add a facility to register and install actions at class init time. The intended use for these actions is for a) context and other model-based menus b) key bindings Most of these actions are going to be stateless, so add separate apis for the simple and stateful cases. We avoid creating an action group for these by teaching the action muxer about these actions. The action muxer also maintains the enabled state for these actions.
2019-06-14 12:12:10 +00:00
{
widget: fix class private data usage to be _init() safe Before this commit, adding GtkWidgetAction to class private data would require copying the actions to each subclass as they were built or modified. This was convenient in that it is a sort of "copy on write" semantic. However, due to the way that GTypeInstance works with base _init() functions, the "g_class" pointer in GTypeInstance is updated as each _init() function is called. That means you cannot access the subclasses class private data, but only the parent class private data. If instead we use a singly linked list of GtkWidgetAction, each subclass has their own "head" yet all subclasses share the tail of the GtkWidgetAction chain. This creates one bit of complexity though. You need a stable way to know which "bit" is the "enabled" bit of the action so we can track enabled GAction state. That is easily solved by calculating the distance to the end of the chain for a given action so that base classes sort ahead of subclasses. Since the parent class always knows its parent's actions, the position is stable. A new dynamic bitarray helper also helps us avoid allocations in all the current cases (up to 64 actions per widget) and dynamically switches to malloc if that is to ever be exceeded.
2020-03-20 16:22:29 +00:00
GtkWidgetClass *klass = GTK_WIDGET_GET_CLASS (muxer->widget);
GtkWidgetClassPrivate *priv = klass->priv;
GtkWidgetAction *action;
Allow registering actions per-class Add a facility to register and install actions at class init time. The intended use for these actions is for a) context and other model-based menus b) key bindings Most of these actions are going to be stateless, so add separate apis for the simple and stateful cases. We avoid creating an action group for these by teaching the action muxer about these actions. The action muxer also maintains the enabled state for these actions.
2019-06-14 12:12:10 +00:00
widget: fix class private data usage to be _init() safe Before this commit, adding GtkWidgetAction to class private data would require copying the actions to each subclass as they were built or modified. This was convenient in that it is a sort of "copy on write" semantic. However, due to the way that GTypeInstance works with base _init() functions, the "g_class" pointer in GTypeInstance is updated as each _init() function is called. That means you cannot access the subclasses class private data, but only the parent class private data. If instead we use a singly linked list of GtkWidgetAction, each subclass has their own "head" yet all subclasses share the tail of the GtkWidgetAction chain. This creates one bit of complexity though. You need a stable way to know which "bit" is the "enabled" bit of the action so we can track enabled GAction state. That is easily solved by calculating the distance to the end of the chain for a given action so that base classes sort ahead of subclasses. Since the parent class always knows its parent's actions, the position is stable. A new dynamic bitarray helper also helps us avoid allocations in all the current cases (up to 64 actions per widget) and dynamically switches to malloc if that is to ever be exceeded.
2020-03-20 16:22:29 +00:00
for (action = priv->actions; action; action = action->next)
Allow registering actions per-class Add a facility to register and install actions at class init time. The intended use for these actions is for a) context and other model-based menus b) key bindings Most of these actions are going to be stateless, so add separate apis for the simple and stateful cases. We avoid creating an action group for these by teaching the action muxer about these actions. The action muxer also maintains the enabled state for these actions.
2019-06-14 12:12:10 +00:00
{
if (strcmp (action->name, action_name) == 0)
{
widget: fix class private data usage to be _init() safe Before this commit, adding GtkWidgetAction to class private data would require copying the actions to each subclass as they were built or modified. This was convenient in that it is a sort of "copy on write" semantic. However, due to the way that GTypeInstance works with base _init() functions, the "g_class" pointer in GTypeInstance is updated as each _init() function is called. That means you cannot access the subclasses class private data, but only the parent class private data. If instead we use a singly linked list of GtkWidgetAction, each subclass has their own "head" yet all subclasses share the tail of the GtkWidgetAction chain. This creates one bit of complexity though. You need a stable way to know which "bit" is the "enabled" bit of the action so we can track enabled GAction state. That is easily solved by calculating the distance to the end of the chain for a given action so that base classes sort ahead of subclasses. Since the parent class always knows its parent's actions, the position is stable. A new dynamic bitarray helper also helps us avoid allocations in all the current cases (up to 64 actions per widget) and dynamically switches to malloc if that is to ever be exceeded.
2020-03-20 16:22:29 +00:00
guint position = get_action_position (action);
if (!_gtk_bitmask_get (muxer->widget_actions_disabled, position))
action muxer: Don't activate disabled actions We really shouldn't.
2019-06-23 01:19:19 +00:00
{
if (action->activate)
action->activate (muxer->widget, action->name, parameter);
else if (action->pspec)
prop_action_activate (muxer->widget, action, parameter);
}
Allow registering actions per-class Add a facility to register and install actions at class init time. The intended use for these actions is for a) context and other model-based menus b) key bindings Most of these actions are going to be stateless, so add separate apis for the simple and stateful cases. We avoid creating an action group for these by teaching the action muxer about these actions. The action muxer also maintains the enabled state for these actions.
2019-06-14 12:12:10 +00:00
return;
}
}
}
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
group = gtk_action_muxer_find_group (muxer, action_name, &unprefixed_name);
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
if (group)
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
g_action_group_activate_action (group->group, unprefixed_name, parameter);
else if (muxer->parent)
actionmuxer: Stop implementing GActionGroup Instead of implementing the GActionGroup interface and using its signals for propagating changes up and down the muxer hierarchy, use the GtkActionObserver mechanism. This cuts down on the signal emission overhead.
2020-07-19 05:17:23 +00:00
gtk_action_muxer_activate_action (muxer->parent, action_name, parameter);
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
}
actionmuxer: Add some more api We want to drop the GActionGroup interface from GtkActionMuxer, so add the necessary api directly to GtkActionMuxer itself.
2020-07-19 02:28:53 +00:00
void
gtk_action_muxer_change_action_state (GtkActionMuxer *muxer,
actionmuxer: Stop implementing GActionGroup Instead of implementing the GActionGroup interface and using its signals for propagating changes up and down the muxer hierarchy, use the GtkActionObserver mechanism. This cuts down on the signal emission overhead.
2020-07-19 05:17:23 +00:00
const char *action_name,
actionmuxer: Add some more api We want to drop the GActionGroup interface from GtkActionMuxer, so add the necessary api directly to GtkActionMuxer itself.
2020-07-19 02:28:53 +00:00
GVariant *state)
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
{
widget: fix class private data usage to be _init() safe Before this commit, adding GtkWidgetAction to class private data would require copying the actions to each subclass as they were built or modified. This was convenient in that it is a sort of "copy on write" semantic. However, due to the way that GTypeInstance works with base _init() functions, the "g_class" pointer in GTypeInstance is updated as each _init() function is called. That means you cannot access the subclasses class private data, but only the parent class private data. If instead we use a singly linked list of GtkWidgetAction, each subclass has their own "head" yet all subclasses share the tail of the GtkWidgetAction chain. This creates one bit of complexity though. You need a stable way to know which "bit" is the "enabled" bit of the action so we can track enabled GAction state. That is easily solved by calculating the distance to the end of the chain for a given action so that base classes sort ahead of subclasses. Since the parent class always knows its parent's actions, the position is stable. A new dynamic bitarray helper also helps us avoid allocations in all the current cases (up to 64 actions per widget) and dynamically switches to malloc if that is to ever be exceeded.
2020-03-20 16:22:29 +00:00
GtkWidgetAction *action;
Replace "gchar" with "char"
2020-07-24 18:40:36 +00:00
const char *unprefixed_name;
widget: fix class private data usage to be _init() safe Before this commit, adding GtkWidgetAction to class private data would require copying the actions to each subclass as they were built or modified. This was convenient in that it is a sort of "copy on write" semantic. However, due to the way that GTypeInstance works with base _init() functions, the "g_class" pointer in GTypeInstance is updated as each _init() function is called. That means you cannot access the subclasses class private data, but only the parent class private data. If instead we use a singly linked list of GtkWidgetAction, each subclass has their own "head" yet all subclasses share the tail of the GtkWidgetAction chain. This creates one bit of complexity though. You need a stable way to know which "bit" is the "enabled" bit of the action so we can track enabled GAction state. That is easily solved by calculating the distance to the end of the chain for a given action so that base classes sort ahead of subclasses. Since the parent class always knows its parent's actions, the position is stable. A new dynamic bitarray helper also helps us avoid allocations in all the current cases (up to 64 actions per widget) and dynamically switches to malloc if that is to ever be exceeded.
2020-03-20 16:22:29 +00:00
Group *group;
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
widget: fix class private data usage to be _init() safe Before this commit, adding GtkWidgetAction to class private data would require copying the actions to each subclass as they were built or modified. This was convenient in that it is a sort of "copy on write" semantic. However, due to the way that GTypeInstance works with base _init() functions, the "g_class" pointer in GTypeInstance is updated as each _init() function is called. That means you cannot access the subclasses class private data, but only the parent class private data. If instead we use a singly linked list of GtkWidgetAction, each subclass has their own "head" yet all subclasses share the tail of the GtkWidgetAction chain. This creates one bit of complexity though. You need a stable way to know which "bit" is the "enabled" bit of the action so we can track enabled GAction state. That is easily solved by calculating the distance to the end of the chain for a given action so that base classes sort ahead of subclasses. Since the parent class always knows its parent's actions, the position is stable. A new dynamic bitarray helper also helps us avoid allocations in all the current cases (up to 64 actions per widget) and dynamically switches to malloc if that is to ever be exceeded.
2020-03-20 16:22:29 +00:00
if (muxer->widget)
Allow registering actions per-class Add a facility to register and install actions at class init time. The intended use for these actions is for a) context and other model-based menus b) key bindings Most of these actions are going to be stateless, so add separate apis for the simple and stateful cases. We avoid creating an action group for these by teaching the action muxer about these actions. The action muxer also maintains the enabled state for these actions.
2019-06-14 12:12:10 +00:00
{
widget: fix class private data usage to be _init() safe Before this commit, adding GtkWidgetAction to class private data would require copying the actions to each subclass as they were built or modified. This was convenient in that it is a sort of "copy on write" semantic. However, due to the way that GTypeInstance works with base _init() functions, the "g_class" pointer in GTypeInstance is updated as each _init() function is called. That means you cannot access the subclasses class private data, but only the parent class private data. If instead we use a singly linked list of GtkWidgetAction, each subclass has their own "head" yet all subclasses share the tail of the GtkWidgetAction chain. This creates one bit of complexity though. You need a stable way to know which "bit" is the "enabled" bit of the action so we can track enabled GAction state. That is easily solved by calculating the distance to the end of the chain for a given action so that base classes sort ahead of subclasses. Since the parent class always knows its parent's actions, the position is stable. A new dynamic bitarray helper also helps us avoid allocations in all the current cases (up to 64 actions per widget) and dynamically switches to malloc if that is to ever be exceeded.
2020-03-20 16:22:29 +00:00
GtkWidgetClass *klass = GTK_WIDGET_GET_CLASS (muxer->widget);
GtkWidgetClassPrivate *priv = klass->priv;
Allow registering actions per-class Add a facility to register and install actions at class init time. The intended use for these actions is for a) context and other model-based menus b) key bindings Most of these actions are going to be stateless, so add separate apis for the simple and stateful cases. We avoid creating an action group for these by teaching the action muxer about these actions. The action muxer also maintains the enabled state for these actions.
2019-06-14 12:12:10 +00:00
widget: fix class private data usage to be _init() safe Before this commit, adding GtkWidgetAction to class private data would require copying the actions to each subclass as they were built or modified. This was convenient in that it is a sort of "copy on write" semantic. However, due to the way that GTypeInstance works with base _init() functions, the "g_class" pointer in GTypeInstance is updated as each _init() function is called. That means you cannot access the subclasses class private data, but only the parent class private data. If instead we use a singly linked list of GtkWidgetAction, each subclass has their own "head" yet all subclasses share the tail of the GtkWidgetAction chain. This creates one bit of complexity though. You need a stable way to know which "bit" is the "enabled" bit of the action so we can track enabled GAction state. That is easily solved by calculating the distance to the end of the chain for a given action so that base classes sort ahead of subclasses. Since the parent class always knows its parent's actions, the position is stable. A new dynamic bitarray helper also helps us avoid allocations in all the current cases (up to 64 actions per widget) and dynamically switches to malloc if that is to ever be exceeded.
2020-03-20 16:22:29 +00:00
for (action = priv->actions; action; action = action->next)
Allow registering actions per-class Add a facility to register and install actions at class init time. The intended use for these actions is for a) context and other model-based menus b) key bindings Most of these actions are going to be stateless, so add separate apis for the simple and stateful cases. We avoid creating an action group for these by teaching the action muxer about these actions. The action muxer also maintains the enabled state for these actions.
2019-06-14 12:12:10 +00:00
{
if (strcmp (action->name, action_name) == 0)
{
Replace stateful actions by property actions The only cases of stateful actions we've seen so far have been boolean properties, and we don't really want to add much state handling API, so lets just go with property actions for now. Adapt the only user in GtkText.
2019-06-22 20:18:05 +00:00
if (action->pspec)
prop_action_set_state (muxer->widget, action, state);
Allow registering actions per-class Add a facility to register and install actions at class init time. The intended use for these actions is for a) context and other model-based menus b) key bindings Most of these actions are going to be stateless, so add separate apis for the simple and stateful cases. We avoid creating an action group for these by teaching the action muxer about these actions. The action muxer also maintains the enabled state for these actions.
2019-06-14 12:12:10 +00:00
return;
}
}
}
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
group = gtk_action_muxer_find_group (muxer, action_name, &unprefixed_name);
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
if (group)
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
g_action_group_change_action_state (group->group, unprefixed_name, state);
else if (muxer->parent)
actionmuxer: Stop implementing GActionGroup Instead of implementing the GActionGroup interface and using its signals for propagating changes up and down the muxer hierarchy, use the GtkActionObserver mechanism. This cuts down on the signal emission overhead.
2020-07-19 05:17:23 +00:00
gtk_action_muxer_change_action_state (muxer->parent, action_name, state);
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
}
static void
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
gtk_action_muxer_unregister_internal (Action *action,
gpointer observer)
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
{
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
GtkActionMuxer *muxer = action->muxer;
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
GSList **ptr;
for (ptr = &action->watchers; *ptr; ptr = &(*ptr)->next)
if ((*ptr)->data == observer)
{
*ptr = g_slist_remove (*ptr, observer);
if (action->watchers == NULL)
actionmuxer: Stop implementing GActionGroup Instead of implementing the GActionGroup interface and using its signals for propagating changes up and down the muxer hierarchy, use the GtkActionObserver mechanism. This cuts down on the signal emission overhead.
2020-07-19 05:17:23 +00:00
{
if (muxer->parent)
gtk_action_observable_unregister_observer (GTK_ACTION_OBSERVABLE (muxer->parent),
action->fullname,
GTK_ACTION_OBSERVER (muxer));
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
g_hash_table_remove (muxer->observed_actions, action->fullname);
actionmuxer: Stop implementing GActionGroup Instead of implementing the GActionGroup interface and using its signals for propagating changes up and down the muxer hierarchy, use the GtkActionObserver mechanism. This cuts down on the signal emission overhead.
2020-07-19 05:17:23 +00:00
}
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
break;
}
}
static void
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
gtk_action_muxer_weak_notify (gpointer data,
GObject *where_the_object_was)
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
{
Action *action = data;
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
gtk_action_muxer_unregister_internal (action, where_the_object_was);
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
}
actionmuxer: Create observed_actions and groups on demand The vast majority of action muxers don't have observers or groups, so we can avoid the overhead of carrying all these empty hash tables.
2020-07-19 13:45:12 +00:00
static void gtk_action_muxer_free_action (gpointer data);
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
static void
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
gtk_action_muxer_register_observer (GtkActionObservable *observable,
Replace "gchar" with "char"
2020-07-24 18:40:36 +00:00
const char *name,
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
GtkActionObserver *observer)
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
{
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
GtkActionMuxer *muxer = GTK_ACTION_MUXER (observable);
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
Action *action;
actionmuxer: Stop implementing GActionGroup Instead of implementing the GActionGroup interface and using its signals for propagating changes up and down the muxer hierarchy, use the GtkActionObserver mechanism. This cuts down on the signal emission overhead.
2020-07-19 05:17:23 +00:00
gboolean enabled;
const GVariantType *parameter_type;
GVariant *state;
actionmuxer: avoid duplicate and recursive work If we've already done the tracking into the parent muxer, there is no need to do it again. This can save a great deal of recursive work when adding items to the muxer. This makes showing the context menu in gnome-text-editor repeatedly fast even as spelling corrections are changed. It is likely that this could fix #4422 as well. Fixes #4519 Fixes https://gitlab.gnome.org/GNOME/gnome-text-editor/-/issues/220
2021-12-08 08:31:49 +00:00
gboolean is_duplicate;
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
actionmuxer: Create observed_actions and groups on demand The vast majority of action muxers don't have observers or groups, so we can avoid the overhead of carrying all these empty hash tables.
2020-07-19 13:45:12 +00:00
if (!muxer->observed_actions)
muxer->observed_actions = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, gtk_action_muxer_free_action);
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
action = g_hash_table_lookup (muxer->observed_actions, name);
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
if (action == NULL)
{
action = g_slice_new (Action);
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
action->muxer = muxer;
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
action->fullname = g_strdup (name);
action->watchers = NULL;
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
g_hash_table_insert (muxer->observed_actions, action->fullname, action);
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
}
actionmuxer: avoid duplicate and recursive work If we've already done the tracking into the parent muxer, there is no need to do it again. This can save a great deal of recursive work when adding items to the muxer. This makes showing the context menu in gnome-text-editor repeatedly fast even as spelling corrections are changed. It is likely that this could fix #4422 as well. Fixes #4519 Fixes https://gitlab.gnome.org/GNOME/gnome-text-editor/-/issues/220
2021-12-08 08:31:49 +00:00
is_duplicate = g_slist_find (action->watchers, observer) != NULL;
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
action->watchers = g_slist_prepend (action->watchers, observer);
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
g_object_weak_ref (G_OBJECT (observer), gtk_action_muxer_weak_notify, action);
actionmuxer: Stop implementing GActionGroup Instead of implementing the GActionGroup interface and using its signals for propagating changes up and down the muxer hierarchy, use the GtkActionObserver mechanism. This cuts down on the signal emission overhead.
2020-07-19 05:17:23 +00:00
actionmuxer: avoid duplicate and recursive work If we've already done the tracking into the parent muxer, there is no need to do it again. This can save a great deal of recursive work when adding items to the muxer. This makes showing the context menu in gnome-text-editor repeatedly fast even as spelling corrections are changed. It is likely that this could fix #4422 as well. Fixes #4519 Fixes https://gitlab.gnome.org/GNOME/gnome-text-editor/-/issues/220
2021-12-08 08:31:49 +00:00
if (!is_duplicate)
actionmuxer: Stop implementing GActionGroup Instead of implementing the GActionGroup interface and using its signals for propagating changes up and down the muxer hierarchy, use the GtkActionObserver mechanism. This cuts down on the signal emission overhead.
2020-07-19 05:17:23 +00:00
{
actionmuxer: avoid duplicate and recursive work If we've already done the tracking into the parent muxer, there is no need to do it again. This can save a great deal of recursive work when adding items to the muxer. This makes showing the context menu in gnome-text-editor repeatedly fast even as spelling corrections are changed. It is likely that this could fix #4422 as well. Fixes #4519 Fixes https://gitlab.gnome.org/GNOME/gnome-text-editor/-/issues/220
2021-12-08 08:31:49 +00:00
if (action_muxer_query_action (muxer, name,
&enabled, &parameter_type,
NULL, NULL, &state, TRUE))
{
gtk_action_muxer_action_added (muxer, name, parameter_type, enabled, state);
g_clear_pointer (&state, g_variant_unref);
}
actionmuxer: Stop implementing GActionGroup Instead of implementing the GActionGroup interface and using its signals for propagating changes up and down the muxer hierarchy, use the GtkActionObserver mechanism. This cuts down on the signal emission overhead.
2020-07-19 05:17:23 +00:00
actionmuxer: avoid duplicate and recursive work If we've already done the tracking into the parent muxer, there is no need to do it again. This can save a great deal of recursive work when adding items to the muxer. This makes showing the context menu in gnome-text-editor repeatedly fast even as spelling corrections are changed. It is likely that this could fix #4422 as well. Fixes #4519 Fixes https://gitlab.gnome.org/GNOME/gnome-text-editor/-/issues/220
2021-12-08 08:31:49 +00:00
if (muxer->parent)
{
gtk_action_observable_register_observer (GTK_ACTION_OBSERVABLE (muxer->parent),
name,
GTK_ACTION_OBSERVER (muxer));
}
actionmuxer: Stop implementing GActionGroup Instead of implementing the GActionGroup interface and using its signals for propagating changes up and down the muxer hierarchy, use the GtkActionObserver mechanism. This cuts down on the signal emission overhead.
2020-07-19 05:17:23 +00:00
}
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
}
static void
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
gtk_action_muxer_unregister_observer (GtkActionObservable *observable,
Replace "gchar" with "char"
2020-07-24 18:40:36 +00:00
const char *name,
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
GtkActionObserver *observer)
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
{
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
GtkActionMuxer *muxer = GTK_ACTION_MUXER (observable);
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
Action *action;
actionmuxer: Create observed_actions and groups on demand The vast majority of action muxers don't have observers or groups, so we can avoid the overhead of carrying all these empty hash tables.
2020-07-19 13:45:12 +00:00
action = find_observers (muxer, name);
if (action)
{
g_object_weak_unref (G_OBJECT (observer), gtk_action_muxer_weak_notify, action);
gtk_action_muxer_unregister_internal (action, observer);
}
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
}
static void
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
gtk_action_muxer_free_group (gpointer data)
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
{
Group *group = data;
Replace "gint" with "int"
2020-07-24 13:54:49 +00:00
int i;
GActionMuxer: disconnect group signals on finalize The signals for the action group were being disconnected when the action group was explicitly removed from the GActionMuxer but the same was not being done when it was finalized. This means that a change in the state of an action group that used to be associated with a finalized GActionMuxer would result in a crash. This would happen for stateful application actions after closing a window.
2012-06-29 03:55:33 +00:00
/* 'for loop' or 'four loop'? */
for (i = 0; i < 4; i++)
g_signal_handler_disconnect (group->group, group->handler_ids[i]);
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
g_object_unref (group->group);
g_free (group->prefix);
g_slice_free (Group, group);
}
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
static void
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
gtk_action_muxer_free_action (gpointer data)
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
{
Action *action = data;
GSList *it;
for (it = action->watchers; it; it = it->next)
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
g_object_weak_unref (G_OBJECT (it->data), gtk_action_muxer_weak_notify, action);
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
g_slist_free (action->watchers);
g_free (action->fullname);
g_slice_free (Action, action);
}
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
static void
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
gtk_action_muxer_finalize (GObject *object)
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
{
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
GtkActionMuxer *muxer = GTK_ACTION_MUXER (object);
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
actionmuxer: Create observed_actions and groups on demand The vast majority of action muxers don't have observers or groups, so we can avoid the overhead of carrying all these empty hash tables.
2020-07-19 13:45:12 +00:00
if (muxer->observed_actions)
{
g_assert_cmpint (g_hash_table_size (muxer->observed_actions), ==, 0);
g_hash_table_unref (muxer->observed_actions);
}
if (muxer->groups)
g_hash_table_unref (muxer->groups);
actionmuxer: Use an array for accels We have a lot of accels across all the muxers, but the vast majority has just one or two, so an array is going to be smaller and faster for this.
2020-07-19 19:11:35 +00:00
gtk_accels_clear (&muxer->primary_accels);
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
widget: fix class private data usage to be _init() safe Before this commit, adding GtkWidgetAction to class private data would require copying the actions to each subclass as they were built or modified. This was convenient in that it is a sort of "copy on write" semantic. However, due to the way that GTypeInstance works with base _init() functions, the "g_class" pointer in GTypeInstance is updated as each _init() function is called. That means you cannot access the subclasses class private data, but only the parent class private data. If instead we use a singly linked list of GtkWidgetAction, each subclass has their own "head" yet all subclasses share the tail of the GtkWidgetAction chain. This creates one bit of complexity though. You need a stable way to know which "bit" is the "enabled" bit of the action so we can track enabled GAction state. That is easily solved by calculating the distance to the end of the chain for a given action so that base classes sort ahead of subclasses. Since the parent class always knows its parent's actions, the position is stable. A new dynamic bitarray helper also helps us avoid allocations in all the current cases (up to 64 actions per widget) and dynamically switches to malloc if that is to ever be exceeded.
2020-03-20 16:22:29 +00:00
_gtk_bitmask_free (muxer->widget_actions_disabled);
actionmuxer: Plug a memory leak
2019-07-06 05:13:41 +00:00
widget: fix class private data usage to be _init() safe Before this commit, adding GtkWidgetAction to class private data would require copying the actions to each subclass as they were built or modified. This was convenient in that it is a sort of "copy on write" semantic. However, due to the way that GTypeInstance works with base _init() functions, the "g_class" pointer in GTypeInstance is updated as each _init() function is called. That means you cannot access the subclasses class private data, but only the parent class private data. If instead we use a singly linked list of GtkWidgetAction, each subclass has their own "head" yet all subclasses share the tail of the GtkWidgetAction chain. This creates one bit of complexity though. You need a stable way to know which "bit" is the "enabled" bit of the action so we can track enabled GAction state. That is easily solved by calculating the distance to the end of the chain for a given action so that base classes sort ahead of subclasses. Since the parent class always knows its parent's actions, the position is stable. A new dynamic bitarray helper also helps us avoid allocations in all the current cases (up to 64 actions per widget) and dynamically switches to malloc if that is to ever be exceeded.
2020-03-20 16:22:29 +00:00
G_OBJECT_CLASS (gtk_action_muxer_parent_class)->finalize (object);
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
}
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
static void
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
gtk_action_muxer_dispose (GObject *object)
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
{
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
GtkActionMuxer *muxer = GTK_ACTION_MUXER (object);
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
actionmuxer: Stop implementing GActionGroup Instead of implementing the GActionGroup interface and using its signals for propagating changes up and down the muxer hierarchy, use the GtkActionObserver mechanism. This cuts down on the signal emission overhead.
2020-07-19 05:17:23 +00:00
g_clear_object (&muxer->parent);
actionmuxer: Create observed_actions and groups on demand The vast majority of action muxers don't have observers or groups, so we can avoid the overhead of carrying all these empty hash tables.
2020-07-19 13:45:12 +00:00
if (muxer->observed_actions)
g_hash_table_remove_all (muxer->observed_actions);
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
muxer: force muxer dispoal as part of widget dispose We need to cleanup state here immediately so that we do not potentially access the g_class private data after it been finalized. This ensures that the borrowed reference is dropped by the muxer.
2020-03-25 21:02:59 +00:00
muxer->widget = NULL;
actionmuxer: Stop implementing GActionGroup Instead of implementing the GActionGroup interface and using its signals for propagating changes up and down the muxer hierarchy, use the GtkActionObserver mechanism. This cuts down on the signal emission overhead.
2020-07-19 05:17:23 +00:00
G_OBJECT_CLASS (gtk_action_muxer_parent_class)->dispose (object);
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
}
Reshuffle action muxer initialization We were having a problem where property actions were not getting state updates because prop_actions_connect was triggered from some instance_init function while the widget class is not in place yet. Delay that call until the widget is fully constructed, so we can guarantee that we are dealing with the correct class private struct, and see all class actions.
2020-04-28 22:34:23 +00:00
void
gtk_action_muxer_connect_class_actions (GtkActionMuxer *muxer)
Replace stateful actions by property actions The only cases of stateful actions we've seen so far have been boolean properties, and we don't really want to add much state handling API, so lets just go with property actions for now. Adapt the only user in GtkText.
2019-06-22 20:18:05 +00:00
{
prop_actions_connect (muxer);
}
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
static void
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
gtk_action_muxer_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
{
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
GtkActionMuxer *muxer = GTK_ACTION_MUXER (object);
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
switch (property_id)
{
case PROP_PARENT:
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
g_value_set_object (value, gtk_action_muxer_get_parent (muxer));
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
break;
Give the action muxer a widget This will be used in the future to obtain widget class actions.
2019-06-15 23:08:39 +00:00
case PROP_WIDGET:
g_value_set_object (value, muxer->widget);
break;
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}
}
static void
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
gtk_action_muxer_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
{
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
GtkActionMuxer *muxer = GTK_ACTION_MUXER (object);
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
switch (property_id)
{
case PROP_PARENT:
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
gtk_action_muxer_set_parent (muxer, g_value_get_object (value));
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
break;
Give the action muxer a widget This will be used in the future to obtain widget class actions.
2019-06-15 23:08:39 +00:00
case PROP_WIDGET:
muxer->widget = g_value_get_object (value);
break;
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}
}
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
static void
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
gtk_action_muxer_init (GtkActionMuxer *muxer)
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
{
widget: fix class private data usage to be _init() safe Before this commit, adding GtkWidgetAction to class private data would require copying the actions to each subclass as they were built or modified. This was convenient in that it is a sort of "copy on write" semantic. However, due to the way that GTypeInstance works with base _init() functions, the "g_class" pointer in GTypeInstance is updated as each _init() function is called. That means you cannot access the subclasses class private data, but only the parent class private data. If instead we use a singly linked list of GtkWidgetAction, each subclass has their own "head" yet all subclasses share the tail of the GtkWidgetAction chain. This creates one bit of complexity though. You need a stable way to know which "bit" is the "enabled" bit of the action so we can track enabled GAction state. That is easily solved by calculating the distance to the end of the chain for a given action so that base classes sort ahead of subclasses. Since the parent class always knows its parent's actions, the position is stable. A new dynamic bitarray helper also helps us avoid allocations in all the current cases (up to 64 actions per widget) and dynamically switches to malloc if that is to ever be exceeded.
2020-03-20 16:22:29 +00:00
muxer->widget_actions_disabled = _gtk_bitmask_new ();
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
}
static void
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
gtk_action_muxer_observable_iface_init (GtkActionObservableInterface *iface)
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
{
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
iface->register_observer = gtk_action_muxer_register_observer;
iface->unregister_observer = gtk_action_muxer_unregister_observer;
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
}
actionmuxer: Stop implementing GActionGroup Instead of implementing the GActionGroup interface and using its signals for propagating changes up and down the muxer hierarchy, use the GtkActionObserver mechanism. This cuts down on the signal emission overhead.
2020-07-19 05:17:23 +00:00
static void
gtk_action_muxer_observer_action_added (GtkActionObserver *observer,
GtkActionObservable *observable,
const char *action_name,
const GVariantType *parameter_type,
gboolean enabled,
GVariant *state)
actionmuxer: Add some more api We want to drop the GActionGroup interface from GtkActionMuxer, so add the necessary api directly to GtkActionMuxer itself.
2020-07-19 02:28:53 +00:00
{
action muxer: Propagate registrations further up We were pretty aggressive about not registering observers further than necessary, stopping at the first muxer that provides an action. But even though action changes further up in the tree won't be relevant in that case, we need to listen to accel changes, since they may come from higher up in the tree (e.g. when using gtk_application_set_accels_for_action with an action that is defined on a widget. So, register all the way to the top, and stop propagating action changes when we hit a muxer that provides the action.
2021-06-17 12:37:42 +00:00
if (action_muxer_query_action (GTK_ACTION_MUXER (observer), action_name,
NULL, NULL, NULL, NULL, NULL, FALSE))
return;
actionmuxer: Stop implementing GActionGroup Instead of implementing the GActionGroup interface and using its signals for propagating changes up and down the muxer hierarchy, use the GtkActionObserver mechanism. This cuts down on the signal emission overhead.
2020-07-19 05:17:23 +00:00
gtk_action_muxer_action_added (GTK_ACTION_MUXER (observer),
action_name,
parameter_type,
enabled,
state);
actionmuxer: Add some more api We want to drop the GActionGroup interface from GtkActionMuxer, so add the necessary api directly to GtkActionMuxer itself.
2020-07-19 02:28:53 +00:00
}
static void
actionmuxer: Stop implementing GActionGroup Instead of implementing the GActionGroup interface and using its signals for propagating changes up and down the muxer hierarchy, use the GtkActionObserver mechanism. This cuts down on the signal emission overhead.
2020-07-19 05:17:23 +00:00
gtk_action_muxer_observer_action_removed (GtkActionObserver *observer,
GtkActionObservable *observable,
const char *action_name)
actionmuxer: Add some more api We want to drop the GActionGroup interface from GtkActionMuxer, so add the necessary api directly to GtkActionMuxer itself.
2020-07-19 02:28:53 +00:00
{
action muxer: Propagate registrations further up We were pretty aggressive about not registering observers further than necessary, stopping at the first muxer that provides an action. But even though action changes further up in the tree won't be relevant in that case, we need to listen to accel changes, since they may come from higher up in the tree (e.g. when using gtk_application_set_accels_for_action with an action that is defined on a widget. So, register all the way to the top, and stop propagating action changes when we hit a muxer that provides the action.
2021-06-17 12:37:42 +00:00
if (action_muxer_query_action (GTK_ACTION_MUXER (observer), action_name,
NULL, NULL, NULL, NULL, NULL, FALSE))
return;
actionmuxer: Stop implementing GActionGroup Instead of implementing the GActionGroup interface and using its signals for propagating changes up and down the muxer hierarchy, use the GtkActionObserver mechanism. This cuts down on the signal emission overhead.
2020-07-19 05:17:23 +00:00
gtk_action_muxer_action_removed (GTK_ACTION_MUXER (observer), action_name);
actionmuxer: Add some more api We want to drop the GActionGroup interface from GtkActionMuxer, so add the necessary api directly to GtkActionMuxer itself.
2020-07-19 02:28:53 +00:00
}
static void
actionmuxer: Stop implementing GActionGroup Instead of implementing the GActionGroup interface and using its signals for propagating changes up and down the muxer hierarchy, use the GtkActionObserver mechanism. This cuts down on the signal emission overhead.
2020-07-19 05:17:23 +00:00
gtk_action_muxer_observer_action_enabled_changed (GtkActionObserver *observer,
GtkActionObservable *observable,
const char *action_name,
gboolean enabled)
actionmuxer: Add some more api We want to drop the GActionGroup interface from GtkActionMuxer, so add the necessary api directly to GtkActionMuxer itself.
2020-07-19 02:28:53 +00:00
{
action muxer: Propagate registrations further up We were pretty aggressive about not registering observers further than necessary, stopping at the first muxer that provides an action. But even though action changes further up in the tree won't be relevant in that case, we need to listen to accel changes, since they may come from higher up in the tree (e.g. when using gtk_application_set_accels_for_action with an action that is defined on a widget. So, register all the way to the top, and stop propagating action changes when we hit a muxer that provides the action.
2021-06-17 12:37:42 +00:00
if (action_muxer_query_action (GTK_ACTION_MUXER (observer), action_name,
NULL, NULL, NULL, NULL, NULL, FALSE))
return;
actionmuxer: Stop implementing GActionGroup Instead of implementing the GActionGroup interface and using its signals for propagating changes up and down the muxer hierarchy, use the GtkActionObserver mechanism. This cuts down on the signal emission overhead.
2020-07-19 05:17:23 +00:00
gtk_action_muxer_action_enabled_changed (GTK_ACTION_MUXER (observer), action_name, enabled);
actionmuxer: Add some more api We want to drop the GActionGroup interface from GtkActionMuxer, so add the necessary api directly to GtkActionMuxer itself.
2020-07-19 02:28:53 +00:00
}
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
static void
actionmuxer: Stop implementing GActionGroup Instead of implementing the GActionGroup interface and using its signals for propagating changes up and down the muxer hierarchy, use the GtkActionObserver mechanism. This cuts down on the signal emission overhead.
2020-07-19 05:17:23 +00:00
gtk_action_muxer_observer_action_state_changed (GtkActionObserver *observer,
GtkActionObservable *observable,
const char *action_name,
GVariant *state)
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
{
action muxer: Propagate registrations further up We were pretty aggressive about not registering observers further than necessary, stopping at the first muxer that provides an action. But even though action changes further up in the tree won't be relevant in that case, we need to listen to accel changes, since they may come from higher up in the tree (e.g. when using gtk_application_set_accels_for_action with an action that is defined on a widget. So, register all the way to the top, and stop propagating action changes when we hit a muxer that provides the action.
2021-06-17 12:37:42 +00:00
if (action_muxer_query_action (GTK_ACTION_MUXER (observer), action_name,
NULL, NULL, NULL, NULL, NULL, FALSE))
return;
actionmuxer: Stop implementing GActionGroup Instead of implementing the GActionGroup interface and using its signals for propagating changes up and down the muxer hierarchy, use the GtkActionObserver mechanism. This cuts down on the signal emission overhead.
2020-07-19 05:17:23 +00:00
gtk_action_muxer_action_state_changed (GTK_ACTION_MUXER (observer), action_name, state);
}
static void
gtk_action_muxer_observer_primary_accel_changed (GtkActionObserver *observer,
GtkActionObservable *observable,
const char *action_name,
const char *action_and_target)
{
gtk_action_muxer_primary_accel_changed (GTK_ACTION_MUXER (observer),
action_name,
action_and_target);
}
static void
gtk_action_muxer_observer_iface_init (GtkActionObserverInterface *iface)
{
iface->action_added = gtk_action_muxer_observer_action_added;
iface->action_removed = gtk_action_muxer_observer_action_removed;
iface->action_enabled_changed = gtk_action_muxer_observer_action_enabled_changed;
iface->action_state_changed = gtk_action_muxer_observer_action_state_changed;
iface->primary_accel_changed = gtk_action_muxer_observer_primary_accel_changed;
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
}
static void
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
gtk_action_muxer_class_init (GObjectClass *class)
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
{
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
class->get_property = gtk_action_muxer_get_property;
class->set_property = gtk_action_muxer_set_property;
class->finalize = gtk_action_muxer_finalize;
class->dispose = gtk_action_muxer_dispose;
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
properties[PROP_PARENT] = g_param_spec_object ("parent", "Parent",
"The parent muxer",
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
GTK_TYPE_ACTION_MUXER,
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS);
Give the action muxer a widget This will be used in the future to obtain widget class actions.
2019-06-15 23:08:39 +00:00
properties[PROP_WIDGET] = g_param_spec_object ("widget", "Widget",
"The widget that owns the muxer",
GTK_TYPE_WIDGET,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT_ONLY |
G_PARAM_STATIC_STRINGS);
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
g_object_class_install_properties (class, NUM_PROPERTIES, properties);
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
}
docs: mark gtkdoc blocks as private for internal only API
2014-01-22 02:47:34 +00:00
/*< private >
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
* gtk_action_muxer_insert:
gtk: Clean up docs syntax Replace leftover gtk-doc syntax (#Type) with backquotes.
2021-05-20 13:17:04 +00:00
* @muxer: a `GtkActionMuxer`
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
* @prefix: the prefix string for the action group
gtk: Clean up docs syntax Replace leftover gtk-doc syntax (#Type) with backquotes.
2021-05-20 13:17:04 +00:00
* @action_group: a `GActionGroup`
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
*
* Adds the actions in @action_group to the list of actions provided by
* @muxer. @prefix is prefixed to each action name, such that for each
docs: don't use <varnam>
2014-02-04 23:32:42 +00:00
* action `x` in @action_group, there is an equivalent
* action @prefix`.x` in @muxer.
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
*
docs: use proper quotes
2014-02-05 18:07:34 +00:00
* For example, if @prefix is “`app`” and @action_group
* contains an action called “`quit`”, then @muxer will
* now contain an action called “`app.quit`”.
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
*
gtk: Clean up docs syntax Replace leftover gtk-doc syntax (#Type) with backquotes.
2021-05-20 13:17:04 +00:00
* If any `GtkActionObserver`s are registered for actions in the group,
docs: use proper quotes
2014-02-05 18:07:34 +00:00
* “action_added” notifications will be emitted, as appropriate.
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
*
* @prefix must not contain a dot ('.').
Undoccommentify action muxer files
2011-12-01 11:30:10 +00:00
*/
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
void
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
gtk_action_muxer_insert (GtkActionMuxer *muxer,
Replace "gchar" with "char"
2020-07-24 18:40:36 +00:00
const char *prefix,
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
GActionGroup *action_group)
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
{
Replace "gchar" with "char"
2020-07-24 18:40:36 +00:00
char **actions;
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
Group *group;
Replace "gint" with "int"
2020-07-24 13:54:49 +00:00
int i;
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
/* TODO: diff instead of ripout and replace */
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
gtk_action_muxer_remove (muxer, prefix);
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
actionmuxer: Create observed_actions and groups on demand The vast majority of action muxers don't have observers or groups, so we can avoid the overhead of carrying all these empty hash tables.
2020-07-19 13:45:12 +00:00
if (!muxer->groups)
muxer->groups = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, gtk_action_muxer_free_group);
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
group = g_slice_new (Group);
group->muxer = muxer;
group->group = g_object_ref (action_group);
group->prefix = g_strdup (prefix);
g_hash_table_insert (muxer->groups, group->prefix, group);
actions = g_action_group_list_actions (group->group);
for (i = 0; actions[i]; i++)
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
gtk_action_muxer_action_added_to_group (group->group, actions[i], group);
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
g_strfreev (actions);
group->handler_ids[0] = g_signal_connect (group->group, "action-added",
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
G_CALLBACK (gtk_action_muxer_action_added_to_group), group);
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
group->handler_ids[1] = g_signal_connect (group->group, "action-removed",
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
G_CALLBACK (gtk_action_muxer_action_removed_from_group), group);
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
group->handler_ids[2] = g_signal_connect (group->group, "action-enabled-changed",
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
G_CALLBACK (gtk_action_muxer_group_action_enabled_changed), group);
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
group->handler_ids[3] = g_signal_connect (group->group, "action-state-changed",
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
G_CALLBACK (gtk_action_muxer_group_action_state_changed), group);
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
}
docs: mark gtkdoc blocks as private for internal only API
2014-01-22 02:47:34 +00:00
/*< private >
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
* gtk_action_muxer_remove:
gtk: Clean up docs syntax Replace leftover gtk-doc syntax (#Type) with backquotes.
2021-05-20 13:17:04 +00:00
* @muxer: a `GtkActionMuxer`
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
* @prefix: the prefix of the action group to remove
*
gtk: Clean up docs syntax Replace leftover gtk-doc syntax (#Type) with backquotes.
2021-05-20 13:17:04 +00:00
* Removes a `GActionGroup` from the `GtkActionMuxer`.
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
*
gtk: Clean up docs syntax Replace leftover gtk-doc syntax (#Type) with backquotes.
2021-05-20 13:17:04 +00:00
* If any `GtkActionObserver`s are registered for actions in the group,
docs: use proper quotes
2014-02-05 18:07:34 +00:00
* “action_removed” notifications will be emitted, as appropriate.
Undoccommentify action muxer files
2011-12-01 11:30:10 +00:00
*/
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
void
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
gtk_action_muxer_remove (GtkActionMuxer *muxer,
Replace "gchar" with "char"
2020-07-24 18:40:36 +00:00
const char *prefix)
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
{
Group *group;
actionmuxer: Create observed_actions and groups on demand The vast majority of action muxers don't have observers or groups, so we can avoid the overhead of carrying all these empty hash tables.
2020-07-19 13:45:12 +00:00
if (!muxer->groups)
return;
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
group = g_hash_table_lookup (muxer->groups, prefix);
if (group != NULL)
{
Replace "gchar" with "char"
2020-07-24 18:40:36 +00:00
char **actions;
Replace "gint" with "int"
2020-07-24 13:54:49 +00:00
int i;
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
g_hash_table_steal (muxer->groups, prefix);
actions = g_action_group_list_actions (group->group);
for (i = 0; actions[i]; i++)
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
gtk_action_muxer_action_removed_from_group (group->group, actions[i], group);
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
g_strfreev (actions);
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
gtk_action_muxer_free_group (group);
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
}
}
docs: mark gtkdoc blocks as private for internal only API
2014-01-22 02:47:34 +00:00
/*< private >
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
* gtk_action_muxer_new:
Give the action muxer a widget This will be used in the future to obtain widget class actions.
2019-06-15 23:08:39 +00:00
* @widget: the widget to which the muxer belongs
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
*
gtk: Clean up docs syntax Replace leftover gtk-doc syntax (#Type) with backquotes.
2021-05-20 13:17:04 +00:00
* Creates a new `GtkActionMuxer`.
Undoccommentify action muxer files
2011-12-01 11:30:10 +00:00
*/
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
GtkActionMuxer *
widget: fix class private data usage to be _init() safe Before this commit, adding GtkWidgetAction to class private data would require copying the actions to each subclass as they were built or modified. This was convenient in that it is a sort of "copy on write" semantic. However, due to the way that GTypeInstance works with base _init() functions, the "g_class" pointer in GTypeInstance is updated as each _init() function is called. That means you cannot access the subclasses class private data, but only the parent class private data. If instead we use a singly linked list of GtkWidgetAction, each subclass has their own "head" yet all subclasses share the tail of the GtkWidgetAction chain. This creates one bit of complexity though. You need a stable way to know which "bit" is the "enabled" bit of the action so we can track enabled GAction state. That is easily solved by calculating the distance to the end of the chain for a given action so that base classes sort ahead of subclasses. Since the parent class always knows its parent's actions, the position is stable. A new dynamic bitarray helper also helps us avoid allocations in all the current cases (up to 64 actions per widget) and dynamically switches to malloc if that is to ever be exceeded.
2020-03-20 16:22:29 +00:00
gtk_action_muxer_new (GtkWidget *widget)
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
{
Give the action muxer a widget This will be used in the future to obtain widget class actions.
2019-06-15 23:08:39 +00:00
return g_object_new (GTK_TYPE_ACTION_MUXER,
"widget", widget,
NULL);
add GActionMuxer and observer interfaces These were destined for GLib, but they don't really make sense as a public API. Instead, we'll copy/paste them around between the various codebases that need to render menus.
2011-11-30 14:33:03 +00:00
}
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
docs: mark gtkdoc blocks as private for internal only API
2014-01-22 02:47:34 +00:00
/*< private >
action stuff: Introspection fixes
2013-05-09 19:28:57 +00:00
* gtk_action_muxer_get_parent:
gtk: Clean up docs syntax Replace leftover gtk-doc syntax (#Type) with backquotes.
2021-05-20 13:17:04 +00:00
* @muxer: a `GtkActionMuxer`
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
*
action stuff: Introspection fixes
2013-05-09 19:28:57 +00:00
* Returns: (transfer none): the parent of @muxer, or NULL.
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
*/
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
GtkActionMuxer *
gtk_action_muxer_get_parent (GtkActionMuxer *muxer)
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
{
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
g_return_val_if_fail (GTK_IS_ACTION_MUXER (muxer), NULL);
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
return muxer->parent;
}
docs: mark gtkdoc blocks as private for internal only API
2014-01-22 02:47:34 +00:00
/*< private >
action stuff: Introspection fixes
2013-05-09 19:28:57 +00:00
* gtk_action_muxer_set_parent:
gtk: Clean up docs syntax Replace leftover gtk-doc syntax (#Type) with backquotes.
2021-05-20 13:17:04 +00:00
* @muxer: a `GtkActionMuxer`
* @parent: (nullable): the new parent `GtkActionMuxer`
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
*
* Sets the parent of @muxer to @parent.
*/
void
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
gtk_action_muxer_set_parent (GtkActionMuxer *muxer,
GtkActionMuxer *parent)
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
{
action stuff: stop abusing GLib's namespace Rename our internal GActionMuxer, GActionObserver and GActionObservable classes and interfaces to have names in our own namespace. These classes were originally intended for GIO but turned out to be too special-purpose to be useful there, so we never made them public API but have just been copying them around (without bothering to properly rename them). Now that other people will be copying them out of Gtk, it's even more important to prevent this namespace abuse from spreading further.
2013-05-09 18:15:51 +00:00
g_return_if_fail (GTK_IS_ACTION_MUXER (muxer));
g_return_if_fail (parent == NULL || GTK_IS_ACTION_MUXER (parent));
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
if (muxer->parent == parent)
return;
if (muxer->parent != NULL)
{
Speed up action muxer setup We don't need to duplicate all these action names and emit all these signals if nobody is listening.
2020-04-24 04:52:17 +00:00
notify_observers_removed (muxer, muxer->parent);
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
g_object_unref (muxer->parent);
}
muxer->parent = parent;
if (muxer->parent != NULL)
{
g_object_ref (muxer->parent);
Speed up action muxer setup We don't need to duplicate all these action names and emit all these signals if nobody is listening.
2020-04-24 04:52:17 +00:00
notify_observers_added (muxer, muxer->parent);
GActionMuxer: add support for parent muxers If a muxer does not contain an action group with the given prefix, chain up to the "parent" muxer to look for it. This initial implementation is rather inefficient. It will lead to changes on action groups associated with parent muxers being broadcast to all children (regardless of if anybody there is interested or not). An optimised version will follow soon.
2012-08-17 17:16:51 +00:00
}
g_object_notify_by_pspec (G_OBJECT (muxer), properties[PROP_PARENT]);
}
GtkActionMuxer: store primary accels Reuse the existing infrastructure in GtkActionMuxer for propagation of accelerator information: in particular, what accel label ought to appear on menu items for a particular action and target. This is a good idea because we want accels to travel along with the actions that they're tied to and reusing GtkActionMuxer will allow us to do that without creating another hierarchy of a different class for the sole purpose of filling in accel labels on menu items. Doing it this ways also allows those who copy/paste GtkActionMuxer to insert the accels for themselves. Add a new method on the GtkActionObserver interface to report changes. This patch introduces a new concept: "action and target" notation for actions. This format looks like so: "'target'|app.action" or for non-targeted actions: "|app.action" and it is used over a number of possible alternative formats for some good reasons: - it's very easy to get a nul-terminated action name out of this format when we need it, by using strrchr('|') + 1 - we can also get the target out of it using g_variant_parse() because this function takes a pointer to a 'limit' character that is not parsed past: we use the '|' for this - it's extremely easy to hash on this format (just use a normal string hash) vs. attempting to hash on a string plus a GVariant A close contender was to use detailed action strings here, but these are not used for two reasons: - it's not possible to easily get the action name or target out of the strings without more work than the "action and target" format requires - we still intend to use detailed action strings on API (since they are a lot nicer to look at) but detailed action strings can be given in non-canonical forms (eg: 'foo::bar' and 'foo("bar")' are equivalent) so we'd have to go through a normalisation step anyway. Since we're doing that already, we may as well convert to a more convenient internal format. This new "action and target" format is going to start appearing in a lot more places as action descriptions are introduced. I suspect that nobody is using '|' in their action names, but in case I am proven wrong, we can always switch to using something more exotic as a separator character (such as '\x01' or '\xff' or the like).
2013-07-10 02:37:17 +00:00
void
gtk_action_muxer_set_primary_accel (GtkActionMuxer *muxer,
actionmuxer: Use an array for accels We have a lot of accels across all the muxers, but the vast majority has just one or two, so an array is going to be smaller and faster for this.
2020-07-19 19:11:35 +00:00
const char *action_and_target,
const char *primary_accel)
GtkActionMuxer: store primary accels Reuse the existing infrastructure in GtkActionMuxer for propagation of accelerator information: in particular, what accel label ought to appear on menu items for a particular action and target. This is a good idea because we want accels to travel along with the actions that they're tied to and reusing GtkActionMuxer will allow us to do that without creating another hierarchy of a different class for the sole purpose of filling in accel labels on menu items. Doing it this ways also allows those who copy/paste GtkActionMuxer to insert the accels for themselves. Add a new method on the GtkActionObserver interface to report changes. This patch introduces a new concept: "action and target" notation for actions. This format looks like so: "'target'|app.action" or for non-targeted actions: "|app.action" and it is used over a number of possible alternative formats for some good reasons: - it's very easy to get a nul-terminated action name out of this format when we need it, by using strrchr('|') + 1 - we can also get the target out of it using g_variant_parse() because this function takes a pointer to a 'limit' character that is not parsed past: we use the '|' for this - it's extremely easy to hash on this format (just use a normal string hash) vs. attempting to hash on a string plus a GVariant A close contender was to use detailed action strings here, but these are not used for two reasons: - it's not possible to easily get the action name or target out of the strings without more work than the "action and target" format requires - we still intend to use detailed action strings on API (since they are a lot nicer to look at) but detailed action strings can be given in non-canonical forms (eg: 'foo::bar' and 'foo("bar")' are equivalent) so we'd have to go through a normalisation step anyway. Since we're doing that already, we may as well convert to a more convenient internal format. This new "action and target" format is going to start appearing in a lot more places as action descriptions are introduced. I suspect that nobody is using '|' in their action names, but in case I am proven wrong, we can always switch to using something more exotic as a separator character (such as '\x01' or '\xff' or the like).
2013-07-10 02:37:17 +00:00
{
if (primary_accel)
actionmuxer: Use an array for accels We have a lot of accels across all the muxers, but the vast majority has just one or two, so an array is going to be smaller and faster for this.
2020-07-19 19:11:35 +00:00
gtk_accels_replace (&muxer->primary_accels, action_and_target, primary_accel);
GtkActionMuxer: store primary accels Reuse the existing infrastructure in GtkActionMuxer for propagation of accelerator information: in particular, what accel label ought to appear on menu items for a particular action and target. This is a good idea because we want accels to travel along with the actions that they're tied to and reusing GtkActionMuxer will allow us to do that without creating another hierarchy of a different class for the sole purpose of filling in accel labels on menu items. Doing it this ways also allows those who copy/paste GtkActionMuxer to insert the accels for themselves. Add a new method on the GtkActionObserver interface to report changes. This patch introduces a new concept: "action and target" notation for actions. This format looks like so: "'target'|app.action" or for non-targeted actions: "|app.action" and it is used over a number of possible alternative formats for some good reasons: - it's very easy to get a nul-terminated action name out of this format when we need it, by using strrchr('|') + 1 - we can also get the target out of it using g_variant_parse() because this function takes a pointer to a 'limit' character that is not parsed past: we use the '|' for this - it's extremely easy to hash on this format (just use a normal string hash) vs. attempting to hash on a string plus a GVariant A close contender was to use detailed action strings here, but these are not used for two reasons: - it's not possible to easily get the action name or target out of the strings without more work than the "action and target" format requires - we still intend to use detailed action strings on API (since they are a lot nicer to look at) but detailed action strings can be given in non-canonical forms (eg: 'foo::bar' and 'foo("bar")' are equivalent) so we'd have to go through a normalisation step anyway. Since we're doing that already, we may as well convert to a more convenient internal format. This new "action and target" format is going to start appearing in a lot more places as action descriptions are introduced. I suspect that nobody is using '|' in their action names, but in case I am proven wrong, we can always switch to using something more exotic as a separator character (such as '\x01' or '\xff' or the like).
2013-07-10 02:37:17 +00:00
else
actionmuxer: Use an array for accels We have a lot of accels across all the muxers, but the vast majority has just one or two, so an array is going to be smaller and faster for this.
2020-07-19 19:11:35 +00:00
gtk_accels_remove (&muxer->primary_accels, action_and_target);
GtkActionMuxer: store primary accels Reuse the existing infrastructure in GtkActionMuxer for propagation of accelerator information: in particular, what accel label ought to appear on menu items for a particular action and target. This is a good idea because we want accels to travel along with the actions that they're tied to and reusing GtkActionMuxer will allow us to do that without creating another hierarchy of a different class for the sole purpose of filling in accel labels on menu items. Doing it this ways also allows those who copy/paste GtkActionMuxer to insert the accels for themselves. Add a new method on the GtkActionObserver interface to report changes. This patch introduces a new concept: "action and target" notation for actions. This format looks like so: "'target'|app.action" or for non-targeted actions: "|app.action" and it is used over a number of possible alternative formats for some good reasons: - it's very easy to get a nul-terminated action name out of this format when we need it, by using strrchr('|') + 1 - we can also get the target out of it using g_variant_parse() because this function takes a pointer to a 'limit' character that is not parsed past: we use the '|' for this - it's extremely easy to hash on this format (just use a normal string hash) vs. attempting to hash on a string plus a GVariant A close contender was to use detailed action strings here, but these are not used for two reasons: - it's not possible to easily get the action name or target out of the strings without more work than the "action and target" format requires - we still intend to use detailed action strings on API (since they are a lot nicer to look at) but detailed action strings can be given in non-canonical forms (eg: 'foo::bar' and 'foo("bar")' are equivalent) so we'd have to go through a normalisation step anyway. Since we're doing that already, we may as well convert to a more convenient internal format. This new "action and target" format is going to start appearing in a lot more places as action descriptions are introduced. I suspect that nobody is using '|' in their action names, but in case I am proven wrong, we can always switch to using something more exotic as a separator character (such as '\x01' or '\xff' or the like).
2013-07-10 02:37:17 +00:00
gtk_action_muxer_primary_accel_changed (muxer, NULL, action_and_target);
}
Replace "gchar" with "char"
2020-07-24 18:40:36 +00:00
const char *
GtkActionMuxer: store primary accels Reuse the existing infrastructure in GtkActionMuxer for propagation of accelerator information: in particular, what accel label ought to appear on menu items for a particular action and target. This is a good idea because we want accels to travel along with the actions that they're tied to and reusing GtkActionMuxer will allow us to do that without creating another hierarchy of a different class for the sole purpose of filling in accel labels on menu items. Doing it this ways also allows those who copy/paste GtkActionMuxer to insert the accels for themselves. Add a new method on the GtkActionObserver interface to report changes. This patch introduces a new concept: "action and target" notation for actions. This format looks like so: "'target'|app.action" or for non-targeted actions: "|app.action" and it is used over a number of possible alternative formats for some good reasons: - it's very easy to get a nul-terminated action name out of this format when we need it, by using strrchr('|') + 1 - we can also get the target out of it using g_variant_parse() because this function takes a pointer to a 'limit' character that is not parsed past: we use the '|' for this - it's extremely easy to hash on this format (just use a normal string hash) vs. attempting to hash on a string plus a GVariant A close contender was to use detailed action strings here, but these are not used for two reasons: - it's not possible to easily get the action name or target out of the strings without more work than the "action and target" format requires - we still intend to use detailed action strings on API (since they are a lot nicer to look at) but detailed action strings can be given in non-canonical forms (eg: 'foo::bar' and 'foo("bar")' are equivalent) so we'd have to go through a normalisation step anyway. Since we're doing that already, we may as well convert to a more convenient internal format. This new "action and target" format is going to start appearing in a lot more places as action descriptions are introduced. I suspect that nobody is using '|' in their action names, but in case I am proven wrong, we can always switch to using something more exotic as a separator character (such as '\x01' or '\xff' or the like).
2013-07-10 02:37:17 +00:00
gtk_action_muxer_get_primary_accel (GtkActionMuxer *muxer,
Replace "gchar" with "char"
2020-07-24 18:40:36 +00:00
const char *action_and_target)
GtkActionMuxer: store primary accels Reuse the existing infrastructure in GtkActionMuxer for propagation of accelerator information: in particular, what accel label ought to appear on menu items for a particular action and target. This is a good idea because we want accels to travel along with the actions that they're tied to and reusing GtkActionMuxer will allow us to do that without creating another hierarchy of a different class for the sole purpose of filling in accel labels on menu items. Doing it this ways also allows those who copy/paste GtkActionMuxer to insert the accels for themselves. Add a new method on the GtkActionObserver interface to report changes. This patch introduces a new concept: "action and target" notation for actions. This format looks like so: "'target'|app.action" or for non-targeted actions: "|app.action" and it is used over a number of possible alternative formats for some good reasons: - it's very easy to get a nul-terminated action name out of this format when we need it, by using strrchr('|') + 1 - we can also get the target out of it using g_variant_parse() because this function takes a pointer to a 'limit' character that is not parsed past: we use the '|' for this - it's extremely easy to hash on this format (just use a normal string hash) vs. attempting to hash on a string plus a GVariant A close contender was to use detailed action strings here, but these are not used for two reasons: - it's not possible to easily get the action name or target out of the strings without more work than the "action and target" format requires - we still intend to use detailed action strings on API (since they are a lot nicer to look at) but detailed action strings can be given in non-canonical forms (eg: 'foo::bar' and 'foo("bar")' are equivalent) so we'd have to go through a normalisation step anyway. Since we're doing that already, we may as well convert to a more convenient internal format. This new "action and target" format is going to start appearing in a lot more places as action descriptions are introduced. I suspect that nobody is using '|' in their action names, but in case I am proven wrong, we can always switch to using something more exotic as a separator character (such as '\x01' or '\xff' or the like).
2013-07-10 02:37:17 +00:00
{
actionmuxer: Use an array for accels We have a lot of accels across all the muxers, but the vast majority has just one or two, so an array is going to be smaller and faster for this.
2020-07-19 19:11:35 +00:00
guint position;
GtkActionMuxer: store primary accels Reuse the existing infrastructure in GtkActionMuxer for propagation of accelerator information: in particular, what accel label ought to appear on menu items for a particular action and target. This is a good idea because we want accels to travel along with the actions that they're tied to and reusing GtkActionMuxer will allow us to do that without creating another hierarchy of a different class for the sole purpose of filling in accel labels on menu items. Doing it this ways also allows those who copy/paste GtkActionMuxer to insert the accels for themselves. Add a new method on the GtkActionObserver interface to report changes. This patch introduces a new concept: "action and target" notation for actions. This format looks like so: "'target'|app.action" or for non-targeted actions: "|app.action" and it is used over a number of possible alternative formats for some good reasons: - it's very easy to get a nul-terminated action name out of this format when we need it, by using strrchr('|') + 1 - we can also get the target out of it using g_variant_parse() because this function takes a pointer to a 'limit' character that is not parsed past: we use the '|' for this - it's extremely easy to hash on this format (just use a normal string hash) vs. attempting to hash on a string plus a GVariant A close contender was to use detailed action strings here, but these are not used for two reasons: - it's not possible to easily get the action name or target out of the strings without more work than the "action and target" format requires - we still intend to use detailed action strings on API (since they are a lot nicer to look at) but detailed action strings can be given in non-canonical forms (eg: 'foo::bar' and 'foo("bar")' are equivalent) so we'd have to go through a normalisation step anyway. Since we're doing that already, we may as well convert to a more convenient internal format. This new "action and target" format is going to start appearing in a lot more places as action descriptions are introduced. I suspect that nobody is using '|' in their action names, but in case I am proven wrong, we can always switch to using something more exotic as a separator character (such as '\x01' or '\xff' or the like).
2013-07-10 02:37:17 +00:00
actionmuxer: Use an array for accels We have a lot of accels across all the muxers, but the vast majority has just one or two, so an array is going to be smaller and faster for this.
2020-07-19 19:11:35 +00:00
position = gtk_accels_find (&muxer->primary_accels, action_and_target);
if (position < G_MAXUINT)
return gtk_accels_index (&muxer->primary_accels, position)->accel;
GtkActionMuxer: store primary accels Reuse the existing infrastructure in GtkActionMuxer for propagation of accelerator information: in particular, what accel label ought to appear on menu items for a particular action and target. This is a good idea because we want accels to travel along with the actions that they're tied to and reusing GtkActionMuxer will allow us to do that without creating another hierarchy of a different class for the sole purpose of filling in accel labels on menu items. Doing it this ways also allows those who copy/paste GtkActionMuxer to insert the accels for themselves. Add a new method on the GtkActionObserver interface to report changes. This patch introduces a new concept: "action and target" notation for actions. This format looks like so: "'target'|app.action" or for non-targeted actions: "|app.action" and it is used over a number of possible alternative formats for some good reasons: - it's very easy to get a nul-terminated action name out of this format when we need it, by using strrchr('|') + 1 - we can also get the target out of it using g_variant_parse() because this function takes a pointer to a 'limit' character that is not parsed past: we use the '|' for this - it's extremely easy to hash on this format (just use a normal string hash) vs. attempting to hash on a string plus a GVariant A close contender was to use detailed action strings here, but these are not used for two reasons: - it's not possible to easily get the action name or target out of the strings without more work than the "action and target" format requires - we still intend to use detailed action strings on API (since they are a lot nicer to look at) but detailed action strings can be given in non-canonical forms (eg: 'foo::bar' and 'foo("bar")' are equivalent) so we'd have to go through a normalisation step anyway. Since we're doing that already, we may as well convert to a more convenient internal format. This new "action and target" format is going to start appearing in a lot more places as action descriptions are introduced. I suspect that nobody is using '|' in their action names, but in case I am proven wrong, we can always switch to using something more exotic as a separator character (such as '\x01' or '\xff' or the like).
2013-07-10 02:37:17 +00:00
if (!muxer->parent)
return NULL;
return gtk_action_muxer_get_primary_accel (muxer->parent, action_and_target);
}
Replace "gchar" with "char"
2020-07-24 18:40:36 +00:00
char *
gtk_print_action_and_target (const char *action_namespace,
const char *action_name,
GtkActionMuxer: store primary accels Reuse the existing infrastructure in GtkActionMuxer for propagation of accelerator information: in particular, what accel label ought to appear on menu items for a particular action and target. This is a good idea because we want accels to travel along with the actions that they're tied to and reusing GtkActionMuxer will allow us to do that without creating another hierarchy of a different class for the sole purpose of filling in accel labels on menu items. Doing it this ways also allows those who copy/paste GtkActionMuxer to insert the accels for themselves. Add a new method on the GtkActionObserver interface to report changes. This patch introduces a new concept: "action and target" notation for actions. This format looks like so: "'target'|app.action" or for non-targeted actions: "|app.action" and it is used over a number of possible alternative formats for some good reasons: - it's very easy to get a nul-terminated action name out of this format when we need it, by using strrchr('|') + 1 - we can also get the target out of it using g_variant_parse() because this function takes a pointer to a 'limit' character that is not parsed past: we use the '|' for this - it's extremely easy to hash on this format (just use a normal string hash) vs. attempting to hash on a string plus a GVariant A close contender was to use detailed action strings here, but these are not used for two reasons: - it's not possible to easily get the action name or target out of the strings without more work than the "action and target" format requires - we still intend to use detailed action strings on API (since they are a lot nicer to look at) but detailed action strings can be given in non-canonical forms (eg: 'foo::bar' and 'foo("bar")' are equivalent) so we'd have to go through a normalisation step anyway. Since we're doing that already, we may as well convert to a more convenient internal format. This new "action and target" format is going to start appearing in a lot more places as action descriptions are introduced. I suspect that nobody is using '|' in their action names, but in case I am proven wrong, we can always switch to using something more exotic as a separator character (such as '\x01' or '\xff' or the like).
2013-07-10 02:37:17 +00:00
GVariant *target)
{
GString *result;
Use g_return_val_if_fail where return value needed. https://bugzilla.gnome.org/show_bug.cgi?id=710987
2013-10-27 21:36:32 +00:00
g_return_val_if_fail (strchr (action_name, '|') == NULL, NULL);
g_return_val_if_fail (action_namespace == NULL || strchr (action_namespace, '|') == NULL, NULL);
GtkActionMuxer: store primary accels Reuse the existing infrastructure in GtkActionMuxer for propagation of accelerator information: in particular, what accel label ought to appear on menu items for a particular action and target. This is a good idea because we want accels to travel along with the actions that they're tied to and reusing GtkActionMuxer will allow us to do that without creating another hierarchy of a different class for the sole purpose of filling in accel labels on menu items. Doing it this ways also allows those who copy/paste GtkActionMuxer to insert the accels for themselves. Add a new method on the GtkActionObserver interface to report changes. This patch introduces a new concept: "action and target" notation for actions. This format looks like so: "'target'|app.action" or for non-targeted actions: "|app.action" and it is used over a number of possible alternative formats for some good reasons: - it's very easy to get a nul-terminated action name out of this format when we need it, by using strrchr('|') + 1 - we can also get the target out of it using g_variant_parse() because this function takes a pointer to a 'limit' character that is not parsed past: we use the '|' for this - it's extremely easy to hash on this format (just use a normal string hash) vs. attempting to hash on a string plus a GVariant A close contender was to use detailed action strings here, but these are not used for two reasons: - it's not possible to easily get the action name or target out of the strings without more work than the "action and target" format requires - we still intend to use detailed action strings on API (since they are a lot nicer to look at) but detailed action strings can be given in non-canonical forms (eg: 'foo::bar' and 'foo("bar")' are equivalent) so we'd have to go through a normalisation step anyway. Since we're doing that already, we may as well convert to a more convenient internal format. This new "action and target" format is going to start appearing in a lot more places as action descriptions are introduced. I suspect that nobody is using '|' in their action names, but in case I am proven wrong, we can always switch to using something more exotic as a separator character (such as '\x01' or '\xff' or the like).
2013-07-10 02:37:17 +00:00
result = g_string_new (NULL);
if (target)
g_variant_print_string (target, result, TRUE);
g_string_append_c (result, '|');
if (action_namespace)
{
g_string_append (result, action_namespace);
g_string_append_c (result, '.');
}
g_string_append (result, action_name);
return g_string_free (result, FALSE);
}
GtkActionMuxer: Add getters Add a way to enumerate all prefixes, and to get the action group for a prefix. https://bugzilla.gnome.org/show_bug.cgi?id=730095
2014-05-14 00:27:58 +00:00
Replace "gchar" with "char"
2020-07-24 18:40:36 +00:00
char *
gtk_normalise_detailed_action_name (const char *detailed_action_name)
app: share function to normalise detailed action name Put the function in gtkactionmuxer.c, where gtk_print_action_and_target() is implemented. https://bugzilla.gnome.org/show_bug.cgi?id=764879
2016-04-20 15:13:26 +00:00
{
GError *error = NULL;
Replace "gchar" with "char"
2020-07-24 18:40:36 +00:00
char *action_and_target;
char *action_name;
app: share function to normalise detailed action name Put the function in gtkactionmuxer.c, where gtk_print_action_and_target() is implemented. https://bugzilla.gnome.org/show_bug.cgi?id=764879
2016-04-20 15:13:26 +00:00
GVariant *target;
g_action_parse_detailed_name (detailed_action_name, &action_name, &target, &error);
g_assert_no_error (error);
action_and_target = gtk_print_action_and_target (NULL, action_name, target);
if (target)
g_variant_unref (target);
g_free (action_name);
return action_and_target;
}
action muxer: Add some convenience api Instead of duplicating this code in multiple places, add an api to look up an action group for a prefixed name, and return the unprefixed name at the same time.
2019-06-14 17:41:45 +00:00
Reference in New Issue Copy Permalink