GNOME.org
 

[libwnck/wip/muktupavels/wnck-handle: 3/9] handle: add set_default_icon_size and set_default_mini_icon_size

commit 6e78840fd1337b9980fefc339090d51e9c9edfd7
Author: Alberts Muktupāvels <alberts muktupavels gmail com>
Date:   Mon Aug 19 18:23:57 2019 +0300

    handle: add set_default_icon_size and set_default_mini_icon_size
    
    And deprecate old functions.

 libwnck/application.c         | 10 ++++---
 libwnck/class-group.c         | 23 +++++++++++-----
 libwnck/private.h             |  6 ++---
 libwnck/screen.c              |  2 +-
 libwnck/tasklist.c            | 61 +++++++++++++++++++++++++++++++------------
 libwnck/util.c                | 20 ++------------
 libwnck/util.h                |  3 +++
 libwnck/window.c              |  9 ++++---
 libwnck/wnck-handle-private.h |  6 ++++-
 libwnck/wnck-handle.c         | 55 ++++++++++++++++++++++++++++++++++++++
 libwnck/wnck-handle.h         |  8 +++++-
 libwnck/xutils.c              | 48 ++++++++++++++++++++++------------
 libwnck/xutils.h              |  6 +++--
 13 files changed, 185 insertions(+), 72 deletions(-)
---
diff --git a/libwnck/application.c b/libwnck/application.c
index 727d1dd..84c937c 100644
--- a/libwnck/application.c
+++ b/libwnck/application.c
@@ -25,6 +25,7 @@
 #include <glib/gi18n-lib.h>
 #include "application.h"
 #include "private.h"
