[dualscreen][presentation] fix Issue #9

[evince.git] / cut-n-paste / gimpcellrenderertoggle / gimpcellrenderertoggle.c

diff --git a/cut-n-paste/gimpcellrenderertoggle/gimpcellrenderertoggle.c b/cut-n-paste/gimpcellrenderertoggle/gimpcellrenderertoggle.c
index d60f01ee658cf86d6334fb1ecbf669175d126efe..8ef02bdf2fd2a66510cd6d325b8f7cff779a525c 100644 (file)
--- a/cut-n-paste/gimpcellrenderertoggle/gimpcellrenderertoggle.c
+++ b/cut-n-paste/gimpcellrenderertoggle/gimpcellrenderertoggle.c
@@ -54,24 +54,23 @@ static void gimp_cell_renderer_toggle_set_property (GObject         *object,
                                                     GParamSpec      *pspec);
 static void gimp_cell_renderer_toggle_get_size     (GtkCellRenderer *cell,
                                                     GtkWidget       *widget,
                                                     GParamSpec      *pspec);
 static void gimp_cell_renderer_toggle_get_size     (GtkCellRenderer *cell,
                                                     GtkWidget       *widget,

-                                                    GdkRectangle    *rectangle,
+                                                    const GdkRectangle *rectangle,

                                                     gint            *x_offset,
                                                     gint            *y_offset,
                                                     gint            *width,
                                                     gint            *height);
 static void gimp_cell_renderer_toggle_render       (GtkCellRenderer *cell,
                                                     gint            *x_offset,
                                                     gint            *y_offset,
                                                     gint            *width,
                                                     gint            *height);
 static void gimp_cell_renderer_toggle_render       (GtkCellRenderer *cell,

-                                                    GdkWindow       *window,
+                                                    cairo_t         *cr,

                                                     GtkWidget       *widget,
                                                     GtkWidget       *widget,

-                                                    GdkRectangle    *background_area,
-                                                    GdkRectangle    *cell_area,
-                                                    GdkRectangle    *expose_area,
+                                                    const GdkRectangle  *background_area,
+                                                    const GdkRectangle  *cell_area,

                                                     GtkCellRendererState flags);
 static gboolean gimp_cell_renderer_toggle_activate (GtkCellRenderer *cell,
                                                     GdkEvent        *event,
                                                     GtkWidget       *widget,
                                                     const gchar     *path,
                                                     GtkCellRendererState flags);
 static gboolean gimp_cell_renderer_toggle_activate (GtkCellRenderer *cell,
                                                     GdkEvent        *event,
                                                     GtkWidget       *widget,
                                                     const gchar     *path,

-                                                    GdkRectangle    *background_area,
-                                                    GdkRectangle    *cell_area,
+                                                    const GdkRectangle *background_area,
+                                                    const GdkRectangle *cell_area,

                                                     GtkCellRendererState  flags);
 static void gimp_cell_renderer_toggle_create_pixbuf (GimpCellRendererToggle *toggle,
                                                      GtkWidget              *widget);
                                                     GtkCellRendererState  flags);
 static void gimp_cell_renderer_toggle_create_pixbuf (GimpCellRendererToggle *toggle,
                                                      GtkWidget              *widget);


@@ -207,20 +206,25 @@ gimp_cell_renderer_toggle_set_property (GObject      *object,
 }
 
 static void
 }
 
 static void

