aboutsummaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/Makefile.am7
-rw-r--r--src/idooffscreenproxy.c512
-rw-r--r--src/idooffscreenproxy.h62
-rw-r--r--src/idoscalemenuitem.c33
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