Merge lp:~robertcarr/ido/offscreen-scale

1 files changed, 512 insertions, 0 deletions

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;
+}