* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the
- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- * Boston, MA 02111-1307, USA.
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
*
* Author:
* Emmanuele Bassi <ebassi@linux.intel.com>
* Matthias Clasen <mclasen@redhat.com>
*
- * Based on similar code from:
- * Thomas Wood <thos@linux.intel.com>
+ * Based on similar code from Mx.
*/
/**
#include "gtkswitch.h"
-#include <gdk/gdkkeysyms.h>
-
-#include "gtkaccessible.h"
#include "gtkactivatable.h"
#include "gtkintl.h"
-#include "gtkstyle.h"
#include "gtkprivate.h"
#include "gtktoggleaction.h"
#include "gtkwidget.h"
+#include "gtkmarshalers.h"
+#include "gtkapplicationprivate.h"
+#include "gtkactionable.h"
+#include "a11y/gtkswitchaccessible.h"
+#include "gtkactionhelper.h"
+
+#include <math.h>
#define DEFAULT_SLIDER_WIDTH (36)
#define DEFAULT_SLIDER_HEIGHT (22)
{
GdkWindow *event_window;
GtkAction *action;
+ GtkActionHelper *action_helper;
gint handle_x;
gint offset;
PROP_ACTIVE,
PROP_RELATED_ACTION,
PROP_USE_ACTION_APPEARANCE,
- LAST_PROP
+ LAST_PROP,
+ PROP_ACTION_NAME,
+ PROP_ACTION_TARGET
};
-static GParamSpec *switch_props[LAST_PROP] = { NULL, };
+enum
+{
+ ACTIVATE,
+ LAST_SIGNAL
+};
+
+static guint signals[LAST_SIGNAL] = { 0 };
-static GType gtk_switch_accessible_factory_get_type (void);
+static GParamSpec *switch_props[LAST_PROP] = { NULL, };
+static void gtk_switch_actionable_iface_init (GtkActionableInterface *iface);
static void gtk_switch_activatable_interface_init (GtkActivatableIface *iface);
G_DEFINE_TYPE_WITH_CODE (GtkSwitch, gtk_switch, GTK_TYPE_WIDGET,
+ G_IMPLEMENT_INTERFACE (GTK_TYPE_ACTIONABLE,
+ gtk_switch_actionable_iface_init)
G_IMPLEMENT_INTERFACE (GTK_TYPE_ACTIVATABLE,
gtk_switch_activatable_interface_init));
if (event->x <= allocation.width / 2)
{
priv->in_press = TRUE;
- return FALSE;
+ return TRUE;
}
priv->offset = event->x - allocation.width / 2;
if (event->x >= allocation.width / 2)
{
priv->in_press = TRUE;
- return FALSE;
+ return TRUE;
}
priv->offset = event->x;
"gtk-dnd-drag-threshold", &priv->drag_threshold,
NULL);
- return FALSE;
+ return TRUE;
}
static gboolean
{
gint position = event->x - priv->offset;
GtkAllocation allocation;
- GtkStyle *style;
-
- style = gtk_widget_get_style (widget);
+ GtkStyleContext *context;
+ GtkStateFlags state;
+ GtkBorder padding;
+ gint width, focus_width, focus_pad;
+
+ gtk_widget_style_get (widget,
+ "focus-line-width", &focus_width,
+ "focus-padding", &focus_pad,
+ NULL);
+
+ context = gtk_widget_get_style_context (widget);
+ state = gtk_widget_get_state_flags (widget);
+
+ gtk_style_context_save (context);
+ gtk_style_context_add_class (context, GTK_STYLE_CLASS_SLIDER);
+ gtk_style_context_get_padding (context, state, &padding);
+ gtk_style_context_restore (context);
+
gtk_widget_get_allocation (widget, &allocation);
+ width = allocation.width - 2 * (focus_width + focus_pad);
+
/* constrain the handle within the trough width */
- if (position > (allocation.width / 2 - style->xthickness))
- priv->handle_x = allocation.width / 2 - style->xthickness;
- else if (position < style->xthickness)
- priv->handle_x = style->xthickness;
+ if (position > (width / 2) - padding.right)
+ priv->handle_x = width / 2 - padding.right;
+ else if (position < padding.left)
+ priv->handle_x = 0;
else
priv->handle_x = position;
return TRUE;
}
+ /* toggle the switch if the handle was clicked but a drag had not been
+ * initiated */
+ if (!priv->is_dragging && !priv->in_press)
+ {
+ gtk_switch_set_active (GTK_SWITCH (widget), !priv->is_active);
+
+ return TRUE;
+ }
+
/* dragged toggle */
if (priv->is_dragging)
{
return FALSE;
}
-static gboolean
-gtk_switch_key_release (GtkWidget *widget,
- GdkEventKey *event)
+static void
+gtk_switch_activate (GtkSwitch *sw)
{
- GtkSwitchPrivate *priv = GTK_SWITCH (widget)->priv;
-
- if (event->keyval == GDK_KEY_Return ||
- event->keyval == GDK_KEY_KP_Enter ||
- event->keyval == GDK_KEY_ISO_Enter ||
- event->keyval == GDK_KEY_space ||
- event->keyval == GDK_KEY_KP_Space)
- {
- gtk_switch_set_active (GTK_SWITCH (widget), !priv->is_active);
- }
+ GtkSwitchPrivate *priv = sw->priv;
- return FALSE;
+ gtk_switch_set_active (sw, !priv->is_active);
}
static void
gint *minimum,
gint *natural)
{
- GtkStyle *style = gtk_widget_get_style (widget);
+ GtkStyleContext *context;
+ GtkStateFlags state;
+ GtkBorder padding;
gint width, slider_width, focus_width, focus_pad;
PangoLayout *layout;
PangoRectangle logical_rect;
- width = style->xthickness * 2;
+ context = gtk_widget_get_style_context (widget);
+ state = gtk_style_context_get_state (context);
+
+ gtk_style_context_save (context);
+
+ gtk_style_context_add_class (context, GTK_STYLE_CLASS_SLIDER);
+ gtk_style_context_get_padding (context, state, &padding);
+
+ width = padding.left + padding.right;
+
+ gtk_style_context_restore (context);
gtk_widget_style_get (widget,
"slider-width", &slider_width,
gint *minimum,
gint *natural)
{
- GtkStyle *style = gtk_widget_get_style (widget);
+ GtkStyleContext *context;
+ GtkStateFlags state;
+ GtkBorder padding;
gint height, focus_width, focus_pad;
PangoLayout *layout;
PangoRectangle logical_rect;
gchar *str;
- height = style->ythickness * 2;
+ context = gtk_widget_get_style_context (widget);
+ state = gtk_style_context_get_state (context);
+
+ gtk_style_context_save (context);
+
+ gtk_style_context_add_class (context, GTK_STYLE_CLASS_SLIDER);
+ gtk_style_context_get_padding (context, state, &padding);
+
+ height = padding.top + padding.bottom;
+
+ gtk_style_context_restore (context);
gtk_widget_style_get (widget,
"focus-line-width", &focus_width,
priv->event_window = gdk_window_new (parent_window,
&attributes,
attributes_mask);
- gdk_window_set_user_data (priv->event_window, widget);
-
- gtk_widget_style_attach (widget);
+ gtk_widget_register_window (widget, priv->event_window);
}
static void
if (priv->event_window != NULL)
{
- gdk_window_set_user_data (priv->event_window, NULL);
+ gtk_widget_unregister_window (widget, priv->event_window);
gdk_window_destroy (priv->event_window);
priv->event_window = NULL;
}
cairo_t *cr,
GdkRectangle *box)
{
- GtkStyle *style = gtk_widget_get_style (widget);
+ GtkStyleContext *context = gtk_widget_get_style_context (widget);
+
+ gtk_style_context_save (context);
+ gtk_style_context_add_class (context, GTK_STYLE_CLASS_SLIDER);
- gtk_paint_slider (style, cr,
- gtk_widget_get_state (widget),
- GTK_SHADOW_OUT,
- GTK_WIDGET (widget), "switch-slider",
- box->x,
- box->y,
- box->width,
- box->height,
- GTK_ORIENTATION_HORIZONTAL);
+ gtk_render_slider (context, cr,
+ box->x, box->y,
+ box->width, box->height,
+ GTK_ORIENTATION_HORIZONTAL);
+
+ gtk_style_context_restore (context);
}
static gboolean
cairo_t *cr)
{
GtkSwitchPrivate *priv = GTK_SWITCH (widget)->priv;
- GtkStyle *style;
+ GtkStyleContext *context;
GdkRectangle handle;
PangoLayout *layout;
PangoRectangle rect;
gint label_x, label_y;
- GtkStateType state;
+ GtkBorder padding;
+ GtkStateFlags state;
gint focus_width, focus_pad;
gint x, y, width, height;
"focus-padding", &focus_pad,
NULL);
- style = gtk_widget_get_style (widget);
+ context = gtk_widget_get_style_context (widget);
+ state = gtk_widget_get_state_flags (widget);
+
+ gtk_style_context_save (context);
+
+ gtk_style_context_add_class (context, GTK_STYLE_CLASS_SLIDER);
+
+ gtk_style_context_get_padding (context, state, &padding);
+
+ gtk_style_context_restore (context);
x = 0;
y = 0;
width = gtk_widget_get_allocated_width (widget);
height = gtk_widget_get_allocated_height (widget);
- if (gtk_widget_has_focus (widget))
- gtk_paint_focus (style, cr,
- gtk_widget_get_state (widget),
- widget, "button",
- x, y, width, height);
+ if (gtk_widget_has_visible_focus (widget))
+ gtk_render_focus (context, cr, x, y, width, height);
x += focus_width + focus_pad;
y += focus_width + focus_pad;
width -= 2 * (focus_width + focus_pad);
height -= 2 * (focus_width + focus_pad);
- state = priv->is_active ? GTK_STATE_SELECTED : gtk_widget_get_state (widget);
+ gtk_style_context_save (context);
+ gtk_style_context_add_class (context, GTK_STYLE_CLASS_TROUGH);
- /* background - XXX should this be a flat box instead? we're missing
- * the border given by the shadow with that, which would require
- * fixing all theme engines to add a subtle border for this widget
- */
- gtk_paint_box (style, cr,
- state,
- GTK_SHADOW_IN,
- widget, "switch-background",
- x, y, width, height);
+ gtk_render_background (context, cr, x, y, width, height);
+ gtk_render_frame (context, cr, x, y, width, height);
- if (!gtk_widget_is_sensitive (widget))
- state = GTK_STATE_INSENSITIVE;
+ width -= padding.left + padding.right;
+ height -= padding.top + padding.bottom;
- /* XXX the +1/-1 it's pixel wriggling after checking with the default
- * theme and xmag
- */
- handle.y = y + style->ythickness + 1;
- handle.width = (width - style->xthickness * 2) / 2;
- handle.height = (height - style->ythickness * 2) - 1;
+ x += padding.left;
+ y += padding.top;
+
+ handle.y = y;
+ handle.width = width / 2;
+ handle.height = height;
/* Translators: if the "on" state label requires more than three
* glyphs then use MEDIUM VERTICAL BAR (U+2759) as the text for
* the state
*/
layout = gtk_widget_create_pango_layout (widget, C_("switch", "ON"));
+
pango_layout_get_extents (layout, NULL, &rect);
pango_extents_to_pixels (&rect, NULL);
- label_x = x + style->xthickness
- + ((width / 2) - rect.width - (style->xthickness * 2)) / 2;
- label_y = y + style->ythickness
- + (height - rect.height - (style->ythickness * 2)) / 2;
+ label_x = x + ((width / 2) - rect.width) / 2;
+ label_y = y + (height - rect.height) / 2;
- gtk_paint_layout (style, cr,
- state,
- FALSE,
- widget, "switch-on-label",
- label_x, label_y,
- layout);
+ gtk_render_layout (context, cr, label_x, label_y, layout);
g_object_unref (layout);
* glyphs then use WHITE CIRCLE (U+25CB) as the text for the state
*/
layout = gtk_widget_create_pango_layout (widget, C_("switch", "OFF"));
+
pango_layout_get_extents (layout, NULL, &rect);
pango_extents_to_pixels (&rect, NULL);
- label_x = x + style->xthickness
- + (width / 2)
- + ((width / 2) - rect.width - (style->xthickness * 2)) / 2;
- label_y = y + style->ythickness
- + (height - rect.height - (style->ythickness * 2)) / 2;
+ label_x = x + (width / 2) + ((width / 2) - rect.width) / 2;
+ label_y = y + (height - rect.height) / 2;
- gtk_paint_layout (style, cr,
- state,
- FALSE,
- widget, "switch-off-label",
- label_x, label_y,
- layout);
+ gtk_render_layout (context, cr, label_x, label_y, layout);
g_object_unref (layout);
if (priv->is_dragging)
handle.x = x + priv->handle_x;
else if (priv->is_active)
- handle.x = x + width - handle.width - style->xthickness;
+ handle.x = x + width - handle.width;
else
- handle.x = x + style->xthickness;
+ handle.x = x;
+
+ gtk_style_context_restore (context);
gtk_switch_paint_handle (widget, cr, &handle);
return FALSE;
}
-static AtkObject *
-gtk_switch_get_accessible (GtkWidget *widget)
-{
- static gboolean first_time = TRUE;
-
- if (G_UNLIKELY (first_time))
- {
- AtkObjectFactory *factory;
- AtkRegistry *registry;
- GType derived_type;
- GType derived_atk_type;
-
- /* Figure out whether accessibility is enabled by looking at the
- * type of the accessible object which would be created for the
- * parent type of GtkSwitch
- */
- derived_type = g_type_parent (GTK_TYPE_SWITCH);
-
- registry = atk_get_default_registry ();
- factory = atk_registry_get_factory (registry, derived_type);
- derived_atk_type = atk_object_factory_get_accessible_type (factory);
- if (g_type_is_a (derived_atk_type, GTK_TYPE_ACCESSIBLE))
- atk_registry_set_factory_type (registry,
- GTK_TYPE_SWITCH,
- gtk_switch_accessible_factory_get_type ());
-
- first_time = FALSE;
- }
-
- return GTK_WIDGET_CLASS (gtk_switch_parent_class)->get_accessible (widget);
-}
-
static void
gtk_switch_set_related_action (GtkSwitch *sw,
GtkAction *action)
}
}
+static void
+gtk_switch_set_action_name (GtkActionable *actionable,
+ const gchar *action_name)
+{
+ GtkSwitch *sw = GTK_SWITCH (actionable);
+
+ if (!sw->priv->action_helper)
+ sw->priv->action_helper = gtk_action_helper_new (actionable);
+
+ gtk_action_helper_set_action_name (sw->priv->action_helper, action_name);
+}
+
+static void
+gtk_switch_set_action_target_value (GtkActionable *actionable,
+ GVariant *action_target)
+{
+ GtkSwitch *sw = GTK_SWITCH (actionable);
+
+ if (!sw->priv->action_helper)
+ sw->priv->action_helper = gtk_action_helper_new (actionable);
+
+ gtk_action_helper_set_action_target_value (sw->priv->action_helper, action_target);
+}
+
+static const gchar *
+gtk_switch_get_action_name (GtkActionable *actionable)
+{
+ GtkSwitch *sw = GTK_SWITCH (actionable);
+
+ return gtk_action_helper_get_action_name (sw->priv->action_helper);
+}
+
+static GVariant *
+gtk_switch_get_action_target_value (GtkActionable *actionable)
+{
+ GtkSwitch *sw = GTK_SWITCH (actionable);
+
+ return gtk_action_helper_get_action_target_value (sw->priv->action_helper);
+}
+
+static void
+gtk_switch_actionable_iface_init (GtkActionableInterface *iface)
+{
+ iface->get_action_name = gtk_switch_get_action_name;
+ iface->set_action_name = gtk_switch_set_action_name;
+ iface->get_action_target_value = gtk_switch_get_action_target_value;
+ iface->set_action_target_value = gtk_switch_set_action_target_value;
+}
+
static void
gtk_switch_set_property (GObject *gobject,
guint prop_id,
gtk_switch_set_use_action_appearance (sw, g_value_get_boolean (value));
break;
+ case PROP_ACTION_NAME:
+ gtk_switch_set_action_name (GTK_ACTIONABLE (sw), g_value_get_string (value));
+ break;
+
+ case PROP_ACTION_TARGET:
+ gtk_switch_set_action_target_value (GTK_ACTIONABLE (sw), g_value_get_variant (value));
+ break;
+
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
}
g_value_set_boolean (value, priv->use_action_appearance);
break;
+ case PROP_ACTION_NAME:
+ g_value_set_string (value, gtk_action_helper_get_action_name (priv->action_helper));
+ break;
+
+ case PROP_ACTION_TARGET:
+ g_value_set_variant (value, gtk_action_helper_get_action_target_value (priv->action_helper));
+ break;
+
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
}
{
GtkSwitchPrivate *priv = GTK_SWITCH (object)->priv;
+ g_clear_object (&priv->action_helper);
+
if (priv->action)
{
gtk_activatable_do_set_related_action (GTK_ACTIVATABLE (object), NULL);
widget_class->motion_notify_event = gtk_switch_motion;
widget_class->enter_notify_event = gtk_switch_enter;
widget_class->leave_notify_event = gtk_switch_leave;
- widget_class->key_release_event = gtk_switch_key_release;
- widget_class->get_accessible = gtk_switch_get_accessible;
+
+ klass->activate = gtk_switch_activate;
/**
* GtkSwitch:slider-width:
DEFAULT_SLIDER_WIDTH, G_MAXINT,
DEFAULT_SLIDER_WIDTH,
GTK_PARAM_READABLE));
+
+ /**
+ * GtkSwitch::activate:
+ * @widget: the object which received the signal.
+ *
+ * The ::activate signal on GtkSwitch is an action signal and
+ * emitting it causes the switch to animate.
+ * Applications should never connect to this signal, but use the
+ * notify::active signal.
+ */
+ signals[ACTIVATE] =
+ g_signal_new (I_("activate"),
+ G_OBJECT_CLASS_TYPE (gobject_class),
+ G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
+ G_STRUCT_OFFSET (GtkSwitchClass, activate),
+ NULL, NULL,
+ _gtk_marshal_VOID__VOID,
+ G_TYPE_NONE, 0);
+ widget_class->activate_signal = signals[ACTIVATE];
+
+ g_object_class_override_property (gobject_class, PROP_ACTION_NAME, "action-name");
+ g_object_class_override_property (gobject_class, PROP_ACTION_TARGET, "action-target");
+
+ gtk_widget_class_set_accessible_type (widget_class, GTK_TYPE_SWITCH_ACCESSIBLE);
}
static void
g_object_notify_by_pspec (G_OBJECT (sw), switch_props[PROP_ACTIVE]);
+ if (priv->action_helper)
+ gtk_action_helper_activate (priv->action_helper);
+
if (priv->action)
gtk_action_activate (priv->action);
accessible = gtk_widget_get_accessible (GTK_WIDGET (sw));
atk_object_notify_state_change (accessible, ATK_STATE_CHECKED, priv->is_active);
+ if (priv->is_active)
+ gtk_widget_set_state_flags (GTK_WIDGET (sw), GTK_STATE_FLAG_ACTIVE, FALSE);
+ else
+ gtk_widget_unset_state_flags (GTK_WIDGET (sw), GTK_STATE_FLAG_ACTIVE);
+
gtk_widget_queue_draw (GTK_WIDGET (sw));
}
}
iface->update = gtk_switch_update;
iface->sync_action_properties = gtk_switch_sync_action_properties;
}
-
-/* accessibility: object */
-
-/* dummy typedefs */
-typedef struct _GtkSwitchAccessible GtkSwitchAccessible;
-typedef struct _GtkSwitchAccessibleClass GtkSwitchAccessibleClass;
-
-ATK_DEFINE_TYPE (GtkSwitchAccessible, gtk_switch_accessible, GTK_TYPE_WIDGET);
-
-static AtkStateSet *
-gtk_switch_accessible_ref_state_set (AtkObject *accessible)
-{
- AtkStateSet *state_set;
- GtkWidget *widget;
-
- state_set = ATK_OBJECT_CLASS (gtk_switch_accessible_parent_class)->ref_state_set (accessible);
-
- widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (accessible));
- if (widget == NULL)
- return state_set;
-
- if (gtk_switch_get_active (GTK_SWITCH (widget)))
- atk_state_set_add_state (state_set, ATK_STATE_CHECKED);
-
- return state_set;
-}
-
-static void
-gtk_switch_accessible_initialize (AtkObject *accessible,
- gpointer widget)
-{
- ATK_OBJECT_CLASS (gtk_switch_accessible_parent_class)->initialize (accessible, widget);
-
- atk_object_set_role (accessible, ATK_ROLE_TOGGLE_BUTTON);
- atk_object_set_name (accessible, C_("light switch widget", "Switch"));
- atk_object_set_description (accessible, _("Switches between on and off states"));
-}
-
-static void
-gtk_switch_accessible_class_init (GtkSwitchAccessibleClass *klass)
-{
- AtkObjectClass *atk_class = ATK_OBJECT_CLASS (klass);
-
- atk_class->initialize = gtk_switch_accessible_initialize;
- atk_class->ref_state_set = gtk_switch_accessible_ref_state_set;
-}
-
-static void
-gtk_switch_accessible_init (GtkSwitchAccessible *self)
-{
-}
-
-/* accessibility: factory */
-
-typedef AtkObjectFactoryClass GtkSwitchAccessibleFactoryClass;
-typedef AtkObjectFactory GtkSwitchAccessibleFactory;
-
-G_DEFINE_TYPE (GtkSwitchAccessibleFactory,
- gtk_switch_accessible_factory,
- ATK_TYPE_OBJECT_FACTORY);
-
-static GType
-gtk_switch_accessible_factory_get_accessible_type (void)
-{
- return gtk_switch_accessible_get_type ();
-}
-
-static AtkObject *
-gtk_switch_accessible_factory_create_accessible (GObject *obj)
-{
- AtkObject *accessible;
-
- accessible = g_object_new (gtk_switch_accessible_get_type (), NULL);
- atk_object_initialize (accessible, obj);
-
- return accessible;
-}
-
-static void
-gtk_switch_accessible_factory_class_init (AtkObjectFactoryClass *klass)
-{
- klass->create_accessible = gtk_switch_accessible_factory_create_accessible;
- klass->get_accessible_type = gtk_switch_accessible_factory_get_accessible_type;
-}
-
-static void
-gtk_switch_accessible_factory_init (AtkObjectFactory *factory)
-{
-}
projects / ~andy / gtk / blobdiff