diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/Makefile.am | 7 | ||||
| -rw-r--r-- | src/idooffscreenproxy.c | 512 | ||||
| -rw-r--r-- | src/idooffscreenproxy.h | 62 | ||||
| -rw-r--r-- | src/idoscalemenuitem.c | 33 |
4 files changed, 599 insertions, 15 deletions
diff --git a/src/Makefile.am b/src/Makefile.am index 5ac5a01..c61474f 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -18,9 +18,10 @@ sources_h = \ idoentrymenuitem.h \ idomessagedialog.h \ idorange.h \ + idooffscreenproxy.h \ idoscalemenuitem.h \ idotimeline.h \ - libido.h + libido.h EXTRA_DIST = \ ido.list \ @@ -62,7 +63,8 @@ libido_0_1_la_SOURCES = \ idomessagedialog.c \ idorange.c \ idoscalemenuitem.c \ - idotimeline.c + idotimeline.c \ + idooffscreenproxy.c libido3_0_1_la_SOURCES = $(libido_0_1_la_SOURCES) libidoincludedir=$(includedir)/libido$(VER)-0.1/libido @@ -74,6 +76,7 @@ libidoinclude_HEADERS = \ idorange.h \ idoscalemenuitem.h \ idotimeline.h \ + idooffscreenproxy.h \ libido.h libido_0_1_la_LIBADD = $(GTK_LIBS) diff --git a/src/idooffscreenproxy.c b/src/idooffscreenproxy.c new file mode 100644 index 0000000..50a087d --- /dev/null +++ b/src/idooffscreenproxy.c @@ -0,0 +1,512 @@ +/* + * Copyright 2011 Canonical, Ltd. + * + * This program is free software: you can redistribute it and/or modify it + * under the terms of either or both of the following licenses: + * + * 1) the GNU Lesser General Public License version 3, as published by the + * Free Software Foundation; and/or + * 2) the GNU Lesser General Public License version 2.1, as published by + * the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranties of + * MERCHANTABILITY, SATISFACTORY QUALITY or FITNESS FOR A PARTICULAR + * PURPOSE. See the applicable version of the GNU Lesser General Public + * License for more details. + * + * You should have received a copy of both the GNU Lesser General Public + * License version 3 and version 2.1 along with this program. If not, see + * <http://www.gnu.org/licenses/> + * + * Authors: + * Robert Carr <racarr@canonical.com> + */ + +#include <gtk/gtk.h> +#include "idooffscreenproxy.h" + +struct _IdoOffscreenProxyPrivate +{ + GtkWidget *child; + + GdkWindow *offscreen_window; +}; + +static void ido_offscreen_proxy_realize (GtkWidget *widget); +static void ido_offscreen_proxy_unrealize (GtkWidget *widget); +static void ido_offscreen_proxy_get_preferred_width (GtkWidget *widget, + gint *minimum, + gint *natural); +static void ido_offscreen_proxy_get_preferred_height (GtkWidget *widget, + gint *minimum, + gint *natural); + +static void ido_offscreen_proxy_size_allocate (GtkWidget *widget, + GtkAllocation *allocation); +static gboolean ido_offscreen_proxy_damage (GtkWidget *widget, + GdkEventExpose *event); +static gboolean ido_offscreen_proxy_draw (GtkWidget *widget, + cairo_t *cr); +static void ido_offscreen_proxy_add (GtkContainer *container, + GtkWidget *child); +static void ido_offscreen_proxy_remove (GtkContainer *container, + GtkWidget *widget); +static void ido_offscreen_proxy_forall (GtkContainer *container, + gboolean include_internals, + GtkCallback callback, + gpointer callback_data); +static GType ido_offscreen_proxy_child_type (GtkContainer *container); + +static cairo_surface_t * ido_offscreen_proxy_create_alpha_image_surface (GdkWindow *offscreen, gint width, gint height); + + + +G_DEFINE_TYPE (IdoOffscreenProxy, ido_offscreen_proxy, GTK_TYPE_CONTAINER); + +#define IDO_OFFSCREEN_PROXY_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), IDO_TYPE_OFFSCREEN_PROXY, IdoOffscreenProxyPrivate)) + +static void +ido_offscreen_proxy_class_init (IdoOffscreenProxyClass *klass) +{ + GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass); + GtkContainerClass *container_class = GTK_CONTAINER_CLASS (klass); + + g_type_class_add_private (klass, sizeof (IdoOffscreenProxyPrivate)); + + widget_class->realize = ido_offscreen_proxy_realize; + widget_class->unrealize = ido_offscreen_proxy_unrealize; + widget_class->get_preferred_width = ido_offscreen_proxy_get_preferred_width; + widget_class->get_preferred_height = ido_offscreen_proxy_get_preferred_height; + widget_class->size_allocate = ido_offscreen_proxy_size_allocate; + widget_class->draw = ido_offscreen_proxy_draw; + + g_signal_override_class_closure (g_signal_lookup ("damage-event", GTK_TYPE_WIDGET), + IDO_TYPE_OFFSCREEN_PROXY, + g_cclosure_new (G_CALLBACK (ido_offscreen_proxy_damage), + NULL, NULL)); + + container_class->add = ido_offscreen_proxy_add; + container_class->remove = ido_offscreen_proxy_remove; + container_class->forall = ido_offscreen_proxy_forall; + container_class->child_type = ido_offscreen_proxy_child_type; + +} + +static void +ido_offscreen_proxy_init (IdoOffscreenProxy *proxy) +{ + proxy->priv = IDO_OFFSCREEN_PROXY_GET_PRIVATE (proxy); + + gtk_widget_set_has_window (GTK_WIDGET (proxy), TRUE); + + gtk_widget_set_events (GTK_WIDGET(proxy), gtk_widget_get_events (GTK_WIDGET(proxy)) + | GDK_EXPOSURE_MASK + | GDK_POINTER_MOTION_MASK + | GDK_BUTTON_PRESS_MASK + | GDK_BUTTON_RELEASE_MASK + | GDK_SCROLL_MASK + | GDK_ENTER_NOTIFY_MASK + | GDK_LEAVE_NOTIFY_MASK); + + gtk_container_set_border_width (GTK_CONTAINER (proxy), 0); +} + +GtkWidget * +ido_offscreen_proxy_new (void) +{ + return g_object_new (IDO_TYPE_OFFSCREEN_PROXY, NULL); +} + +static GdkWindow * +pick_offscreen_child (GdkWindow *offscreen_window, + double widget_x, double widget_y, + IdoOffscreenProxy *proxy) +{ + GtkAllocation child_area; + + if (proxy->priv->child && gtk_widget_get_visible (proxy->priv->child)) + { + gtk_widget_get_allocation (proxy->priv->child, &child_area); + + // if (widget_x >= 0 && widget_x < child_area.width && + // widget_y >= 0 && widget_y < child_area.height) + //return proxy->priv->offscreen_window; + return proxy->priv->offscreen_window; + } + + return NULL; +} + +static void +offscreen_to_parent (GdkWindow *offscreen_window, + double offscreen_x, + double offscreen_y, + double *parent_x, + double *parent_y, + gpointer user_data) +{ + *parent_x = offscreen_x; + *parent_y = offscreen_y; +} + +static void +offscreen_from_parent (GdkWindow *window, + double parent_x, + double parent_y, + double *offscreen_x, + double *offscreen_y, + gpointer user_data) +{ + *offscreen_x = parent_x; + *offscreen_y = parent_y; +} + +static cairo_surface_t * +ido_offscreen_proxy_create_alpha_image_surface (GdkWindow *offscreen, gint width, gint height) +{ + return cairo_image_surface_create (CAIRO_FORMAT_ARGB32, width, height); +} + +static void +proxy_add_css (GtkStyleContext *sc) +{ + GtkCssProvider *provider = gtk_css_provider_new(); + const gchar *proxy_css = ".menu.ido-offscreen { \nborder-width: 0;\nborder-radius:0; \n}\n"; + + gtk_css_provider_load_from_data (provider, proxy_css, -1, NULL); + + gtk_style_context_add_provider (sc, GTK_STYLE_PROVIDER (provider), + GTK_STYLE_PROVIDER_PRIORITY_APPLICATION); + +} + +static void +ido_offscreen_proxy_realize (GtkWidget *widget) +{ + IdoOffscreenProxy *proxy = IDO_OFFSCREEN_PROXY (widget); + GtkAllocation allocation, child_area; + GtkStyleContext *context; + GdkWindow *window; + GdkWindowAttr attributes; + gint attributes_mask; + // GtkRequisition child_requisition; + + gtk_widget_set_realized (widget, TRUE); + + gtk_widget_get_allocation (widget, &allocation); + + attributes.x = allocation.x; + attributes.y = allocation.y; + attributes.width = allocation.width; + attributes.height = allocation.height; + + attributes.window_type = GDK_WINDOW_CHILD; + attributes.event_mask = gtk_widget_get_events (widget) + | GDK_EXPOSURE_MASK + | GDK_POINTER_MOTION_MASK + | GDK_BUTTON_PRESS_MASK + | GDK_BUTTON_RELEASE_MASK + | GDK_SCROLL_MASK + | GDK_ENTER_NOTIFY_MASK + | GDK_LEAVE_NOTIFY_MASK; + attributes.visual = gdk_screen_get_rgba_visual (gdk_screen_get_default ());//gtk_widget_get_visual (widget); + attributes.wclass = GDK_INPUT_OUTPUT; + + attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL; + + window = gdk_window_new (gtk_widget_get_parent_window (widget), + &attributes, attributes_mask); + + gtk_widget_set_window (widget, window); + gdk_window_set_user_data (window, widget); + + g_signal_connect (window, "pick-embedded-child", + G_CALLBACK (pick_offscreen_child), proxy); + + attributes.window_type = GDK_WINDOW_OFFSCREEN; + attributes.x = attributes.y = 0; + + if (proxy->priv->child && gtk_widget_get_visible (proxy->priv->child)) + { + gtk_widget_get_allocation (proxy->priv->child, &child_area); + attributes.width = child_area.width; + attributes.height = child_area.height; + } + + proxy->priv->offscreen_window = gdk_window_new (gtk_widget_get_root_window (widget), + &attributes, attributes_mask); + gdk_window_set_user_data (proxy->priv->offscreen_window, widget); + + if (proxy->priv->child) + gtk_widget_set_parent_window (proxy->priv->child, proxy->priv->offscreen_window); + + gdk_offscreen_window_set_embedder (proxy->priv->offscreen_window, + window); + + g_signal_connect(proxy->priv->offscreen_window, "create-surface", + G_CALLBACK (ido_offscreen_proxy_create_alpha_image_surface), + proxy); + g_signal_connect (proxy->priv->offscreen_window, "to-embedder", + G_CALLBACK (offscreen_to_parent), NULL); + g_signal_connect (proxy->priv->offscreen_window, "from-embedder", + G_CALLBACK (offscreen_from_parent), NULL); + + context = gtk_widget_get_style_context (widget); + gtk_style_context_add_class (context, GTK_STYLE_CLASS_MENUITEM); + gtk_style_context_set_background (context, window); + gtk_style_context_set_background (context, proxy->priv->offscreen_window); + gtk_style_context_set_junction_sides (context, GTK_JUNCTION_TOP | GTK_JUNCTION_BOTTOM | GTK_JUNCTION_LEFT | GTK_JUNCTION_RIGHT); + + gtk_widget_set_name (widget, "IdoOffscreenProxy"); + gtk_widget_path_iter_set_name (gtk_widget_get_path (widget), -1, "IdoOffscreenProxy"); + + gdk_window_show (proxy->priv->offscreen_window); +} + +static void +ido_offscreen_proxy_unrealize (GtkWidget *widget) +{ + IdoOffscreenProxy *proxy = IDO_OFFSCREEN_PROXY (widget); + + gdk_window_set_user_data (proxy->priv->offscreen_window, NULL); + gdk_window_destroy (proxy->priv->offscreen_window); + proxy->priv->offscreen_window = NULL; + + GTK_WIDGET_CLASS (ido_offscreen_proxy_parent_class)->unrealize (widget); +} + +static GType +ido_offscreen_proxy_child_type (GtkContainer *container) +{ + IdoOffscreenProxy *proxy = IDO_OFFSCREEN_PROXY (container); + + if (proxy->priv->child) + return G_TYPE_NONE; + + return GTK_TYPE_WIDGET; +} + +static void +ido_offscreen_proxy_add (GtkContainer *container, + GtkWidget *child) +{ + IdoOffscreenProxy *proxy = IDO_OFFSCREEN_PROXY (container); + + if (!proxy->priv->child) + { + gtk_widget_set_parent_window (child, proxy->priv->offscreen_window); + gtk_widget_set_parent (child, GTK_WIDGET (proxy)); + proxy->priv->child = child; + } + else + { + g_warning ("IdoOffscreenProxy can only have a single child\n"); + } +} + +static void +ido_offscreen_proxy_remove (GtkContainer *container, + GtkWidget *widget) +{ + IdoOffscreenProxy *proxy = IDO_OFFSCREEN_PROXY (container); + gboolean was_visible; + + was_visible = gtk_widget_get_visible (widget); + + if (proxy->priv->child == widget) + { + gtk_widget_unparent (widget); + proxy->priv->child = NULL; + + if (was_visible && gtk_widget_get_visible (GTK_WIDGET (container))) + gtk_widget_queue_resize (GTK_WIDGET (container)); + } +} + +static void +ido_offscreen_proxy_forall (GtkContainer *container, + gboolean include_internals, + GtkCallback callback, + gpointer callback_data) +{ + IdoOffscreenProxy *proxy = IDO_OFFSCREEN_PROXY (container); + + g_return_if_fail (callback != NULL); + + if (proxy->priv->child) + (*callback) (proxy->priv->child, callback_data); +} + +static void +ido_offscreen_proxy_size_request (GtkWidget *widget, + GtkRequisition *requisition) +{ + IdoOffscreenProxy *proxy = IDO_OFFSCREEN_PROXY (widget); + int w, h; + + w = 0; + h = 0; + + if (proxy->priv->child && gtk_widget_get_visible (proxy->priv->child)) + { + GtkRequisition child_requisition; + + gtk_widget_get_preferred_size (proxy->priv->child, + &child_requisition, NULL); + w = child_requisition.width; + h = child_requisition.height; + } + + requisition->width = w; + requisition->height = h; + +} + +static void +ido_offscreen_proxy_get_preferred_width (GtkWidget *widget, + gint *minimum, + gint *natural) +{ + GtkRequisition requisition; + + ido_offscreen_proxy_size_request (widget, &requisition); + + *minimum = *natural = requisition.width; +} + +static void +ido_offscreen_proxy_get_preferred_height (GtkWidget *widget, + gint *minimum, + gint *natural) +{ + GtkRequisition requisition; + + ido_offscreen_proxy_size_request (widget, &requisition); + + *minimum = *natural = requisition.height; + +} + +static void +ido_offscreen_proxy_size_allocate (GtkWidget *widget, + GtkAllocation *allocation) +{ + IdoOffscreenProxy *proxy; + + proxy = IDO_OFFSCREEN_PROXY (widget); + + gtk_widget_set_allocation (widget, allocation); + + if (gtk_widget_get_realized (widget)) + { + gdk_window_move_resize (gtk_widget_get_window (widget), + allocation->x, + allocation->y, + allocation->width, + allocation->height); + } + + if (proxy->priv->child && gtk_widget_get_visible (proxy->priv->child)) + { + GtkRequisition child_requisition; + GtkAllocation child_allocation; + + gtk_widget_get_preferred_size (proxy->priv->child, + &child_requisition, NULL); + + child_allocation.x = child_requisition.width; + child_allocation.y = child_requisition.height; + child_allocation.width = allocation->width; + child_allocation.height = allocation->height; + + if (gtk_widget_get_realized (widget)) + gdk_window_move_resize (proxy->priv->offscreen_window, + child_allocation.x, + child_allocation.y, + child_allocation.width+4, + child_allocation.height); + + child_allocation.x = child_allocation.y = 0; + gtk_widget_size_allocate (proxy->priv->child, &child_allocation); + } +} + + +static gboolean +ido_offscreen_proxy_damage (GtkWidget *widget, + GdkEventExpose *event) +{ + gdk_window_invalidate_rect (gtk_widget_get_window (widget), + NULL, FALSE); + return TRUE; +} + +static GtkStyleContext * +get_menu_style_context () +{ + GtkStyleContext *sc; + GtkWidgetPath *path; + + path = gtk_widget_path_new (); + gtk_widget_path_append_type (path, GTK_TYPE_MENU); + + sc = gtk_style_context_new(); + + proxy_add_css (sc); + + gtk_style_context_set_path (sc, path); + gtk_style_context_add_class (sc, GTK_STYLE_CLASS_MENU); + gtk_style_context_add_class (sc, "ido-offscreen"); + + + + gtk_widget_path_free (path); + + return sc; +} + +static gboolean +ido_offscreen_proxy_draw (GtkWidget *widget, + cairo_t *cr) +{ + IdoOffscreenProxy *proxy = IDO_OFFSCREEN_PROXY (widget); + GdkWindow *window; + GtkStyleContext *sc; + + window = gtk_widget_get_window (widget); + + sc = get_menu_style_context(); + + gtk_render_background (sc, cr, + 0, 0, + gdk_window_get_width (window), + gdk_window_get_height (window)); + + g_object_unref (sc); + + + + if (gtk_cairo_should_draw_window (cr, window)) + { + cairo_surface_t *surface; + + if (proxy->priv->child && gtk_widget_get_visible (proxy->priv->child)) + { + surface = gdk_offscreen_window_get_surface (proxy->priv->offscreen_window); + + cairo_set_source_surface (cr, surface, 0, 0); + cairo_paint (cr); + } + } + else if (gtk_cairo_should_draw_window (cr, proxy->priv->offscreen_window)) + { + + if (proxy->priv->child) + gtk_container_propagate_draw (GTK_CONTAINER (widget), + proxy->priv->child, + cr); + } + + return TRUE; +} diff --git a/src/idooffscreenproxy.h b/src/idooffscreenproxy.h new file mode 100644 index 0000000..3071eab --- /dev/null +++ b/src/idooffscreenproxy.h @@ -0,0 +1,62 @@ +/* + * Copyright 2011 Canonical, Ltd. + * + * This program is free software: you can redistribute it and/or modify it + * under the terms of either or both of the following licenses: + * + * 1) the GNU Lesser General Public License version 3, as published by the + * Free Software Foundation; and/or + * 2) the GNU Lesser General Public License version 2.1, as published by + * the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranties of + * MERCHANTABILITY, SATISFACTORY QUALITY or FITNESS FOR A PARTICULAR + * PURPOSE. See the applicable version of the GNU Lesser General Public + * License for more details. + * + * You should have received a copy of both the GNU Lesser General Public + * License version 3 and version 2.1 along with this program. If not, see + * <http://www.gnu.org/licenses/> + * + * Authors: + * Robert Carr <racarr@canonical.com> + */ + +#ifndef __IDO_OFFSCREEN_PROXY_H__ +#define __IDO_OFFSCREEN_PROXy_H__ + +#include <gdk/gdk.h> +#include <gtk/gtk.h> + +G_BEGIN_DECLS + +#define IDO_TYPE_OFFSCREEN_PROXY (ido_offscreen_proxy_get_type ()) +#define IDO_OFFSCREEN_PROXY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), IDO_TYPE_OFFSCREEN_PROXY, IdoOffscreenProxy)) +#define IDO_OFFSCREEN_PROXY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), IDO_TYPE_OFFSCREEN_PROXY, IdoOffscreenProxyClass)) +#define IDO_IS_OFFSCREEN_PROXY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), IDO_TYPE_OFFSCREEN_PROXY)) +#define IDO_IS_OFFSCREEN_PROXY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), IDO_TYPE_OFFSCREEN_PROXY)) +#define IDO_OFFSCREEN_PROXY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), IDO_TYPE_OFFSCREEN_PROXY, IdoOffscreenProxyClass)) + +typedef struct _IdoOffscreenProxy IdoOffscreenProxy; +typedef struct _IdoOffscreenProxyClass IdoOffscreenProxyClass; +typedef struct _IdoOffscreenProxyPrivate IdoOffscreenProxyPrivate; + +struct _IdoOffscreenProxyClass +{ + GtkBinClass parent_class; +}; + +struct _IdoOffscreenProxy +{ + GtkContainer container; + + IdoOffscreenProxyPrivate *priv; +}; + +GType ido_offscreen_proxy_get_type (void) G_GNUC_CONST; +GtkWidget *ido_offscreen_proxy_new (void); + +G_END_DECLS + +#endif diff --git a/src/idoscalemenuitem.c b/src/idoscalemenuitem.c index 8b9e1ac..3f27c57 100644 --- a/src/idoscalemenuitem.c +++ b/src/idoscalemenuitem.c @@ -26,6 +26,7 @@ #include <gtk/gtk.h> #include "idorange.h" #include "idoscalemenuitem.h" +#include "idooffscreenproxy.h" #include "idotypebuiltins.h" static void ido_scale_menu_item_set_property (GObject *object, @@ -57,6 +58,7 @@ static void update_packing (IdoScaleMenuItem struct _IdoScaleMenuItemPrivate { GtkWidget *scale; + GtkWidget *proxy; GtkAdjustment *adjustment; GtkWidget *primary_image; GtkWidget *secondary_image; @@ -226,6 +228,12 @@ ido_scale_menu_item_constructed (GObject *object) priv->scale = ido_range_new (adj, range_style); g_object_ref (priv->scale); gtk_scale_set_draw_value (GTK_SCALE (priv->scale), FALSE); + + gtk_widget_set_can_focus (priv->scale, FALSE); + + priv->proxy = ido_offscreen_proxy_new (); + g_object_ref (priv->proxy); + gtk_container_add (GTK_CONTAINER (priv->proxy), priv->scale); hbox = gtk_hbox_new (FALSE, 0); @@ -338,23 +346,23 @@ update_packing (IdoScaleMenuItem *self, IdoScaleMenuItemStyle style, IdoScaleMen switch (old_style) { case IDO_SCALE_MENU_ITEM_STYLE_NONE: - gtk_container_remove (container, priv->scale); + gtk_container_remove (container, priv->proxy); break; case IDO_SCALE_MENU_ITEM_STYLE_IMAGE: gtk_container_remove (container, priv->primary_image); gtk_container_remove (container, priv->secondary_image); - gtk_container_remove (container, priv->scale); + gtk_container_remove (container, priv->proxy); break; case IDO_SCALE_MENU_ITEM_STYLE_LABEL: gtk_container_remove (container, priv->primary_label); gtk_container_remove (container, priv->secondary_label); - gtk_container_remove (container, priv->scale); + gtk_container_remove (container, priv->proxy); break; default: - gtk_container_remove (container, priv->scale); + gtk_container_remove (container, priv->proxy); break; } } @@ -362,23 +370,23 @@ update_packing (IdoScaleMenuItem *self, IdoScaleMenuItemStyle style, IdoScaleMen switch (style) { case IDO_SCALE_MENU_ITEM_STYLE_NONE: - gtk_box_pack_start (GTK_BOX (priv->hbox), priv->scale, FALSE, FALSE, 0); + gtk_box_pack_start (GTK_BOX (priv->hbox), priv->proxy, FALSE, FALSE, 0); break; case IDO_SCALE_MENU_ITEM_STYLE_IMAGE: gtk_box_pack_start (GTK_BOX (priv->hbox), priv->primary_image, FALSE, FALSE, 0); - gtk_box_pack_start (GTK_BOX (priv->hbox), priv->scale, FALSE, FALSE, 0); + gtk_box_pack_start (GTK_BOX (priv->hbox), priv->proxy, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (priv->hbox), priv->secondary_image, FALSE, FALSE, 0); break; case IDO_SCALE_MENU_ITEM_STYLE_LABEL: gtk_box_pack_start (GTK_BOX (priv->hbox), priv->primary_label, FALSE, FALSE, 0); - gtk_box_pack_start (GTK_BOX (priv->hbox), priv->scale, FALSE, FALSE, 0); + gtk_box_pack_start (GTK_BOX (priv->hbox), priv->proxy, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (priv->hbox), priv->secondary_label, FALSE, FALSE, 0); break; default: - gtk_box_pack_start (GTK_BOX (priv->hbox), priv->scale, FALSE, FALSE, 0); + gtk_box_pack_start (GTK_BOX (priv->hbox), priv->proxy, FALSE, FALSE, 0); break; } @@ -469,7 +477,6 @@ ido_scale_menu_item_button_press_event (GtkWidget *menuitem, GdkEventButton *event) { IdoScaleMenuItemPrivate *priv = GET_PRIVATE (menuitem); - GtkWidget *scale = priv->scale; gdouble x; // can we block emissions of "grab-notify" on parent?? @@ -480,12 +487,12 @@ ido_scale_menu_item_button_press_event (GtkWidget *menuitem, translate_event_coordinates (menuitem, event->x_root, &x); event->x_root = x; - ubuntu_gtk_widget_set_has_grab (scale, TRUE); + // ubuntu_gtk_widget_set_has_grab (scale, TRUE); - gtk_widget_event (scale, + gtk_widget_event (priv->scale, ((GdkEvent *)(void*)(event))); - ubuntu_gtk_widget_set_has_grab (scale, FALSE); + // ubuntu_gtk_widget_set_has_grab (scale, FALSE); if (!priv->grabbed) { @@ -493,7 +500,7 @@ ido_scale_menu_item_button_press_event (GtkWidget *menuitem, g_signal_emit (menuitem, signals[SLIDER_GRABBED], 0); } - return TRUE; + return FALSE; } static gboolean |