aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--.bzrignore29
-rw-r--r--configure.ac3
-rw-r--r--src/Makefile.am24
-rw-r--r--src/idocalendarmenuitem.c61
-rw-r--r--src/idooffscreenproxy.c512
-rw-r--r--src/idooffscreenproxy.h62
-rw-r--r--src/idoscalemenuitem.c77
7 files changed, 743 insertions, 25 deletions
diff --git a/.bzrignore b/.bzrignore
new file mode 100644
index 0000000..7d5438e
--- /dev/null
+++ b/.bzrignore
@@ -0,0 +1,29 @@
+compile
+gtk-doc.make
+libido.pc
+libido3-0.1.pc
+libido3.pc
+build/autotools/gtk-doc.m4
+build/autotools/libtool.m4
+build/autotools/ltoptions.m4
+build/autotools/ltsugar.m4
+build/autotools/ltversion.m4
+build/autotools/lt~obsolete.m4
+build/autotools/shave
+build/autotools/shave-libtool
+example/.deps
+example/.libs
+example/menus
+example/messagedialog
+src/idocalendarmenuitem.lo
+src/idoentrymenuitem.lo
+src/idomessagedialog.lo
+src/idooffscreenproxy.lo
+src/idorange.lo
+src/idoscalemenuitem.lo
+src/idotimeline.lo
+src/idotypebuiltins.c
+src/idotypebuiltins.h
+src/idotypebuiltins.lo
+src/libido3-0.1.la
+src/stamp-idotypebuiltins.h
diff --git a/configure.ac b/configure.ac
index 3694e3e..a712bd8 100644
--- a/configure.ac
+++ b/configure.ac
@@ -3,7 +3,7 @@
#
m4_define([ido_major_version], [0])
m4_define([ido_minor_version], [2])
-m4_define([ido_micro_version], [90])
+m4_define([ido_micro_version], [92])
m4_define([ido_api_version],
[ido_major_version.ido_minor_version])
@@ -88,6 +88,7 @@ if test "x$with_gtk" = "x2"; then
PKG_CHECK_MODULES(GTK, gtk+-2.0 >= 2.19.7)
else
PKG_CHECK_MODULES(GTK, gtk+-3.0 >= 3.0.0)
+ AC_DEFINE_UNQUOTED(USE_GTK3, , [Use GTK3])
fi
AC_SUBST(GTK_CFLAGS)
AC_SUBST(GTK_LIBS)
diff --git a/src/Makefile.am b/src/Makefile.am
index 5ac5a01..ac34bf4 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -20,13 +20,21 @@ sources_h = \
idorange.h \
idoscalemenuitem.h \
idotimeline.h \
- libido.h
+ libido.h
EXTRA_DIST = \
ido.list \
idotypebuiltins.h.template \
idotypebuiltins.c.template
+
+if USE_GTK3
+sources_h += idooffscreenproxy.h
+else
+EXTRA_DIST += idooffscreenproxy.h \
+ idooffscreenproxy.c
+endif
+
idotypebuiltins.h: stamp-idotypebuiltins.h
stamp-idotypebuiltins.h: $(sources_h)
@@ -53,7 +61,8 @@ INCLUDES = \
AM_CPPFLAGS = \
$(GCC_FLAGS) \
$(GTK_CFLAGS) \
- $(MAINTAINER_CFLAGS)
+ $(MAINTAINER_CFLAGS) \
+ -Wall -Werror -Wextra -Wno-unused-parameter
libido_0_1_la_SOURCES = \
idotypebuiltins.c \
@@ -62,7 +71,12 @@ libido_0_1_la_SOURCES = \
idomessagedialog.c \
idorange.c \
idoscalemenuitem.c \
- idotimeline.c
+ idotimeline.c
+
+if USE_GTK3
+libido_0_1_la_SOURCES += idooffscreenproxy.c
+endif
+
libido3_0_1_la_SOURCES = $(libido_0_1_la_SOURCES)
libidoincludedir=$(includedir)/libido$(VER)-0.1/libido
@@ -76,6 +90,10 @@ libidoinclude_HEADERS = \
idotimeline.h \
libido.h
+if USE_GTK3
+libidoinclude_HEADERS += idooffscreenproxy.h
+endif
+
libido_0_1_la_LIBADD = $(GTK_LIBS)
libido_0_1_la_LDFLAGS = $(GTK_LT_LDFLAGS)
libido3_0_1_la_LIBADD = $(libido_0_1_la_LIBADD)
diff --git a/src/idocalendarmenuitem.c b/src/idocalendarmenuitem.c
index 6d5c077..40d96a1 100644
--- a/src/idocalendarmenuitem.c
+++ b/src/idocalendarmenuitem.c
@@ -196,31 +196,62 @@ static gboolean
ido_calendar_menu_item_button_press (GtkWidget *widget,
GdkEventButton *event)
{
- GtkWidget *calendar = IDO_CALENDAR_MENU_ITEM (widget)->priv->calendar;
+ GtkWidget *calendar = IDO_CALENDAR_MENU_ITEM (widget)->priv->calendar;
- if (event->button == 1)
- {
- if (gtk_widget_get_window (calendar) != NULL)
- {
- gdk_window_raise (gtk_widget_get_window (calendar));
- }
+ if (event->button == 1) {
+ if (gtk_widget_get_window (calendar) != NULL) {
+ gdk_window_raise (gtk_widget_get_window (calendar));
+ }
- if (!gtk_widget_has_focus (calendar))
- {
- gtk_widget_grab_focus (calendar);
- }
+ if (!gtk_widget_has_focus (calendar)) {
+ gtk_widget_grab_focus (calendar);
+ }
- return TRUE;
- }
+#if GTK_CHECK_VERSION (3, 0, 0)
+ GdkEvent * newevent = gdk_event_copy((GdkEvent *)(event));
+ GList * children = gdk_window_get_children(gtk_widget_get_window(calendar));
+ GList * child;
- return FALSE;
+ gint root_x = event->x_root;
+ gint root_y = event->y_root;
+
+ for (child = children; child != NULL; child = g_list_next(child)) {
+ gint newx, newy;
+ gint winx, winy;
+ GdkWindow * newwindow = (GdkWindow*)child->data;
+
+ ((GdkEventButton *)newevent)->window = newwindow;
+
+ gdk_window_get_origin(newwindow, &winx, &winy);
+ newx = root_x - winx;
+ newy = root_y - winy;
+
+ if (newx >= 0 && newy >= 0 && newx < gdk_window_get_width(newwindow) && newy < gdk_window_get_height(newwindow)) {
+ ((GdkEventButton *)newevent)->x = newx;
+ ((GdkEventButton *)newevent)->y = newy;
+
+ GTK_WIDGET_GET_CLASS(calendar)->button_press_event(GTK_WIDGET(calendar), (GdkEventButton*)newevent);
+ }
+ }
+
+ ((GdkEventButton *)newevent)->window = event->window;
+ gdk_event_free(newevent);
+#endif
+
+ return TRUE;
+ }
+
+ return FALSE;
}
static gboolean
ido_calendar_menu_item_button_release (GtkWidget *widget,
GdkEventButton *event)
{
- // GtkWidget *calendar = IDO_CALENDAR_MENU_ITEM (widget)->priv->calendar;
+#if GTK_CHECK_VERSION (3, 0, 0)
+ GtkWidget *calendar = IDO_CALENDAR_MENU_ITEM (widget)->priv->calendar;
+ GTK_WIDGET_GET_CLASS(calendar)->button_release_event(GTK_WIDGET(calendar), event);
+#endif
return TRUE;
}
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..8a55299 100644
--- a/src/idoscalemenuitem.c
+++ b/src/idoscalemenuitem.c
@@ -23,11 +23,18 @@
* Cody Russell <crussell@canonical.com>
*/
+#include "config.h"
+
+
#include <gtk/gtk.h>
#include "idorange.h"
#include "idoscalemenuitem.h"
#include "idotypebuiltins.h"
+#ifdef USE_GTK3
+#include "idooffscreenproxy.h"
+#endif
+
static void ido_scale_menu_item_set_property (GObject *object,
guint prop_id,
const GValue *value,
@@ -57,6 +64,11 @@ static void update_packing (IdoScaleMenuItem
struct _IdoScaleMenuItemPrivate {
GtkWidget *scale;
+
+#ifdef USE_GTK3
+ GtkWidget *proxy;
+#endif
+
GtkAdjustment *adjustment;
GtkWidget *primary_image;
GtkWidget *secondary_image;
@@ -226,6 +238,14 @@ 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);
+
+#ifdef USE_GTK3
+ 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);
+#endif
hbox = gtk_hbox_new (FALSE, 0);
@@ -338,23 +358,39 @@ update_packing (IdoScaleMenuItem *self, IdoScaleMenuItemStyle style, IdoScaleMen
switch (old_style)
{
case IDO_SCALE_MENU_ITEM_STYLE_NONE:
- gtk_container_remove (container, priv->scale);
+#ifdef USE_GTK3
+ gtk_container_remove (container, priv->proxy);
+#else
+ gtk_container_remove (container, priv->scale);
+#endif
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);
+#ifdef USE_GTK3
+ gtk_container_remove (container, priv->proxy);
+#else
+ gtk_container_remove (container, priv->scale);
+#endif
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);
+#ifdef USE_GTK3
+ gtk_container_remove (container, priv->proxy);
+#else
+ gtk_container_remove (container, priv->scale);
+#endif
break;
default:
- gtk_container_remove (container, priv->scale);
+#ifdef USE_GTK3
+ gtk_container_remove (container, priv->proxy);
+#else
+ gtk_container_remove (container, priv->scale);
+#endif
break;
}
}
@@ -362,23 +398,41 @@ update_packing (IdoScaleMenuItem *self, IdoScaleMenuItemStyle style, IdoScaleMen
switch (style)
{
case IDO_SCALE_MENU_ITEM_STYLE_NONE:
+#ifdef USE_GTK3
+ gtk_box_pack_start (GTK_BOX (priv->hbox), priv->proxy, FALSE, FALSE, 0);
+#else
gtk_box_pack_start (GTK_BOX (priv->hbox), priv->scale, FALSE, FALSE, 0);
+#endif
break;
case IDO_SCALE_MENU_ITEM_STYLE_IMAGE:
gtk_box_pack_start (GTK_BOX (priv->hbox), priv->primary_image, FALSE, FALSE, 0);
+
+#ifdef USE_GTK3
+ gtk_box_pack_start (GTK_BOX (priv->hbox), priv->proxy, FALSE, FALSE, 0);
+#else
gtk_box_pack_start (GTK_BOX (priv->hbox), priv->scale, FALSE, FALSE, 0);
+#endif
+
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);
+#ifdef USE_GTK3
+ gtk_box_pack_start (GTK_BOX (priv->hbox), priv->proxy, FALSE, FALSE, 0);
+#else
gtk_box_pack_start (GTK_BOX (priv->hbox), priv->scale, FALSE, FALSE, 0);
+#endif
gtk_box_pack_start (GTK_BOX (priv->hbox), priv->secondary_label, FALSE, FALSE, 0);
break;
default:
+#ifdef USE_GTK3
+ gtk_box_pack_start (GTK_BOX (priv->hbox), priv->proxy, FALSE, FALSE, 0);
+#else
gtk_box_pack_start (GTK_BOX (priv->hbox), priv->scale, FALSE, FALSE, 0);
+#endif
break;
}
@@ -469,8 +523,11 @@ ido_scale_menu_item_button_press_event (GtkWidget *menuitem,
GdkEventButton *event)
{
IdoScaleMenuItemPrivate *priv = GET_PRIVATE (menuitem);
- GtkWidget *scale = priv->scale;
gdouble x;
+
+#ifndef USE_GTK3
+ GtkWidget *scale = priv->scale;
+#endif
// can we block emissions of "grab-notify" on parent??
@@ -480,12 +537,16 @@ ido_scale_menu_item_button_press_event (GtkWidget *menuitem,
translate_event_coordinates (menuitem, event->x_root, &x);
event->x_root = x;
+#ifndef USE_GTK3
ubuntu_gtk_widget_set_has_grab (scale, TRUE);
+#endif
- gtk_widget_event (scale,
+ gtk_widget_event (priv->scale,
((GdkEvent *)(void*)(event)));
+#ifndef USE_GTK3
ubuntu_gtk_widget_set_has_grab (scale, FALSE);
+#endif
if (!priv->grabbed)
{
@@ -493,7 +554,11 @@ ido_scale_menu_item_button_press_event (GtkWidget *menuitem,
g_signal_emit (menuitem, signals[SLIDER_GRABBED], 0);
}
+#ifdef USE_GTK3
+ return FALSE;
+#else
return TRUE;
+#endif
}
static gboolean