forked from AuroraMiddleware/gtk
773 lines
24 KiB
C
773 lines
24 KiB
C
/* gtkshortcutsshortcut.c
|
|
*
|
|
* Copyright (C) 2015 Christian Hergert <christian@hergert.me>
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Library General Public License as
|
|
* published by the Free Software Foundation; either version 2 of the
|
|
* License, 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
|
|
* Library General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Library General Public
|
|
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include "gtkshortcutsshortcutprivate.h"
|
|
|
|
#include "gtkimage.h"
|
|
#include "gtkbox.h"
|
|
#include "gtkintl.h"
|
|
#include "gtklabel.h"
|
|
#include "gtkprivate.h"
|
|
#include "gtkwidgetprivate.h"
|
|
#include "gtkshortcutlabel.h"
|
|
#include "gtkshortcutswindowprivate.h"
|
|
#include "gtksizegroup.h"
|
|
#include "gtktypebuiltins.h"
|
|
|
|
/**
|
|
* SECTION:gtkshortcutsshortcut
|
|
* @Title: GtkShortcutsShortcut
|
|
* @Short_description: Represents a keyboard shortcut in a GtkShortcutsWindow
|
|
*
|
|
* A GtkShortcutsShortcut represents a single keyboard shortcut or gesture
|
|
* with a short text. This widget is only meant to be used with #GtkShortcutsWindow.
|
|
*/
|
|
|
|
struct _GtkShortcutsShortcut
|
|
{
|
|
GtkWidget parent_instance;
|
|
|
|
GtkBox *box;
|
|
GtkImage *image;
|
|
GtkShortcutLabel *accelerator;
|
|
GtkLabel *title;
|
|
GtkLabel *subtitle;
|
|
GtkLabel *title_box;
|
|
|
|
GtkSizeGroup *accel_size_group;
|
|
GtkSizeGroup *title_size_group;
|
|
|
|
gboolean subtitle_set;
|
|
gboolean icon_set;
|
|
GtkTextDirection direction;
|
|
char *action_name;
|
|
GtkShortcutType shortcut_type;
|
|
};
|
|
|
|
struct _GtkShortcutsShortcutClass
|
|
{
|
|
GtkWidgetClass parent_class;
|
|
};
|
|
|
|
G_DEFINE_TYPE (GtkShortcutsShortcut, gtk_shortcuts_shortcut, GTK_TYPE_WIDGET)
|
|
|
|
enum {
|
|
PROP_0,
|
|
PROP_ACCELERATOR,
|
|
PROP_ICON,
|
|
PROP_ICON_SET,
|
|
PROP_TITLE,
|
|
PROP_SUBTITLE,
|
|
PROP_SUBTITLE_SET,
|
|
PROP_ACCEL_SIZE_GROUP,
|
|
PROP_TITLE_SIZE_GROUP,
|
|
PROP_DIRECTION,
|
|
PROP_SHORTCUT_TYPE,
|
|
PROP_ACTION_NAME,
|
|
LAST_PROP
|
|
};
|
|
|
|
static GParamSpec *properties[LAST_PROP];
|
|
|
|
static void
|
|
gtk_shortcuts_shortcut_set_accelerator (GtkShortcutsShortcut *self,
|
|
const char *accelerator)
|
|
{
|
|
gtk_shortcut_label_set_accelerator (self->accelerator, accelerator);
|
|
}
|
|
|
|
static void
|
|
gtk_shortcuts_shortcut_set_accel_size_group (GtkShortcutsShortcut *self,
|
|
GtkSizeGroup *group)
|
|
{
|
|
if (self->accel_size_group)
|
|
{
|
|
gtk_size_group_remove_widget (self->accel_size_group, GTK_WIDGET (self->accelerator));
|
|
gtk_size_group_remove_widget (self->accel_size_group, GTK_WIDGET (self->image));
|
|
}
|
|
|
|
if (group)
|
|
{
|
|
gtk_size_group_add_widget (group, GTK_WIDGET (self->accelerator));
|
|
gtk_size_group_add_widget (group, GTK_WIDGET (self->image));
|
|
}
|
|
|
|
g_set_object (&self->accel_size_group, group);
|
|
}
|
|
|
|
static void
|
|
gtk_shortcuts_shortcut_set_title_size_group (GtkShortcutsShortcut *self,
|
|
GtkSizeGroup *group)
|
|
{
|
|
if (self->title_size_group)
|
|
gtk_size_group_remove_widget (self->title_size_group, GTK_WIDGET (self->title_box));
|
|
if (group)
|
|
gtk_size_group_add_widget (group, GTK_WIDGET (self->title_box));
|
|
|
|
g_set_object (&self->title_size_group, group);
|
|
}
|
|
|
|
static void
|
|
update_subtitle_from_type (GtkShortcutsShortcut *self)
|
|
{
|
|
const char *subtitle;
|
|
|
|
if (self->subtitle_set)
|
|
return;
|
|
|
|
switch (self->shortcut_type)
|
|
{
|
|
case GTK_SHORTCUT_ACCELERATOR:
|
|
case GTK_SHORTCUT_GESTURE:
|
|
subtitle = NULL;
|
|
break;
|
|
|
|
case GTK_SHORTCUT_GESTURE_PINCH:
|
|
subtitle = _("Two finger pinch");
|
|
break;
|
|
|
|
case GTK_SHORTCUT_GESTURE_STRETCH:
|
|
subtitle = _("Two finger stretch");
|
|
break;
|
|
|
|
case GTK_SHORTCUT_GESTURE_ROTATE_CLOCKWISE:
|
|
subtitle = _("Rotate clockwise");
|
|
break;
|
|
|
|
case GTK_SHORTCUT_GESTURE_ROTATE_COUNTERCLOCKWISE:
|
|
subtitle = _("Rotate counterclockwise");
|
|
break;
|
|
|
|
case GTK_SHORTCUT_GESTURE_TWO_FINGER_SWIPE_LEFT:
|
|
subtitle = _("Two finger swipe left");
|
|
break;
|
|
|
|
case GTK_SHORTCUT_GESTURE_TWO_FINGER_SWIPE_RIGHT:
|
|
subtitle = _("Two finger swipe right");
|
|
break;
|
|
|
|
case GTK_SHORTCUT_GESTURE_SWIPE_LEFT:
|
|
subtitle = _("Swipe left");
|
|
break;
|
|
|
|
case GTK_SHORTCUT_GESTURE_SWIPE_RIGHT:
|
|
subtitle = _("Swipe right");
|
|
break;
|
|
|
|
default:
|
|
subtitle = NULL;
|
|
break;
|
|
}
|
|
|
|
gtk_label_set_label (self->subtitle, subtitle);
|
|
gtk_widget_set_visible (GTK_WIDGET (self->subtitle), subtitle != NULL);
|
|
g_object_notify (G_OBJECT (self), "subtitle");
|
|
}
|
|
|
|
static void
|
|
gtk_shortcuts_shortcut_set_subtitle_set (GtkShortcutsShortcut *self,
|
|
gboolean subtitle_set)
|
|
{
|
|
if (self->subtitle_set != subtitle_set)
|
|
{
|
|
self->subtitle_set = subtitle_set;
|
|
g_object_notify (G_OBJECT (self), "subtitle-set");
|
|
}
|
|
update_subtitle_from_type (self);
|
|
}
|
|
|
|
static void
|
|
gtk_shortcuts_shortcut_set_subtitle (GtkShortcutsShortcut *self,
|
|
const char *subtitle)
|
|
{
|
|
gtk_label_set_label (self->subtitle, subtitle);
|
|
gtk_widget_set_visible (GTK_WIDGET (self->subtitle), subtitle && subtitle[0]);
|
|
gtk_shortcuts_shortcut_set_subtitle_set (self, subtitle && subtitle[0]);
|
|
|
|
g_object_notify (G_OBJECT (self), "subtitle");
|
|
}
|
|
|
|
static void
|
|
update_icon_from_type (GtkShortcutsShortcut *self)
|
|
{
|
|
GIcon *icon;
|
|
|
|
if (self->icon_set)
|
|
return;
|
|
|
|
switch (self->shortcut_type)
|
|
{
|
|
case GTK_SHORTCUT_GESTURE_PINCH:
|
|
icon = g_themed_icon_new ("gesture-pinch-symbolic");
|
|
break;
|
|
|
|
case GTK_SHORTCUT_GESTURE_STRETCH:
|
|
icon = g_themed_icon_new ("gesture-stretch-symbolic");
|
|
break;
|
|
|
|
case GTK_SHORTCUT_GESTURE_ROTATE_CLOCKWISE:
|
|
icon = g_themed_icon_new ("gesture-rotate-clockwise-symbolic");
|
|
break;
|
|
|
|
case GTK_SHORTCUT_GESTURE_ROTATE_COUNTERCLOCKWISE:
|
|
icon = g_themed_icon_new ("gesture-rotate-anticlockwise-symbolic");
|
|
break;
|
|
|
|
case GTK_SHORTCUT_GESTURE_TWO_FINGER_SWIPE_LEFT:
|
|
icon = g_themed_icon_new ("gesture-two-finger-swipe-left-symbolic");
|
|
break;
|
|
|
|
case GTK_SHORTCUT_GESTURE_TWO_FINGER_SWIPE_RIGHT:
|
|
icon = g_themed_icon_new ("gesture-two-finger-swipe-right-symbolic");
|
|
break;
|
|
|
|
case GTK_SHORTCUT_GESTURE_SWIPE_LEFT:
|
|
icon = g_themed_icon_new ("gesture-swipe-left-symbolic");
|
|
break;
|
|
|
|
case GTK_SHORTCUT_GESTURE_SWIPE_RIGHT:
|
|
icon = g_themed_icon_new ("gesture-swipe-right-symbolic");
|
|
break;
|
|
|
|
case GTK_SHORTCUT_ACCELERATOR:
|
|
case GTK_SHORTCUT_GESTURE:
|
|
default:
|
|
icon = NULL;
|
|
break;
|
|
}
|
|
|
|
if (icon)
|
|
{
|
|
gtk_image_set_from_gicon (self->image, icon);
|
|
gtk_image_set_pixel_size (self->image, 64);
|
|
g_object_unref (icon);
|
|
}
|
|
}
|
|
|
|
static void
|
|
gtk_shortcuts_shortcut_set_icon_set (GtkShortcutsShortcut *self,
|
|
gboolean icon_set)
|
|
{
|
|
if (self->icon_set != icon_set)
|
|
{
|
|
self->icon_set = icon_set;
|
|
g_object_notify (G_OBJECT (self), "icon-set");
|
|
}
|
|
update_icon_from_type (self);
|
|
}
|
|
|
|
static void
|
|
gtk_shortcuts_shortcut_set_icon (GtkShortcutsShortcut *self,
|
|
GIcon *gicon)
|
|
{
|
|
gtk_image_set_from_gicon (self->image, gicon);
|
|
gtk_shortcuts_shortcut_set_icon_set (self, gicon != NULL);
|
|
g_object_notify (G_OBJECT (self), "icon");
|
|
}
|
|
|
|
static void
|
|
update_visible_from_direction (GtkShortcutsShortcut *self)
|
|
{
|
|
if (self->direction == GTK_TEXT_DIR_NONE ||
|
|
self->direction == gtk_widget_get_direction (GTK_WIDGET (self)))
|
|
{
|
|
gtk_widget_show (GTK_WIDGET (self));
|
|
}
|
|
else
|
|
{
|
|
gtk_widget_hide (GTK_WIDGET (self));
|
|
}
|
|
}
|
|
|
|
static void
|
|
gtk_shortcuts_shortcut_set_direction (GtkShortcutsShortcut *self,
|
|
GtkTextDirection direction)
|
|
{
|
|
if (self->direction == direction)
|
|
return;
|
|
|
|
self->direction = direction;
|
|
|
|
update_visible_from_direction (self);
|
|
|
|
g_object_notify (G_OBJECT (self), "direction");
|
|
}
|
|
|
|
static void
|
|
gtk_shortcuts_shortcut_direction_changed (GtkWidget *widget,
|
|
GtkTextDirection previous_dir)
|
|
{
|
|
update_visible_from_direction (GTK_SHORTCUTS_SHORTCUT (widget));
|
|
|
|
GTK_WIDGET_CLASS (gtk_shortcuts_shortcut_parent_class)->direction_changed (widget, previous_dir);
|
|
}
|
|
|
|
static void
|
|
gtk_shortcuts_shortcut_set_type (GtkShortcutsShortcut *self,
|
|
GtkShortcutType type)
|
|
{
|
|
if (self->shortcut_type == type)
|
|
return;
|
|
|
|
self->shortcut_type = type;
|
|
|
|
update_subtitle_from_type (self);
|
|
update_icon_from_type (self);
|
|
|
|
gtk_widget_set_visible (GTK_WIDGET (self->accelerator), type == GTK_SHORTCUT_ACCELERATOR);
|
|
gtk_widget_set_visible (GTK_WIDGET (self->image), type != GTK_SHORTCUT_ACCELERATOR);
|
|
|
|
|
|
g_object_notify (G_OBJECT (self), "shortcut-type");
|
|
}
|
|
|
|
static void
|
|
gtk_shortcuts_shortcut_set_action_name (GtkShortcutsShortcut *self,
|
|
const char *action_name)
|
|
{
|
|
g_free (self->action_name);
|
|
self->action_name = g_strdup (action_name);
|
|
|
|
g_object_notify (G_OBJECT (self), "action-name");
|
|
}
|
|
|
|
static void
|
|
gtk_shortcuts_shortcut_get_property (GObject *object,
|
|
guint prop_id,
|
|
GValue *value,
|
|
GParamSpec *pspec)
|
|
{
|
|
GtkShortcutsShortcut *self = GTK_SHORTCUTS_SHORTCUT (object);
|
|
|
|
switch (prop_id)
|
|
{
|
|
case PROP_TITLE:
|
|
g_value_set_string (value, gtk_label_get_label (self->title));
|
|
break;
|
|
|
|
case PROP_SUBTITLE:
|
|
g_value_set_string (value, gtk_label_get_label (self->subtitle));
|
|
break;
|
|
|
|
case PROP_SUBTITLE_SET:
|
|
g_value_set_boolean (value, self->subtitle_set);
|
|
break;
|
|
|
|
case PROP_ACCELERATOR:
|
|
g_value_set_string (value, gtk_shortcut_label_get_accelerator (self->accelerator));
|
|
break;
|
|
|
|
case PROP_ICON:
|
|
g_value_set_object (value, gtk_image_get_gicon (self->image));
|
|
break;
|
|
|
|
case PROP_ICON_SET:
|
|
g_value_set_boolean (value, self->icon_set);
|
|
break;
|
|
|
|
case PROP_DIRECTION:
|
|
g_value_set_enum (value, self->direction);
|
|
break;
|
|
|
|
case PROP_SHORTCUT_TYPE:
|
|
g_value_set_enum (value, self->shortcut_type);
|
|
break;
|
|
|
|
case PROP_ACTION_NAME:
|
|
g_value_set_string (value, self->action_name);
|
|
break;
|
|
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
|
}
|
|
}
|
|
|
|
static void
|
|
gtk_shortcuts_shortcut_set_property (GObject *object,
|
|
guint prop_id,
|
|
const GValue *value,
|
|
GParamSpec *pspec)
|
|
{
|
|
GtkShortcutsShortcut *self = GTK_SHORTCUTS_SHORTCUT (object);
|
|
|
|
switch (prop_id)
|
|
{
|
|
case PROP_ACCELERATOR:
|
|
gtk_shortcuts_shortcut_set_accelerator (self, g_value_get_string (value));
|
|
break;
|
|
|
|
case PROP_ICON:
|
|
gtk_shortcuts_shortcut_set_icon (self, g_value_get_object (value));
|
|
break;
|
|
|
|
case PROP_ICON_SET:
|
|
gtk_shortcuts_shortcut_set_icon_set (self, g_value_get_boolean (value));
|
|
break;
|
|
|
|
case PROP_ACCEL_SIZE_GROUP:
|
|
gtk_shortcuts_shortcut_set_accel_size_group (self, GTK_SIZE_GROUP (g_value_get_object (value)));
|
|
break;
|
|
|
|
case PROP_TITLE:
|
|
gtk_label_set_label (self->title, g_value_get_string (value));
|
|
break;
|
|
|
|
case PROP_SUBTITLE:
|
|
gtk_shortcuts_shortcut_set_subtitle (self, g_value_get_string (value));
|
|
break;
|
|
|
|
case PROP_SUBTITLE_SET:
|
|
gtk_shortcuts_shortcut_set_subtitle_set (self, g_value_get_boolean (value));
|
|
break;
|
|
|
|
case PROP_TITLE_SIZE_GROUP:
|
|
gtk_shortcuts_shortcut_set_title_size_group (self, GTK_SIZE_GROUP (g_value_get_object (value)));
|
|
break;
|
|
|
|
case PROP_DIRECTION:
|
|
gtk_shortcuts_shortcut_set_direction (self, g_value_get_enum (value));
|
|
break;
|
|
|
|
case PROP_SHORTCUT_TYPE:
|
|
gtk_shortcuts_shortcut_set_type (self, g_value_get_enum (value));
|
|
break;
|
|
|
|
case PROP_ACTION_NAME:
|
|
gtk_shortcuts_shortcut_set_action_name (self, g_value_get_string (value));
|
|
break;
|
|
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void
|
|
gtk_shortcuts_shortcut_finalize (GObject *object)
|
|
{
|
|
GtkShortcutsShortcut *self = GTK_SHORTCUTS_SHORTCUT (object);
|
|
|
|
g_clear_object (&self->accel_size_group);
|
|
g_clear_object (&self->title_size_group);
|
|
g_free (self->action_name);
|
|
gtk_widget_unparent (GTK_WIDGET (self->box));
|
|
|
|
G_OBJECT_CLASS (gtk_shortcuts_shortcut_parent_class)->finalize (object);
|
|
}
|
|
|
|
void
|
|
gtk_shortcuts_shortcut_update_accel (GtkShortcutsShortcut *self,
|
|
GtkWindow *window)
|
|
{
|
|
GtkApplication *app;
|
|
char **accels;
|
|
char *str;
|
|
|
|
if (self->action_name == NULL)
|
|
return;
|
|
|
|
app = gtk_window_get_application (window);
|
|
if (app == NULL)
|
|
return;
|
|
|
|
accels = gtk_application_get_accels_for_action (app, self->action_name);
|
|
str = g_strjoinv (" ", accels);
|
|
|
|
gtk_shortcuts_shortcut_set_accelerator (self, str);
|
|
|
|
g_free (str);
|
|
g_strfreev (accels);
|
|
}
|
|
|
|
static void
|
|
gtk_shortcuts_shortcut_measure (GtkWidget *widget,
|
|
GtkOrientation orientation,
|
|
int for_size,
|
|
int *minimum,
|
|
int *natural,
|
|
int *minimum_baseline,
|
|
int *natural_baseline)
|
|
{
|
|
gtk_widget_measure (GTK_WIDGET (GTK_SHORTCUTS_SHORTCUT (widget)->box),
|
|
orientation, for_size,
|
|
minimum, natural,
|
|
minimum_baseline, natural_baseline);
|
|
}
|
|
|
|
static void
|
|
gtk_shortcuts_shortcut_snapshot (GtkWidget *widget,
|
|
GtkSnapshot *snapshot)
|
|
{
|
|
gtk_widget_snapshot_child (widget, GTK_WIDGET (GTK_SHORTCUTS_SHORTCUT (widget)->box), snapshot);
|
|
}
|
|
|
|
static void
|
|
gtk_shortcuts_shortcut_size_allocate (GtkWidget *widget,
|
|
int width,
|
|
int height,
|
|
int baseline)
|
|
{
|
|
GTK_WIDGET_CLASS (gtk_shortcuts_shortcut_parent_class)->size_allocate (widget, width, height, baseline);
|
|
|
|
gtk_widget_size_allocate (GTK_WIDGET (GTK_SHORTCUTS_SHORTCUT (widget)->box),
|
|
&(GtkAllocation) {
|
|
0, 0,
|
|
width, height
|
|
}, -1);
|
|
}
|
|
|
|
static void
|
|
gtk_shortcuts_shortcut_class_init (GtkShortcutsShortcutClass *klass)
|
|
{
|
|
GObjectClass *object_class = G_OBJECT_CLASS (klass);
|
|
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
|
|
|
|
object_class->finalize = gtk_shortcuts_shortcut_finalize;
|
|
object_class->get_property = gtk_shortcuts_shortcut_get_property;
|
|
object_class->set_property = gtk_shortcuts_shortcut_set_property;
|
|
|
|
widget_class->direction_changed = gtk_shortcuts_shortcut_direction_changed;
|
|
widget_class->measure = gtk_shortcuts_shortcut_measure;
|
|
widget_class->snapshot = gtk_shortcuts_shortcut_snapshot;
|
|
widget_class->size_allocate = gtk_shortcuts_shortcut_size_allocate;
|
|
|
|
/**
|
|
* GtkShortcutsShortcut:accelerator:
|
|
*
|
|
* The accelerator(s) represented by this object. This property is used
|
|
* if #GtkShortcutsShortcut:shortcut-type is set to #GTK_SHORTCUT_ACCELERATOR.
|
|
*
|
|
* The syntax of this property is (an extension of) the syntax understood by
|
|
* gtk_accelerator_parse(). Multiple accelerators can be specified by separating
|
|
* them with a space, but keep in mind that the available width is limited.
|
|
* It is also possible to specify ranges of shortcuts, using ... between the keys.
|
|
* Sequences of keys can be specified using a + or & between the keys.
|
|
*
|
|
* Examples:
|
|
* - A single shortcut: <ctl><alt>delete
|
|
* - Two alternative shortcuts: <shift>a Home
|
|
* - A range of shortcuts: <alt>1...<alt>9
|
|
* - Several keys pressed together: Control_L&Control_R
|
|
* - A sequence of shortcuts or keys: <ctl>c+<ctl>x
|
|
*
|
|
* Use + instead of & when the keys may (or have to be) pressed sequentially (e.g
|
|
* use t+t for 'press the t key twice').
|
|
*
|
|
* Note that <, > and & need to be escaped as <, > and & when used
|
|
* in .ui files.
|
|
*/
|
|
properties[PROP_ACCELERATOR] =
|
|
g_param_spec_string ("accelerator",
|
|
P_("Accelerator"),
|
|
P_("The accelerator keys for shortcuts of type “Accelerator”"),
|
|
NULL,
|
|
(G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
|
|
|
|
/**
|
|
* GtkShortcutsShortcut:icon:
|
|
*
|
|
* An icon to represent the shortcut or gesture. This property is used if
|
|
* #GtkShortcutsShortcut:shortcut-type is set to #GTK_SHORTCUT_GESTURE.
|
|
* For the other predefined gesture types, GTK provides an icon on its own.
|
|
*/
|
|
properties[PROP_ICON] =
|
|
g_param_spec_object ("icon",
|
|
P_("Icon"),
|
|
P_("The icon to show for shortcuts of type “Other Gesture”"),
|
|
G_TYPE_ICON,
|
|
(G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
|
|
|
|
/**
|
|
* GtkShortcutsShortcut:icon-set:
|
|
*
|
|
* %TRUE if an icon has been set.
|
|
*/
|
|
properties[PROP_ICON_SET] =
|
|
g_param_spec_boolean ("icon-set",
|
|
P_("Icon Set"),
|
|
P_("Whether an icon has been set"),
|
|
FALSE,
|
|
(G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
|
|
|
|
/**
|
|
* GtkShortcutsShortcut:title:
|
|
*
|
|
* The textual description for the shortcut or gesture represented by
|
|
* this object. This should be a short string that can fit in a single line.
|
|
*/
|
|
properties[PROP_TITLE] =
|
|
g_param_spec_string ("title",
|
|
P_("Title"),
|
|
P_("A short description for the shortcut"),
|
|
"",
|
|
(G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
|
|
|
|
/**
|
|
* GtkShortcutsShortcut:subtitle:
|
|
*
|
|
* The subtitle for the shortcut or gesture.
|
|
*
|
|
* This is typically used for gestures and should be a short, one-line
|
|
* text that describes the gesture itself. For the predefined gesture
|
|
* types, GTK provides a subtitle on its own.
|
|
*/
|
|
properties[PROP_SUBTITLE] =
|
|
g_param_spec_string ("subtitle",
|
|
P_("Subtitle"),
|
|
P_("A short description for the gesture"),
|
|
"",
|
|
(G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
|
|
|
|
/**
|
|
* GtkShortcutsShortcut:subtitle-set:
|
|
*
|
|
* %TRUE if a subtitle has been set.
|
|
*/
|
|
properties[PROP_SUBTITLE_SET] =
|
|
g_param_spec_boolean ("subtitle-set",
|
|
P_("Subtitle Set"),
|
|
P_("Whether a subtitle has been set"),
|
|
FALSE,
|
|
(G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
|
|
|
|
/**
|
|
* GtkShortcutsShortcut:accel-size-group:
|
|
*
|
|
* The size group for the accelerator portion of this shortcut.
|
|
*
|
|
* This is used internally by GTK, and must not be modified by applications.
|
|
*/
|
|
properties[PROP_ACCEL_SIZE_GROUP] =
|
|
g_param_spec_object ("accel-size-group",
|
|
P_("Accelerator Size Group"),
|
|
P_("Accelerator Size Group"),
|
|
GTK_TYPE_SIZE_GROUP,
|
|
(G_PARAM_WRITABLE | G_PARAM_STATIC_STRINGS));
|
|
|
|
/**
|
|
* GtkShortcutsShortcut:title-size-group:
|
|
*
|
|
* The size group for the textual portion of this shortcut.
|
|
*
|
|
* This is used internally by GTK, and must not be modified by applications.
|
|
*/
|
|
properties[PROP_TITLE_SIZE_GROUP] =
|
|
g_param_spec_object ("title-size-group",
|
|
P_("Title Size Group"),
|
|
P_("Title Size Group"),
|
|
GTK_TYPE_SIZE_GROUP,
|
|
(G_PARAM_WRITABLE | G_PARAM_STATIC_STRINGS));
|
|
|
|
/**
|
|
* GtkShortcutsShortcut:direction:
|
|
*
|
|
* The text direction for which this shortcut is active. If the shortcut
|
|
* is used regardless of the text direction, set this property to
|
|
* #GTK_TEXT_DIR_NONE.
|
|
*/
|
|
properties[PROP_DIRECTION] =
|
|
g_param_spec_enum ("direction",
|
|
P_("Direction"),
|
|
P_("Text direction for which this shortcut is active"),
|
|
GTK_TYPE_TEXT_DIRECTION,
|
|
GTK_TEXT_DIR_NONE,
|
|
(G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_EXPLICIT_NOTIFY));
|
|
|
|
/**
|
|
* GtkShortcutsShortcut:shortcut-type:
|
|
*
|
|
* The type of shortcut that is represented.
|
|
*/
|
|
properties[PROP_SHORTCUT_TYPE] =
|
|
g_param_spec_enum ("shortcut-type",
|
|
P_("Shortcut Type"),
|
|
P_("The type of shortcut that is represented"),
|
|
GTK_TYPE_SHORTCUT_TYPE,
|
|
GTK_SHORTCUT_ACCELERATOR,
|
|
(G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_EXPLICIT_NOTIFY));
|
|
|
|
/**
|
|
* GtkShortcutsShortcut:action-name:
|
|
*
|
|
* A detailed action name. If this is set for a shortcut
|
|
* of type %GTK_SHORTCUT_ACCELERATOR, then GTK will use
|
|
* the accelerators that are associated with the action
|
|
* via gtk_application_set_accels_for_action(), and setting
|
|
* #GtkShortcutsShortcut:accelerator is not necessary.
|
|
*/
|
|
properties[PROP_ACTION_NAME] =
|
|
g_param_spec_string ("action-name",
|
|
P_("Action Name"),
|
|
P_("The name of the action"),
|
|
NULL,
|
|
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_EXPLICIT_NOTIFY);
|
|
|
|
g_object_class_install_properties (object_class, LAST_PROP, properties);
|
|
gtk_widget_class_set_css_name (widget_class, I_("shortcut"));
|
|
gtk_widget_class_set_accessible_role (widget_class, GTK_ACCESSIBLE_ROLE_GROUP);
|
|
}
|
|
|
|
static void
|
|
gtk_shortcuts_shortcut_init (GtkShortcutsShortcut *self)
|
|
{
|
|
self->box = g_object_new (GTK_TYPE_BOX,
|
|
"orientation", GTK_ORIENTATION_HORIZONTAL,
|
|
"spacing", 12,
|
|
NULL);
|
|
gtk_widget_set_parent (GTK_WIDGET (self->box), GTK_WIDGET (self));
|
|
|
|
self->direction = GTK_TEXT_DIR_NONE;
|
|
self->shortcut_type = GTK_SHORTCUT_ACCELERATOR;
|
|
|
|
self->image = g_object_new (GTK_TYPE_IMAGE,
|
|
"visible", FALSE,
|
|
"valign", GTK_ALIGN_CENTER,
|
|
"accessible-role", GTK_ACCESSIBLE_ROLE_PRESENTATION,
|
|
NULL);
|
|
gtk_box_append (GTK_BOX (self->box), GTK_WIDGET (self->image));
|
|
|
|
self->accelerator = g_object_new (GTK_TYPE_SHORTCUT_LABEL,
|
|
"visible", TRUE,
|
|
"valign", GTK_ALIGN_CENTER,
|
|
NULL);
|
|
gtk_box_append (GTK_BOX (self->box), GTK_WIDGET (self->accelerator));
|
|
|
|
self->title_box = g_object_new (GTK_TYPE_BOX,
|
|
"visible", TRUE,
|
|
"valign", GTK_ALIGN_CENTER,
|
|
"hexpand", TRUE,
|
|
"orientation", GTK_ORIENTATION_VERTICAL,
|
|
NULL);
|
|
gtk_box_append (GTK_BOX (self->box), GTK_WIDGET (self->title_box));
|
|
|
|
self->title = g_object_new (GTK_TYPE_LABEL,
|
|
"visible", TRUE,
|
|
"xalign", 0.0f,
|
|
NULL);
|
|
gtk_box_append (GTK_BOX (self->title_box), GTK_WIDGET (self->title));
|
|
|
|
self->subtitle = g_object_new (GTK_TYPE_LABEL,
|
|
"visible", FALSE,
|
|
"xalign", 0.0f,
|
|
NULL);
|
|
gtk_widget_add_css_class (GTK_WIDGET (self->subtitle), "dim-label");
|
|
gtk_box_append (GTK_BOX (self->title_box), GTK_WIDGET (self->subtitle));
|
|
}
|