+#include "wnck-handle-private.h"
 
 /**
  * SECTION:application
@@ -327,17 +328,20 @@ wnck_application_get_pid (WnckApplication *app)
 static void
 get_icons (WnckApplication *app)
 {
+  WnckHandle *handle;
   GdkPixbuf *icon;
   GdkPixbuf *mini_icon;
   gsize normal_size;
   gsize mini_size;
 
+  handle = wnck_screen_get_handle (app->priv->screen);
+
   icon = NULL;
   mini_icon = NULL;
-  normal_size = _wnck_get_default_icon_size ();
-  mini_size = _wnck_get_default_mini_icon_size ();
+  normal_size = wnck_handle_get_default_icon_size (handle);
+  mini_size = wnck_handle_get_default_mini_icon_size (handle);
 
-  if (_wnck_read_icons (WNCK_SCREEN_XSCREEN (app->priv->screen),
+  if (_wnck_read_icons (app->priv->screen,
                         app->priv->xwindow,
                         app->priv->icon_cache,
                         &icon, normal_size, normal_size,
diff --git a/libwnck/class-group.c b/libwnck/class-group.c
index 4b658d8..e843180 100644
--- a/libwnck/class-group.c
+++ b/libwnck/class-group.c
@@ -26,6 +26,7 @@
 #include "class-group.h"
 #include "window.h"
 #include "private.h"
+#include "wnck-handle-private.h"
 
 /**
  * SECTION:class-group
@@ -50,6 +51,8 @@
 
 /* Private part of the WnckClassGroup structure */
 struct _WnckClassGroupPrivate {
+  WnckScreen *screen;
+
   char *res_class;
   char *name;
   GList *windows;
@@ -220,6 +223,7 @@ wnck_class_group_get (const char *id)
 
 /**
  * _wnck_class_group_create:
+ * @screen: a #WnckScreen.
  * @res_class: name of the resource class for the group.
  *
  * Creates a new WnckClassGroup with the specified resource class name.  If
@@ -230,7 +234,8 @@ wnck_class_group_get (const char *id)
  * matches the @res_class.
  **/
 WnckClassGroup *
-_wnck_class_group_create (const char *res_class)
+_wnck_class_group_create (WnckScreen *screen,
+                          const char *res_class)
 {
   WnckClassGroup *class_group;
 
@@ -242,6 +247,7 @@ _wnck_class_group_create (const char *res_class)
                        NULL);
 
   class_group = g_object_new (WNCK_TYPE_CLASS_GROUP, NULL);
+  class_group->priv->screen = screen;
 
   class_group->priv->res_class = g_strdup (res_class ? res_class : "");
 
@@ -450,12 +456,17 @@ set_icon (WnckClassGroup *class_group)
 
   if (!icon || !mini_icon)
     {
-      _wnck_get_fallback_icons (&icon,
-                                _wnck_get_default_icon_size (),
-                                _wnck_get_default_icon_size (),
+      WnckHandle *handle;
+
+      handle = wnck_screen_get_handle (class_group->priv->screen);
+
+      _wnck_get_fallback_icons (handle,
+                                &icon,
+                                wnck_handle_get_default_icon_size (handle),
+                                wnck_handle_get_default_icon_size (handle),
                                 &mini_icon,
-                                _wnck_get_default_mini_icon_size (),
-                                _wnck_get_default_mini_icon_size ());
+                                wnck_handle_get_default_mini_icon_size (handle),
+                                wnck_handle_get_default_mini_icon_size (handle));
       icons_reffed = TRUE;
     }
 
diff --git a/libwnck/private.h b/libwnck/private.h
index 270ad99..64ff45c 100644
--- a/libwnck/private.h
+++ b/libwnck/private.h
@@ -41,9 +41,6 @@ G_BEGIN_DECLS
 
 WnckHandle *_wnck_get_handle (void);
 
-gsize _wnck_get_default_icon_size (void);
-gsize _wnck_get_default_mini_icon_size (void);
-
 void _wnck_application_process_property_notify (WnckApplication *app,
                                                 XEvent          *xevent);
 void _wnck_window_process_property_notify (WnckWindow *window,
@@ -97,7 +94,8 @@ void             _wnck_application_load_icons (WnckApplication *app);
 void             _wnck_application_shutdown_all (void);
 
 
-WnckClassGroup*  _wnck_class_group_create        (const char     *res_class);
+WnckClassGroup*  _wnck_class_group_create        (WnckScreen     *screen,
+                                                  const char     *res_class);
 void             _wnck_class_group_destroy       (WnckClassGroup *class_group);
 void             _wnck_class_group_add_window    (WnckClassGroup *class_group,
                                                   WnckWindow     *window);
diff --git a/libwnck/screen.c b/libwnck/screen.c
index 1105099..1eec498 100644
--- a/libwnck/screen.c
+++ b/libwnck/screen.c
@@ -1513,7 +1513,7 @@ update_client_list (WnckScreen *screen)
          class_group = wnck_class_group_get (res_class);
          if (class_group == NULL)
            {
-             class_group = _wnck_class_group_create (res_class);
+             class_group = _wnck_class_group_create (screen, res_class);
              created_class_groups = g_list_prepend (created_class_groups, class_group);
            }
 
diff --git a/libwnck/tasklist.c b/libwnck/tasklist.c
index 12abf30..e878ecf 100644
--- a/libwnck/tasklist.c
+++ b/libwnck/tasklist.c
@@ -32,6 +32,7 @@
 #include "class-group.h"
 #include "window-action-menu.h"
 #include "wnck-image-menu-item-private.h"
+#include "wnck-handle-private.h"
 #include "workspace.h"
 #include "xutils.h"
 #include "private.h"
@@ -90,7 +91,6 @@ typedef struct _WnckTaskClass   WnckTaskClass;
 
 #define DEFAULT_GROUPING_LIMIT 80
 
-#define MINI_ICON_SIZE _wnck_get_default_mini_icon_size ()
 #define TASKLIST_BUTTON_PADDING 4
 #define TASKLIST_TEXT_MAX_WIDTH 25 /* maximum width in characters */
 
@@ -1193,6 +1193,7 @@ wnck_task_get_highest_scored (GList     *ungrouped_class_groups,
 static int
 wnck_tasklist_get_button_size (GtkWidget *widget)
 {
+  WnckTasklist *tasklist;
   GtkStyleContext *style_context;
   GtkStateFlags state;
   PangoContext *context;
@@ -1200,8 +1201,12 @@ wnck_tasklist_get_button_size (GtkWidget *widget)
   PangoFontDescription *description;
   gint char_width;
   gint text_width;
+  WnckHandle *handle;
+  gint mini_icon_size;
   gint width;
 
+  tasklist = WNCK_TASKLIST (widget);
+
   style_context = gtk_widget_get_style_context (widget);
   state = gtk_style_context_get_state (style_context);
   gtk_style_context_get (style_context, state, GTK_STYLE_PROPERTY_FONT, &description, NULL);
@@ -1213,8 +1218,11 @@ wnck_tasklist_get_button_size (GtkWidget *widget)
   pango_font_metrics_unref (metrics);
   text_width = PANGO_PIXELS (TASKLIST_TEXT_MAX_WIDTH * char_width);
 
+  handle = wnck_screen_get_handle (tasklist->priv->screen);
+  mini_icon_size = wnck_handle_get_default_mini_icon_size (handle);
+
   width = text_width + 2 * TASKLIST_BUTTON_PADDING
-         + MINI_ICON_SIZE + 2 * TASKLIST_BUTTON_PADDING;
+         + mini_icon_size + 2 * TASKLIST_BUTTON_PADDING;
 
   return width;
 }
@@ -1506,6 +1514,8 @@ wnck_task_size_allocated (GtkWidget     *widget,
   GtkStyleContext *context;
   GtkStateFlags    state;
   GtkBorder        padding;
+  WnckHandle      *handle;
+  gsize            mini_icon_size;
   int              min_image_width;
   gboolean         old_image_visible;
   gboolean         old_label_visible;
@@ -1514,7 +1524,10 @@ wnck_task_size_allocated (GtkWidget     *widget,
   state = gtk_style_context_get_state (context);
   gtk_style_context_get_padding (context, state, &padding);
 
-  min_image_width = MINI_ICON_SIZE +
+  handle = wnck_screen_get_handle (task->tasklist->priv->screen);
+  mini_icon_size = wnck_handle_get_default_mini_icon_size (handle);
+
+  min_image_width = mini_icon_size +
                     padding.left + padding.right +
                     2 * TASKLIST_BUTTON_PADDING;
   old_image_visible = gtk_widget_get_visible (task->image);
@@ -3192,9 +3205,12 @@ wnck_dimm_icon (GdkPixbuf *pixbuf)
 }
 
 static GdkPixbuf *
-wnck_task_scale_icon (GdkPixbuf *orig, gboolean minimized)
+wnck_task_scale_icon (WnckHandle *handle,
+                      GdkPixbuf  *orig,
+                      gboolean    minimized)
 {
   int w, h;
+  gsize mini_icon_size;
   GdkPixbuf *pixbuf;
 
   if (!orig)
@@ -3203,7 +3219,9 @@ wnck_task_scale_icon (GdkPixbuf *orig, gboolean minimized)
   w = gdk_pixbuf_get_width (orig);
   h = gdk_pixbuf_get_height (orig);
 
-  if (h != (int) MINI_ICON_SIZE ||
+  mini_icon_size = wnck_handle_get_default_mini_icon_size (handle);
+
+  if (h != (int) mini_icon_size ||
       !gdk_pixbuf_get_has_alpha (orig))
     {
       double scale;
@@ -3211,10 +3229,10 @@ wnck_task_scale_icon (GdkPixbuf *orig, gboolean minimized)
       pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB,
                               TRUE,
                               8,
-                              MINI_ICON_SIZE * w / (double) h,
-                              MINI_ICON_SIZE);
+                              mini_icon_size * w / (double) h,
+                              mini_icon_size);
 
-      scale = MINI_ICON_SIZE / (double) gdk_pixbuf_get_height (orig);
+      scale = mini_icon_size / (double) gdk_pixbuf_get_height (orig);
 
       gdk_pixbuf_scale (orig,
                        pixbuf,
@@ -3246,23 +3264,27 @@ wnck_task_scale_icon (GdkPixbuf *orig, gboolean minimized)
 static GdkPixbuf *
 wnck_task_get_icon (WnckTask *task)
 {
+  WnckHandle *handle;
   WnckWindowState state;
   GdkPixbuf *pixbuf;
 
+  handle = wnck_screen_get_handle (task->tasklist->priv->screen);
   pixbuf = NULL;
 
   switch (task->type)
     {
     case WNCK_TASK_CLASS_GROUP:
-      pixbuf = wnck_task_scale_icon (wnck_class_group_get_mini_icon (task->class_group),
-                                    FALSE);
+      pixbuf = wnck_task_scale_icon (handle,
+                                     wnck_class_group_get_mini_icon (task->class_group),
+                                     FALSE);
       break;
 
     case WNCK_TASK_WINDOW:
       state = wnck_window_get_state (task->window);
 
-      pixbuf =  wnck_task_scale_icon (wnck_window_get_mini_icon (task->window),
-                                     state & WNCK_WINDOW_STATE_MINIMIZED);
+      pixbuf =  wnck_task_scale_icon (handle,
+                                      wnck_window_get_mini_icon (task->window),
+                                      state & WNCK_WINDOW_STATE_MINIMIZED);
       break;
 
     case WNCK_TASK_STARTUP_SEQUENCE:
@@ -3274,16 +3296,19 @@ wnck_task_get_icon (WnckTask *task)
           icon = sn_startup_sequence_get_icon_name (task->startup_sequence);
           if (icon != NULL)
             {
+              gsize mini_icon_size;
               GdkPixbuf *loaded;
 
+              mini_icon_size = wnck_handle_get_default_mini_icon_size (handle);
+
               loaded =  (* task->tasklist->priv->icon_loader) (icon,
-                                                               MINI_ICON_SIZE,
+                                                               mini_icon_size,
                                                                0,
                                                                task->tasklist->priv->icon_loader_data);
 
               if (loaded != NULL)
                 {
-                  pixbuf = wnck_task_scale_icon (loaded, FALSE);
+                  pixbuf = wnck_task_scale_icon (handle, loaded, FALSE);
                   g_object_unref (G_OBJECT (loaded));
                 }
             }
@@ -3291,8 +3316,12 @@ wnck_task_get_icon (WnckTask *task)
 
       if (pixbuf == NULL)
         {
-          _wnck_get_fallback_icons (NULL, 0, 0,
-                                    &pixbuf, MINI_ICON_SIZE, MINI_ICON_SIZE);
+          gsize mini_icon_size;
+
+          mini_icon_size = wnck_handle_get_default_mini_icon_size (handle);
+
+          _wnck_get_fallback_icons (handle, NULL, 0, 0,
+                                    &pixbuf, mini_icon_size, mini_icon_size);
         }
 #endif
       break;
diff --git a/libwnck/util.c b/libwnck/util.c
index e08fabc..2925c66 100644
--- a/libwnck/util.c
+++ b/libwnck/util.c
@@ -674,8 +674,6 @@ _wnck_get_handle (void)
   return wnck_handle;
 }
 
-static gsize default_icon_size = WNCK_DEFAULT_ICON_SIZE;
-
 /**
  * wnck_set_default_icon_size:
  * @size: the default size for windows and application standard icons.
@@ -688,17 +686,9 @@ static gsize default_icon_size = WNCK_DEFAULT_ICON_SIZE;
 void
 wnck_set_default_icon_size (gsize size)
 {
-  default_icon_size = size;
-}
-
-gsize
-_wnck_get_default_icon_size (void)
-{
-  return default_icon_size;
+  wnck_handle_set_default_icon_size (_wnck_get_handle(), size);
 }
 
-static gsize default_mini_icon_size = WNCK_DEFAULT_MINI_ICON_SIZE;
-
 /**
  * wnck_set_default_mini_icon_size:
  * @size: the default size for windows and application mini icons.
@@ -715,7 +705,7 @@ wnck_set_default_mini_icon_size (gsize size)
   WnckScreen *screen;
   GList *l;
 
-  default_mini_icon_size = size;
+  wnck_handle_set_default_mini_icon_size (_wnck_get_handle (), size);
 
   default_screen = DefaultScreen (_wnck_get_default_display ());
   screen = _wnck_screen_get_existing (default_screen);
@@ -736,12 +726,6 @@ wnck_set_default_mini_icon_size (gsize size)
     }
 }
 
-gsize
-_wnck_get_default_mini_icon_size (void)
-{
-  return default_mini_icon_size;
-}
-
 /**
  * _make_gtk_label_bold:
  * @label: The label.
diff --git a/libwnck/util.h b/libwnck/util.h
index f17d37a..91a4e08 100644
--- a/libwnck/util.h
+++ b/libwnck/util.h
@@ -106,7 +106,10 @@ void wnck_set_client_type (WnckClientType ewmh_sourceindication_client_type);
 #define WNCK_DEFAULT_ICON_SIZE 32
 #define WNCK_DEFAULT_MINI_ICON_SIZE 16
 
+G_DEPRECATED_FOR(wnck_handle_set_default_icon_size)
 void wnck_set_default_icon_size      (gsize size);
+
+G_DEPRECATED_FOR(wnck_handle_set_default_mini_icon_size)
 void wnck_set_default_mini_icon_size (gsize size);
 
 void wnck_shutdown        (void);
diff --git a/libwnck/window.c b/libwnck/window.c
index 7190077..9c2583e 100644
--- a/libwnck/window.c
+++ b/libwnck/window.c
@@ -2111,17 +2111,20 @@ wnck_window_transient_is_most_recently_activated (WnckWindow *window)
 static void
 get_icons (WnckWindow *window)
 {
+  WnckHandle *handle;
   GdkPixbuf *icon;
   GdkPixbuf *mini_icon;
   gsize normal_size;
   gsize mini_size;
 
+  handle = wnck_screen_get_handle (window->priv->screen);
+
   icon = NULL;
   mini_icon = NULL;
-  normal_size = _wnck_get_default_icon_size ();
-  mini_size = _wnck_get_default_mini_icon_size ();
+  normal_size = wnck_handle_get_default_icon_size (handle);
+  mini_size = wnck_handle_get_default_mini_icon_size (handle);
 
-  if (_wnck_read_icons (WNCK_SCREEN_XSCREEN (window->priv->screen),
+  if (_wnck_read_icons (window->priv->screen,
                         window->priv->xwindow,
                         window->priv->icon_cache,
                         &icon, normal_size, normal_size,
diff --git a/libwnck/wnck-handle-private.h b/libwnck/wnck-handle-private.h
index 13ff70f..68e26c6 100644
--- a/libwnck/wnck-handle-private.h
+++ b/libwnck/wnck-handle-private.h
@@ -22,7 +22,11 @@
 
 G_BEGIN_DECLS
 
-WnckClientType wnck_handle_get_client_type (WnckHandle *self);
+WnckClientType wnck_handle_get_client_type            (WnckHandle *self);
+
+gsize          wnck_handle_get_default_icon_size      (WnckHandle *self);
+
+gsize          wnck_handle_get_default_mini_icon_size (WnckHandle *self);
 
 G_END_DECLS
 
diff --git a/libwnck/wnck-handle.c b/libwnck/wnck-handle.c
index 1625c10..c8c4f15 100644
--- a/libwnck/wnck-handle.c
+++ b/libwnck/wnck-handle.c
@@ -32,6 +32,9 @@ struct _WnckHandle
   GObject        parent;
 
   WnckClientType client_type;
+
+  gsize          default_icon_size;
+  gsize          default_mini_icon_size;
 };
 
 enum
@@ -120,6 +123,8 @@ wnck_handle_class_init (WnckHandleClass *self_class)
 static void
 wnck_handle_init (WnckHandle *self)
 {
+  self->default_icon_size = WNCK_DEFAULT_ICON_SIZE;
+  self->default_mini_icon_size = WNCK_DEFAULT_MINI_ICON_SIZE;
 }
 
 /**
@@ -145,3 +150,53 @@ wnck_handle_get_client_type (WnckHandle *self)
 
   return self->client_type;
 }
+
+/**
+ * wnck_handle_set_default_icon_size:
+ * @self: a #WnckHandle
+ * @icon_size: the default size for windows and application standard icons.
+ *
+ * The default main icon size is %WNCK_DEFAULT_ICON_SIZE. This function allows
+ * to change this value.
+ */
+void
+wnck_handle_set_default_icon_size (WnckHandle *self,
+                                   gsize       icon_size)
+{
+  g_return_if_fail (WNCK_IS_HANDLE (self));
+
+  self->default_icon_size = icon_size;
+}
+
+gsize
+wnck_handle_get_default_icon_size (WnckHandle *self)
+{
+  g_return_val_if_fail (WNCK_IS_HANDLE (self), WNCK_DEFAULT_ICON_SIZE);
+
+  return self->default_icon_size;
+}
+
+/**
+ * wnck_handle_set_default_mini_icon_size:
+ * @self: a #WnckHandle
+ * @icon_size: the default size for windows and application mini icons.
+ *
+ * The default main icon size is %WNCK_DEFAULT_MINI_ICON_SIZE. This function
+ * allows to change this value.
+ */
+void
+wnck_handle_set_default_mini_icon_size (WnckHandle *self,
+                                        gsize       icon_size)
+{
+  g_return_if_fail (WNCK_IS_HANDLE (self));
+
+  self->default_mini_icon_size = icon_size;
+}
+
+gsize
+wnck_handle_get_default_mini_icon_size (WnckHandle *self)
+{
+  g_return_val_if_fail (WNCK_IS_HANDLE (self), WNCK_DEFAULT_MINI_ICON_SIZE);
+
+  return self->default_mini_icon_size;
+}
diff --git a/libwnck/wnck-handle.h b/libwnck/wnck-handle.h
index 874d3ba..6fed2f0 100644
--- a/libwnck/wnck-handle.h
+++ b/libwnck/wnck-handle.h
@@ -30,7 +30,13 @@ G_BEGIN_DECLS
 #define WNCK_TYPE_HANDLE (wnck_handle_get_type ())
 G_DECLARE_FINAL_TYPE (WnckHandle, wnck_handle, WNCK, HANDLE, GObject)
 
-WnckHandle *wnck_handle_new (WnckClientType client_type);
+WnckHandle *wnck_handle_new                        (WnckClientType  client_type);
+
+void        wnck_handle_set_default_icon_size      (WnckHandle     *self,
+                                                    gsize           icon_size);
+
+void        wnck_handle_set_default_mini_icon_size (WnckHandle     *self,
+                                                    gsize           icon_size);
 
 G_END_DECLS
 
diff --git a/libwnck/xutils.c b/libwnck/xutils.c
index 2340373..1ddaf7f 100644
--- a/libwnck/xutils.c
+++ b/libwnck/xutils.c
@@ -2173,7 +2173,7 @@ scaled_from_pixdata (guchar *pixdata,
 }
 
 gboolean
-_wnck_read_icons (Screen        *screen,
+_wnck_read_icons (WnckScreen    *screen,
                   Window         xwindow,
                   WnckIconCache *icon_cache,
                   GdkPixbuf    **iconp,
@@ -2183,6 +2183,7 @@ _wnck_read_icons (Screen        *screen,
                   int            ideal_mini_width,
                   int            ideal_mini_height)
 {
+  Screen *xscreen;
   Display *display;
   guchar *pixdata;
   int w, h;
@@ -2196,7 +2197,8 @@ _wnck_read_icons (Screen        *screen,
 
   g_return_val_if_fail (icon_cache != NULL, FALSE);
 
-  display = DisplayOfScreen (screen);
+  xscreen = WNCK_SCREEN_XSCREEN (screen);
+  display = DisplayOfScreen (xscreen);
 
   *iconp = NULL;
   *mini_iconp = NULL;
@@ -2232,7 +2234,7 @@ _wnck_read_icons (Screen        *screen,
     {
       icon_cache->net_wm_icon_dirty = FALSE;
 
-      if (read_rgb_icon (screen, xwindow,
+      if (read_rgb_icon (xscreen, xwindow,
                          ideal_width, ideal_height,
                          ideal_mini_width, ideal_mini_height,
                          &w, &h, &pixdata,
@@ -2279,7 +2281,7 @@ _wnck_read_icons (Screen        *screen,
            mask != icon_cache->prev_mask) &&
           pixmap != None)
         {
-          if (try_pixmap_and_mask (screen, pixmap, mask,
+          if (try_pixmap_and_mask (xscreen, pixmap, mask,
                                    iconp, ideal_width, ideal_height,
                                    mini_iconp, ideal_mini_width, ideal_mini_height))
             {
@@ -2299,13 +2301,13 @@ _wnck_read_icons (Screen        *screen,
     {
       icon_cache->kwm_win_icon_dirty = FALSE;
 
-      get_kwm_win_icon (screen, xwindow, &pixmap, &mask);
+      get_kwm_win_icon (xscreen, xwindow, &pixmap, &mask);
 
       if ((pixmap != icon_cache->prev_pixmap ||
            mask != icon_cache->prev_mask) &&
           pixmap != None)
         {
-          if (try_pixmap_and_mask (screen, pixmap, mask,
+          if (try_pixmap_and_mask (xscreen, pixmap, mask,
                                    iconp, ideal_width, ideal_height,
                                    mini_iconp, ideal_mini_width, ideal_mini_height))
             {
@@ -2323,7 +2325,12 @@ _wnck_read_icons (Screen        *screen,
   if (icon_cache->want_fallback &&
       icon_cache->origin < USING_FALLBACK_ICON)
     {
-      _wnck_get_fallback_icons (iconp,
+      WnckHandle *handle;
+
+      handle = wnck_screen_get_handle (screen);
+
+      _wnck_get_fallback_icons (handle,
+                                iconp,
                                 ideal_width,
                                 ideal_height,
                                 mini_iconp,
@@ -2383,24 +2390,31 @@ default_icon_at_size (int width,
 }
 
 void
-_wnck_get_fallback_icons (GdkPixbuf **iconp,
-                          int         ideal_width,
-                          int         ideal_height,
-                          GdkPixbuf **mini_iconp,
-                          int         ideal_mini_width,
-                          int         ideal_mini_height)
+_wnck_get_fallback_icons (WnckHandle  *handle,
+                          GdkPixbuf  **iconp,
+                          int          ideal_width,
+                          int          ideal_height,
+                          GdkPixbuf  **mini_iconp,
+                          int          ideal_mini_width,
+                          int          ideal_mini_height)
 {
+  gsize default_icon_size;
+  gsize default_mini_icon_size;
+
+  default_icon_size = wnck_handle_get_default_icon_size (handle);
+  default_mini_icon_size = wnck_handle_get_default_mini_icon_size (handle);
+
   if (iconp)
     *iconp = default_icon_at_size (ideal_width > 0 ? ideal_width :
-                                   (int) _wnck_get_default_icon_size (),
+                                   (int) default_icon_size,
                                    ideal_height > 0 ? ideal_height :
-                                   (int) _wnck_get_default_icon_size ());
+                                   (int) default_icon_size);
 
   if (mini_iconp)
     *mini_iconp = default_icon_at_size (ideal_mini_width > 0 ? ideal_mini_width :
-                                        (int) _wnck_get_default_mini_icon_size (),
+                                        (int) default_mini_icon_size,
                                         ideal_mini_height > 0 ? ideal_mini_height :
-                                        (int) _wnck_get_default_mini_icon_size ());
+                                        (int) default_mini_icon_size);
 }
 
 
diff --git a/libwnck/xutils.h b/libwnck/xutils.h
index bc415e2..7f5e26c 100644
--- a/libwnck/xutils.h
+++ b/libwnck/xutils.h
@@ -31,6 +31,7 @@
 G_BEGIN_DECLS
 
 /* forward decls */
+typedef struct _WnckHandle WnckHandle;
 typedef struct _WnckScreen WnckScreen;
 
 #define WNCK_APP_WINDOW_EVENT_MASK (PropertyChangeMask | StructureNotifyMask)
@@ -170,7 +171,7 @@ void           _wnck_icon_cache_set_want_fallback    (WnckIconCache *icon_cache,
                                                       gboolean       setting);
 gboolean       _wnck_icon_cache_get_is_fallback      (WnckIconCache *icon_cache);
 
-gboolean _wnck_read_icons         (Screen         *screen,
+gboolean _wnck_read_icons         (WnckScreen     *screen,
                                    Window          xwindow,
                                    WnckIconCache  *icon_cache,
                                    GdkPixbuf     **iconp,
@@ -179,7 +180,8 @@ gboolean _wnck_read_icons         (Screen         *screen,
                                    GdkPixbuf     **mini_iconp,
                                    int             ideal_mini_width,
                                    int             ideal_mini_height);
-void _wnck_get_fallback_icons (GdkPixbuf     **iconp,
+void _wnck_get_fallback_icons (WnckHandle     *handle,
+                               GdkPixbuf     **iconp,
                                int             ideal_width,
                                int             ideal_height,
                                GdkPixbuf     **mini_iconp,
[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]