-gimp_cell_renderer_toggle_get_size (GtkCellRenderer *cell,
-                                    GtkWidget       *widget,
-                                    GdkRectangle    *cell_area,
-                                    gint            *x_offset,
-                                    gint            *y_offset,
-                                    gint            *width,
-                                    gint            *height)
+gimp_cell_renderer_toggle_get_size (GtkCellRenderer    *cell,
+                                    GtkWidget          *widget,
+                                    const GdkRectangle *cell_area,
+                                    gint               *x_offset,
+                                    gint               *y_offset,
+                                    gint               *width,
+                                    gint               *height)

 {
   GimpCellRendererToggle *toggle = GIMP_CELL_RENDERER_TOGGLE (cell);
 {
   GimpCellRendererToggle *toggle = GIMP_CELL_RENDERER_TOGGLE (cell);

-  GtkStyle               *style  = gtk_widget_get_style (widget);
+  GtkStyleContext        *context  = gtk_widget_get_style_context (widget);
+  GtkBorder               border;

   gint                    calc_width;
   gint                    calc_height;
   gint                    pixbuf_width;
   gint                    pixbuf_height;
   gint                    calc_width;
   gint                    calc_height;
   gint                    pixbuf_width;
   gint                    pixbuf_height;

+  gfloat                  xalign;
+  gfloat                  yalign;
+  gint                    xpad;
+  gint                    ypad;

 
   if (! toggle->stock_id)
     {
 
   if (! toggle->stock_id)
     {


@@ -232,16 +236,19 @@ gimp_cell_renderer_toggle_get_size (GtkCellRenderer *cell,
       return;
     }
 
       return;
     }
 

+  gtk_cell_renderer_get_alignment (cell, &xalign, &yalign);
+  gtk_cell_renderer_get_padding (cell, &xpad, &ypad);
+
+  gtk_style_context_get_border (context, 0, &border);
+

   if (! toggle->pixbuf)
     gimp_cell_renderer_toggle_create_pixbuf (toggle, widget);
 
   pixbuf_width  = gdk_pixbuf_get_width  (toggle->pixbuf);
   pixbuf_height = gdk_pixbuf_get_height (toggle->pixbuf);
 
   if (! toggle->pixbuf)
     gimp_cell_renderer_toggle_create_pixbuf (toggle, widget);
 
   pixbuf_width  = gdk_pixbuf_get_width  (toggle->pixbuf);
   pixbuf_height = gdk_pixbuf_get_height (toggle->pixbuf);
 

-  calc_width  = (pixbuf_width +
-                 (gint) cell->xpad * 2 + style->xthickness * 2);
-  calc_height = (pixbuf_height +
-                 (gint) cell->ypad * 2 + style->ythickness * 2);
+  calc_width  = (pixbuf_width + (gint) xpad * 2 + (border.left + border.right));
+  calc_height = (pixbuf_height + (gint) ypad * 2 + (border.top + border.bottom));

 
   if (width)
     *width  = calc_width;
 
   if (width)
     *width  = calc_width;


@@ -254,14 +261,14 @@ gimp_cell_renderer_toggle_get_size (GtkCellRenderer *cell,
       if (x_offset)
         {
           *x_offset = (((gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL) ?
       if (x_offset)
         {
           *x_offset = (((gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL) ?

-                        (1.0 - cell->xalign) : cell->xalign) *
+                        (1.0 - xalign) : xalign) *

                        (cell_area->width - calc_width));
           *x_offset = MAX (*x_offset, 0);
         }
 
       if (y_offset)
         {
                        (cell_area->width - calc_width));
           *x_offset = MAX (*x_offset, 0);
         }
 
       if (y_offset)
         {

-          *y_offset = cell->yalign * (cell_area->height - calc_height);
+          *y_offset = yalign * (cell_area->height - calc_height);

           *y_offset = MAX (*y_offset, 0);
         }
     }
           *y_offset = MAX (*y_offset, 0);
         }
     }


@@ -269,39 +276,44 @@ gimp_cell_renderer_toggle_get_size (GtkCellRenderer *cell,
 
 static void
 gimp_cell_renderer_toggle_render (GtkCellRenderer      *cell,
 
 static void
 gimp_cell_renderer_toggle_render (GtkCellRenderer      *cell,

-                                  GdkWindow            *window,
+                                  cairo_t              *cr,

                                   GtkWidget            *widget,
                                   GtkWidget            *widget,

-                                  GdkRectangle         *background_area,
-                                  GdkRectangle         *cell_area,
-                                  GdkRectangle         *expose_area,
+                                  const GdkRectangle   *background_area,
+                                  const GdkRectangle   *cell_area,

                                   GtkCellRendererState  flags)
 {
   GimpCellRendererToggle *toggle = GIMP_CELL_RENDERER_TOGGLE (cell);
                                   GtkCellRendererState  flags)
 {
   GimpCellRendererToggle *toggle = GIMP_CELL_RENDERER_TOGGLE (cell);

-  GtkStyle               *style  = gtk_widget_get_style (widget);
+  GtkStyleContext        *context = gtk_widget_get_style_context (widget);

   GdkRectangle            toggle_rect;
   GdkRectangle            draw_rect;
   GdkRectangle            toggle_rect;
   GdkRectangle            draw_rect;

-  GtkStateType            state;
+  GdkRectangle            clip_rect;
+  GtkStateFlags           state;

   gboolean                active;
   gboolean                active;

+  gint                    xpad;
+  gint                    ypad;

 
   if (! toggle->stock_id)
     {
 
   if (! toggle->stock_id)
     {

-      GTK_CELL_RENDERER_CLASS (parent_class)->render (cell, window, widget,
+      GTK_CELL_RENDERER_CLASS (parent_class)->render (cell,
+                                                      cr,
+                                                      widget,

                                                       background_area,
                                                       background_area,

-                                                      cell_area, expose_area,
+                                                      cell_area,

                                                       flags);
       return;
     }
 
                                                       flags);
       return;
     }
 

-  gimp_cell_renderer_toggle_get_size (cell, widget, cell_area,
-                                      &toggle_rect.x,
-                                      &toggle_rect.y,
-                                      &toggle_rect.width,
-                                      &toggle_rect.height);
+  gtk_cell_renderer_get_size (cell, widget, cell_area,
+                              &toggle_rect.x,
+                              &toggle_rect.y,
+                              &toggle_rect.width,
+                              &toggle_rect.height);

 
 

-  toggle_rect.x      += cell_area->x + cell->xpad;
-  toggle_rect.y      += cell_area->y + cell->ypad;
-  toggle_rect.width  -= cell->xpad * 2;
-  toggle_rect.height -= cell->ypad * 2;
+  gtk_cell_renderer_get_padding (cell, &xpad, &ypad);
+  toggle_rect.x      += cell_area->x + xpad;
+  toggle_rect.y      += cell_area->y + ypad;
+  toggle_rect.width  -= xpad * 2;
+  toggle_rect.height -= ypad * 2;

 
   if (toggle_rect.width <= 0 || toggle_rect.height <= 0)
     return;
 
   if (toggle_rect.width <= 0 || toggle_rect.height <= 0)
     return;


@@ -309,47 +321,61 @@ gimp_cell_renderer_toggle_render (GtkCellRenderer      *cell,
   active =
     gtk_cell_renderer_toggle_get_active (GTK_CELL_RENDERER_TOGGLE (cell));
 
   active =
     gtk_cell_renderer_toggle_get_active (GTK_CELL_RENDERER_TOGGLE (cell));
 

-  if (!cell->sensitive)
+  if (!gtk_cell_renderer_get_sensitive (cell))

     {
     {

-      state = GTK_STATE_INSENSITIVE;
+      state = GTK_STATE_FLAG_INSENSITIVE;

     }
   else if ((flags & GTK_CELL_RENDERER_SELECTED) == GTK_CELL_RENDERER_SELECTED)
     {
       if (gtk_widget_has_focus (widget))
     }
   else if ((flags & GTK_CELL_RENDERER_SELECTED) == GTK_CELL_RENDERER_SELECTED)
     {
       if (gtk_widget_has_focus (widget))

-        state = GTK_STATE_SELECTED;
+        state = GTK_STATE_FLAG_SELECTED;

       else
       else

-        state = GTK_STATE_ACTIVE;
+        state = GTK_STATE_FLAG_ACTIVE;

     }
   else
     {
     }
   else
     {

-      if (GTK_CELL_RENDERER_TOGGLE (cell)->activatable)
-        state = GTK_STATE_NORMAL;
+      if (gtk_cell_renderer_toggle_get_activatable (GTK_CELL_RENDERER_TOGGLE (cell)))
+        state = 0;

       else
       else

-        state = GTK_STATE_INSENSITIVE;
+        state = GTK_STATE_FLAG_INSENSITIVE;

     }
 
     }
 

-  if (gdk_rectangle_intersect (expose_area, cell_area, &draw_rect) &&
-      (flags & GTK_CELL_RENDERER_PRELIT))
-    gtk_paint_shadow (style,
-                      window,
-                      state,
-                      active ? GTK_SHADOW_IN : GTK_SHADOW_OUT,
-                      &draw_rect,
-                      widget, NULL,
-                      toggle_rect.x,     toggle_rect.y,
-                      toggle_rect.width, toggle_rect.height);
+  if ((flags & GTK_CELL_RENDERER_PRELIT) &&
+      gdk_cairo_get_clip_rectangle(cr, &clip_rect) &&
+      gdk_rectangle_intersect (&clip_rect, cell_area, &draw_rect))
+    {
+      cairo_save (cr);
+      gtk_style_context_save (context);
+      gdk_cairo_rectangle (cr, &draw_rect);
+      cairo_clip (cr);
+      gtk_render_frame (context, //gtk_widget_get_style_context (widget),
+                        cr,
+                        toggle_rect.x, toggle_rect.y,
+                        toggle_rect.width, toggle_rect.height);
+      gtk_style_context_restore (context);
+      cairo_restore (cr);
+    }

 
   if (active)
     {
       GdkPixbuf *insensitive = NULL;
       GdkPixbuf *pixbuf = toggle->pixbuf;
 
   if (active)
     {
       GdkPixbuf *insensitive = NULL;
       GdkPixbuf *pixbuf = toggle->pixbuf;

-      
-      toggle_rect.x      += style->xthickness;
-      toggle_rect.y      += style->ythickness;
-      toggle_rect.width  -= style->xthickness * 2;
-      toggle_rect.height -= style->ythickness * 2;
-
-      if (state == GTK_STATE_INSENSITIVE)
+      GtkBorder  border = { 1, 1, 1, 1 };
+
+#if 0
+      /* FIXME: for some reason calling gtk_style_context_get_border
+       * makes the icon only visible on hover, so use border = 1
+       * for now as a workaround
+       */
+      gtk_style_context_get_border (context, state, &border);
+#endif
+
+      toggle_rect.x      += border.left;
+      toggle_rect.y      += border.top;
+      toggle_rect.width  -= (border.left + border.right);
+      toggle_rect.height -= (border.top + border.bottom);
+
+      if (state & GTK_STATE_FLAG_INSENSITIVE)

         {
          GtkIconSource *source;
 
         {
          GtkIconSource *source;
 


@@ -362,14 +388,10 @@ gimp_cell_renderer_toggle_render (GtkCellRenderer      *cell,
          gtk_icon_source_set_size (source, GTK_ICON_SIZE_SMALL_TOOLBAR);
          gtk_icon_source_set_size_wildcarded (source, FALSE);
 
          gtk_icon_source_set_size (source, GTK_ICON_SIZE_SMALL_TOOLBAR);
          gtk_icon_source_set_size_wildcarded (source, FALSE);
 

-         insensitive = gtk_style_render_icon (widget->style,
-                                              source,
-                                              gtk_widget_get_direction (widget),
-                                              GTK_STATE_INSENSITIVE,
-                                              /* arbitrary */
-                                              (GtkIconSize)-1,
-                                              widget,
-                                              "gimpcellrenderertoggle");
+          gtk_style_context_save (context);
+          gtk_style_context_set_state (context, GTK_STATE_FLAG_INSENSITIVE);
+          insensitive = gtk_render_icon_pixbuf (context, source, (GtkIconSize)-1);
+          gtk_style_context_restore (context);

 
          gtk_icon_source_free (source);
 
 
          gtk_icon_source_free (source);
 


@@ -378,17 +400,11 @@ gimp_cell_renderer_toggle_render (GtkCellRenderer      *cell,
 
       if (gdk_rectangle_intersect (&draw_rect, &toggle_rect, &draw_rect))
         {
 
       if (gdk_rectangle_intersect (&draw_rect, &toggle_rect, &draw_rect))
         {

-         cairo_t *cr;
-         
-         cr = gdk_cairo_create (window);
-

          gdk_cairo_set_source_pixbuf (cr, pixbuf, toggle_rect.x, toggle_rect.y);
          gdk_cairo_rectangle (cr, &draw_rect);
          cairo_fill (cr);
          gdk_cairo_set_source_pixbuf (cr, pixbuf, toggle_rect.x, toggle_rect.y);
          gdk_cairo_rectangle (cr, &draw_rect);
          cairo_fill (cr);

-         
-         cairo_destroy (cr);

        }
        }

-             
+

       if (insensitive)
         g_object_unref (insensitive);
     }
       if (insensitive)
         g_object_unref (insensitive);
     }


@@ -399,13 +415,13 @@ gimp_cell_renderer_toggle_activate (GtkCellRenderer      *cell,
                                     GdkEvent             *event,
                                     GtkWidget            *widget,
                                     const gchar          *path,
                                     GdkEvent             *event,
                                     GtkWidget            *widget,
                                     const gchar          *path,

-                                    GdkRectangle         *background_area,
-                                    GdkRectangle         *cell_area,
+                                    const GdkRectangle   *background_area,
+                                    const GdkRectangle   *cell_area,

                                     GtkCellRendererState  flags)
 {
   GtkCellRendererToggle *toggle = GTK_CELL_RENDERER_TOGGLE (cell);
 
                                     GtkCellRendererState  flags)
 {
   GtkCellRendererToggle *toggle = GTK_CELL_RENDERER_TOGGLE (cell);
 

-  if (toggle->activatable)
+  if (gtk_cell_renderer_toggle_get_activatable (toggle))

     {
       GdkModifierType state = 0;
 
     {
       GdkModifierType state = 0;
 


@@ -432,9 +448,9 @@ gimp_cell_renderer_toggle_create_pixbuf (GimpCellRendererToggle *toggle,
   if (toggle->pixbuf)
     g_object_unref (toggle->pixbuf);
 
   if (toggle->pixbuf)
     g_object_unref (toggle->pixbuf);
 

-  toggle->pixbuf = gtk_widget_render_icon (widget,
-                                           toggle->stock_id,
-                                           toggle->stock_size, NULL);
+  toggle->pixbuf = gtk_widget_render_icon_pixbuf (widget,
+                                                  toggle->stock_id,
+                                                  toggle->stock_size);

 }
 
 
 }