X-Git-Url: http://pileus.org/git/?a=blobdiff_plain;f=gtk%2Fgtkstatusicon.c;h=6f7bf89824a7b48ab73f89ab1891ca91f0aee80c;hb=5bd4c234fb21909d9f769f6f2d44382f115d53bf;hp=89ce944f3ad03687b2beea8f1e6baa318a2a2511;hpb=913cdf3be750a1e74c09b20edf55a57f9a919fcc;p=~andy%2Fgtk diff --git a/gtk/gtkstatusicon.c b/gtk/gtkstatusicon.c index 89ce944f3..6f7bf8982 100644 --- a/gtk/gtkstatusicon.c +++ b/gtk/gtkstatusicon.c @@ -28,38 +28,63 @@ */ #include "config.h" + #include #include "gtkstatusicon.h" #include "gtkintl.h" #include "gtkiconfactory.h" +#include "gtkiconhelperprivate.h" #include "gtkmain.h" #include "gtkmarshalers.h" -#include "gtktrayicon.h" - +#include "gtksizerequest.h" #include "gtkprivate.h" #include "gtkwidget.h" #include "gtktooltip.h" +#include "gtkicontheme.h" +#include "gtklabel.h" +#include "gtktypebuiltins.h" #ifdef GDK_WINDOWING_X11 #include "gdk/x11/gdkx.h" +#include "gtktrayicon.h" #endif #ifdef GDK_WINDOWING_WIN32 -#include "gtkicontheme.h" -#include "gtklabel.h" - -#include "win32/gdkwin32.h" +#include "gdk/win32/gdkwin32.h" #define WM_GTK_TRAY_NOTIFICATION (WM_USER+1) #endif -#ifdef GDK_WINDOWING_QUARTZ -#include "gtkicontheme.h" -#include "gtklabel.h" -#endif -#include "gdkkeysyms.h" +/** + * SECTION:gtkstatusicon + * @Short_description: Display an icon in the system tray + * @Title: GtkStatusIcon + * + * The "system tray" or notification area is normally used for transient icons + * that indicate some special state. For example, a system tray icon might + * appear to tell the user that they have new mail, or have an incoming instant + * message, or something along those lines. The basic idea is that creating an + * icon in the notification area is less annoying than popping up a dialog. + * + * A #GtkStatusIcon object can be used to display an icon in a "system tray". + * The icon can have a tooltip, and the user can interact with it by + * activating it or popping up a context menu. Critical information should + * not solely be displayed in a #GtkStatusIcon, since it may not be + * visible (e.g. when the user doesn't have a notification area on his panel). + * This can be checked with gtk_status_icon_is_embedded(). + * + * On X11, the implementation follows the freedesktop.org "System Tray" + * specification. + * Implementations of the "tray" side of this specification can + * be found e.g. in the GNOME 2 and KDE panel applications. + * + * Note that a GtkStatusIcon is not a widget, but just + * a #GObject. Making it a widget would be impractical, since the system tray + * on Win32 doesn't allow to embed arbitrary widgets. + */ + #define BLINK_TIMEOUT 500 @@ -107,11 +132,13 @@ struct _GtkStatusIconPrivate #ifdef GDK_WINDOWING_X11 GtkWidget *tray_icon; GtkWidget *image; +#else + GtkWidget *dummy_widget; #endif #ifdef GDK_WINDOWING_WIN32 - GtkWidget *dummy_widget; NOTIFYICONDATAW nid; + gint taskbar_top; gint last_click_x, last_click_y; GtkOrientation orientation; gchar *tooltip_text; @@ -119,28 +146,14 @@ struct _GtkStatusIconPrivate #endif #ifdef GDK_WINDOWING_QUARTZ - GtkWidget *dummy_widget; GtkQuartzStatusIcon *status_item; gchar *tooltip_text; gchar *title; #endif - gint size; - - gint image_width; - gint image_height; - - GtkImageType storage_type; - - union - { - GdkPixbuf *pixbuf; - gchar *stock_id; - gchar *icon_name; - GIcon *gicon; - } image_data; - - guint visible : 1; + gint size; + GtkIconHelper *icon_helper; + guint visible : 1; }; static GObject* gtk_status_icon_constructor (GType type, @@ -164,6 +177,7 @@ static void gtk_status_icon_screen_changed (GtkStatusIcon *status_icon, static void gtk_status_icon_embedded_changed (GtkStatusIcon *status_icon); static void gtk_status_icon_orientation_changed (GtkStatusIcon *status_icon); static void gtk_status_icon_padding_changed (GtkStatusIcon *status_icon); +static void gtk_status_icon_icon_size_changed(GtkStatusIcon *status_icon); static void gtk_status_icon_fg_changed (GtkStatusIcon *status_icon); static void gtk_status_icon_color_changed (GtkTrayIcon *tray, GParamSpec *pspec, @@ -499,7 +513,8 @@ gtk_status_icon_class_init (GtkStatusIconClass *class) /** * GtkStatusIcon::button-press-event: * @status_icon: the object which received the signal - * @event: the #GdkEventButton which triggered this signal + * @event: (type Gdk.EventButton): the #GdkEventButton which triggered + * this signal * * The ::button-press-event signal will be emitted when a button * (typically from a mouse) is pressed. @@ -525,7 +540,8 @@ gtk_status_icon_class_init (GtkStatusIconClass *class) /** * GtkStatusIcon::button-release-event: * @status_icon: the object which received the signal - * @event: the #GdkEventButton which triggered this signal + * @event: (type Gdk.EventButton): the #GdkEventButton which triggered + * this signal * * The ::button-release-event signal will be emitted when a button * (typically from a mouse) is released. @@ -551,7 +567,8 @@ gtk_status_icon_class_init (GtkStatusIconClass *class) /** * GtkStatusIcon::scroll-event: * @status_icon: the object which received the signal. - * @event: the #GdkEventScroll which triggered this signal + * @event: (type Gdk.EventScroll): the #GdkEventScroll which triggered + * this signal * * The ::scroll-event signal is emitted when a button in the 4 to 7 * range is pressed. Wheel mice are usually configured to generate @@ -641,7 +658,7 @@ build_button_event (GtkStatusIconPrivate *priv, e->axes = NULL; e->state = 0; e->button = button; - e->device = gdk_display_get_default ()->core_pointer; + //FIXME: e->device = gdk_display_get_default ()->core_pointer; e->x_root = e->x; e->y_root = e->y; } @@ -665,7 +682,7 @@ button_callback (gpointer data) gdk_event_free ((GdkEvent *) bc->event); g_free (data); - return FALSE; + return G_SOURCE_REMOVE; } static UINT taskbar_created_msg = 0; @@ -819,14 +836,11 @@ gtk_status_icon_init (GtkStatusIcon *status_icon) GtkStatusIconPrivate); status_icon->priv = priv; - priv->storage_type = GTK_IMAGE_EMPTY; + priv->icon_helper = _gtk_icon_helper_new (); priv->visible = TRUE; #ifdef GDK_WINDOWING_X11 priv->size = 0; - priv->image_width = 0; - priv->image_height = 0; - priv->tray_icon = GTK_WIDGET (_gtk_tray_icon_new (NULL)); gtk_widget_add_events (GTK_WIDGET (priv->tray_icon), @@ -843,6 +857,8 @@ gtk_status_icon_init (GtkStatusIcon *status_icon) G_CALLBACK (gtk_status_icon_orientation_changed), status_icon); g_signal_connect_swapped (priv->tray_icon, "notify::padding", G_CALLBACK (gtk_status_icon_padding_changed), status_icon); + g_signal_connect_swapped (priv->tray_icon, "notify::icon-size", + G_CALLBACK (gtk_status_icon_icon_size_changed), status_icon); g_signal_connect_swapped (priv->tray_icon, "notify::fg-color", G_CALLBACK (gtk_status_icon_fg_changed), status_icon); g_signal_connect (priv->tray_icon, "notify::error-color", @@ -866,9 +882,17 @@ gtk_status_icon_init (GtkStatusIcon *status_icon) gtk_container_add (GTK_CONTAINER (priv->tray_icon), priv->image); gtk_widget_show (priv->image); + /* Force-initialize the symbolic colors */ + g_object_notify (G_OBJECT (priv->tray_icon), "fg-color"); + g_object_notify (G_OBJECT (priv->tray_icon), "error-color"); + g_object_notify (G_OBJECT (priv->tray_icon), "warning-color"); + g_object_notify (G_OBJECT (priv->tray_icon), "success-color"); + g_signal_connect_swapped (priv->image, "size-allocate", G_CALLBACK (gtk_status_icon_size_allocate), status_icon); +#else /* !GDK_WINDOWING_X11 */ + priv->dummy_widget = gtk_label_new (""); #endif #ifdef GDK_WINDOWING_WIN32 @@ -883,16 +907,14 @@ gtk_status_icon_init (GtkStatusIcon *status_icon) priv->orientation = GTK_ORIENTATION_VERTICAL; else priv->orientation = GTK_ORIENTATION_HORIZONTAL; + + priv->taskbar_top = abd.rc.top; } priv->last_click_x = priv->last_click_y = 0; /* Are the system tray icons always 16 pixels square? */ priv->size = 16; - priv->image_width = 16; - priv->image_height = 16; - - priv->dummy_widget = gtk_label_new (""); memset (&priv->nid, 0, sizeof (priv->nid)); @@ -901,6 +923,17 @@ gtk_status_icon_init (GtkStatusIcon *status_icon) priv->nid.uCallbackMessage = WM_GTK_TRAY_NOTIFICATION; priv->nid.uFlags = NIF_MESSAGE; + /* To help win7 identify the icon create it with an application "unique" tip */ + if (g_get_prgname ()) + { + WCHAR *wcs = g_utf8_to_utf16 (g_get_prgname (), -1, NULL, NULL, NULL); + + priv->nid.uFlags |= NIF_TIP; + wcsncpy (priv->nid.szTip, wcs, G_N_ELEMENTS (priv->nid.szTip) - 1); + priv->nid.szTip[G_N_ELEMENTS (priv->nid.szTip) - 1] = 0; + g_free (wcs); + } + if (!Shell_NotifyIconW (NIM_ADD, &priv->nid)) { g_warning (G_STRLOC ": Shell_NotifyIcon(NIM_ADD) failed"); @@ -912,14 +945,10 @@ gtk_status_icon_init (GtkStatusIcon *status_icon) #endif #ifdef GDK_WINDOWING_QUARTZ - priv->dummy_widget = gtk_label_new (""); - QUARTZ_POOL_ALLOC; priv->status_item = [[GtkQuartzStatusIcon alloc] initWithStatusIcon:status_icon]; - - priv->image_width = priv->image_height = [priv->status_item getHeight]; - priv->size = priv->image_height; + priv->size = [priv->status_item getHeight]; QUARTZ_POOL_RELEASE; @@ -959,6 +988,7 @@ gtk_status_icon_finalize (GObject *object) GtkStatusIconPrivate *priv = status_icon->priv; gtk_status_icon_reset_image_data (status_icon); + g_clear_object (&priv->icon_helper); #ifdef GDK_WINDOWING_X11 g_signal_handlers_disconnect_by_func (priv->tray_icon, @@ -971,6 +1001,8 @@ gtk_status_icon_finalize (GObject *object) gtk_status_icon_orientation_changed, status_icon); g_signal_handlers_disconnect_by_func (priv->tray_icon, gtk_status_icon_padding_changed, status_icon); + g_signal_handlers_disconnect_by_func (priv->tray_icon, + gtk_status_icon_icon_size_changed, status_icon); g_signal_handlers_disconnect_by_func (priv->tray_icon, gtk_status_icon_fg_changed, status_icon); g_signal_handlers_disconnect_by_func (priv->tray_icon, @@ -987,6 +1019,8 @@ gtk_status_icon_finalize (GObject *object) gtk_status_icon_screen_changed, status_icon); gtk_widget_destroy (priv->image); gtk_widget_destroy (priv->tray_icon); +#else /* !GDK_WINDOWING_X11 */ + gtk_widget_destroy (priv->dummy_widget); #endif #ifdef GDK_WINDOWING_WIN32 @@ -996,8 +1030,6 @@ gtk_status_icon_finalize (GObject *object) DestroyIcon (priv->nid.hIcon); g_free (priv->tooltip_text); - gtk_widget_destroy (priv->dummy_widget); - status_icons = g_slist_remove (status_icons, status_icon); #endif @@ -1067,39 +1099,20 @@ gtk_status_icon_get_property (GObject *object, GParamSpec *pspec) { GtkStatusIcon *status_icon = GTK_STATUS_ICON (object); - GtkStatusIconPrivate *priv = status_icon->priv; - - /* The "getter" functions whine if you try to get the wrong - * storage type. This function is instead robust against that, - * so that GUI builders don't have to jump through hoops - * to avoid g_warning - */ switch (prop_id) { case PROP_PIXBUF: - if (priv->storage_type != GTK_IMAGE_PIXBUF) - g_value_set_object (value, NULL); - else - g_value_set_object (value, gtk_status_icon_get_pixbuf (status_icon)); + g_value_set_object (value, gtk_status_icon_get_pixbuf (status_icon)); break; case PROP_STOCK: - if (priv->storage_type != GTK_IMAGE_STOCK) - g_value_set_string (value, NULL); - else - g_value_set_string (value, gtk_status_icon_get_stock (status_icon)); + g_value_set_string (value, gtk_status_icon_get_stock (status_icon)); break; case PROP_ICON_NAME: - if (priv->storage_type != GTK_IMAGE_ICON_NAME) - g_value_set_string (value, NULL); - else - g_value_set_string (value, gtk_status_icon_get_icon_name (status_icon)); + g_value_set_string (value, gtk_status_icon_get_icon_name (status_icon)); break; case PROP_GICON: - if (priv->storage_type != GTK_IMAGE_GICON) - g_value_set_object (value, NULL); - else - g_value_set_object (value, gtk_status_icon_get_gicon (status_icon)); + g_value_set_object (value, gtk_status_icon_get_gicon (status_icon)); break; case PROP_STORAGE_TYPE: g_value_set_enum (value, gtk_status_icon_get_storage_type (status_icon)); @@ -1180,7 +1193,7 @@ gtk_status_icon_new_from_pixbuf (GdkPixbuf *pixbuf) /** * gtk_status_icon_new_from_file: - * @filename: a filename + * @filename: (type filename): a filename * * Creates a status icon displaying the file @filename. * @@ -1295,16 +1308,15 @@ emit_size_changed_signal (GtkStatusIcon *status_icon, #endif -#ifdef GDK_WINDOWING_X11 - -static GtkIconSize -find_icon_size (GtkWidget *widget, - gint pixel_size) +/* rounds the pixel size to the nearest size avaiable in the theme */ +static gint +round_pixel_size (GtkWidget *widget, + gint pixel_size) { GdkScreen *screen; GtkSettings *settings; - GtkIconSize s, size; - gint w, h, d, dist; + GtkIconSize s; + gint w, h, d, dist, size; screen = gtk_widget_get_screen (widget); @@ -1312,9 +1324,9 @@ find_icon_size (GtkWidget *widget, return GTK_ICON_SIZE_MENU; settings = gtk_settings_get_for_screen (screen); - + dist = G_MAXINT; - size = GTK_ICON_SIZE_MENU; + size = 0; for (s = GTK_ICON_SIZE_MENU; s <= GTK_ICON_SIZE_DIALOG; s++) { @@ -1325,7 +1337,7 @@ find_icon_size (GtkWidget *widget, if (d < dist) { dist = d; - size = s; + size = MAX (w, h); } } } @@ -1333,8 +1345,6 @@ find_icon_size (GtkWidget *widget, return size; } -#endif - static void gtk_status_icon_update_image (GtkStatusIcon *status_icon) { @@ -1342,233 +1352,86 @@ gtk_status_icon_update_image (GtkStatusIcon *status_icon) #ifdef GDK_WINDOWING_WIN32 HICON prev_hicon; #endif + GtkStyleContext *context; + GtkWidget *widget; + GtkImageType storage_type = _gtk_icon_helper_get_storage_type (priv->icon_helper); + GdkPixbuf *pixbuf; + gint round_size; - switch (priv->storage_type) - { - case GTK_IMAGE_PIXBUF: - { - GdkPixbuf *pixbuf; +#ifdef GDK_WINDOWING_X11 + widget = priv->image; +#else + widget = priv->dummy_widget; +#endif - pixbuf = priv->image_data.pixbuf; + context = gtk_widget_get_style_context (widget); + round_size = round_pixel_size (widget, priv->size); - if (pixbuf) - { - GdkPixbuf *scaled; - gint size; - gint width; - gint height; + if (storage_type == GTK_IMAGE_PIXBUF) + { + GdkPixbuf *scaled; + gint width; + gint height; - size = priv->size; + pixbuf = _gtk_icon_helper_ensure_pixbuf (priv->icon_helper, context); - width = gdk_pixbuf_get_width (pixbuf); - height = gdk_pixbuf_get_height (pixbuf); + width = gdk_pixbuf_get_width (pixbuf); + height = gdk_pixbuf_get_height (pixbuf); - if (width > size || height > size) - scaled = gdk_pixbuf_scale_simple (pixbuf, - MIN (size, width), - MIN (size, height), - GDK_INTERP_BILINEAR); - else - scaled = g_object_ref (pixbuf); + if (width > round_size || height > round_size) + { + scaled = gdk_pixbuf_scale_simple (pixbuf, + MIN (round_size, width), + MIN (round_size, height), + GDK_INTERP_BILINEAR); + g_object_unref (pixbuf); + pixbuf = scaled; + } + } + else + { + _gtk_icon_helper_set_pixel_size (priv->icon_helper, round_size); + pixbuf = _gtk_icon_helper_ensure_pixbuf (priv->icon_helper, context); + } + if (pixbuf != NULL) + { #ifdef GDK_WINDOWING_X11 - gtk_image_set_from_pixbuf (GTK_IMAGE (priv->image), scaled); + gtk_image_set_from_pixbuf (GTK_IMAGE (priv->image), pixbuf); #endif #ifdef GDK_WINDOWING_WIN32 - prev_hicon = priv->nid.hIcon; - priv->nid.hIcon = gdk_win32_pixbuf_to_hicon_libgtk_only (scaled); - priv->nid.uFlags |= NIF_ICON; - if (priv->nid.hWnd != NULL && priv->visible) - if (!Shell_NotifyIconW (NIM_MODIFY, &priv->nid)) - g_warning (G_STRLOC ": Shell_NotifyIcon(NIM_MODIFY) failed"); - if (prev_hicon) - DestroyIcon (prev_hicon); + prev_hicon = priv->nid.hIcon; + priv->nid.hIcon = gdk_win32_pixbuf_to_hicon_libgtk_only (pixbuf); + priv->nid.uFlags |= NIF_ICON; + if (priv->nid.hWnd != NULL && priv->visible) + if (!Shell_NotifyIconW (NIM_MODIFY, &priv->nid)) + g_warning (G_STRLOC ": Shell_NotifyIcon(NIM_MODIFY) failed"); + if (prev_hicon) + DestroyIcon (prev_hicon); #endif #ifdef GDK_WINDOWING_QUARTZ QUARTZ_POOL_ALLOC; - [priv->status_item setImage:scaled]; + [priv->status_item setImage:pixbuf]; QUARTZ_POOL_RELEASE; #endif - - g_object_unref (scaled); - } - else - { -#ifdef GDK_WINDOWING_X11 - gtk_image_set_from_pixbuf (GTK_IMAGE (priv->image), NULL); -#endif -#ifdef GDK_WINDOWING_WIN32 - priv->nid.uFlags &= ~NIF_ICON; - if (priv->nid.hWnd != NULL && priv->visible) - if (!Shell_NotifyIconW (NIM_MODIFY, &priv->nid)) - g_warning (G_STRLOC ": Shell_NotifyIcon(NIM_MODIFY) failed"); -#endif -#ifdef GDK_WINDOWING_QUARTZ - [priv->status_item setImage:NULL]; -#endif - } - } - break; - - case GTK_IMAGE_STOCK: - { -#ifdef GDK_WINDOWING_X11 - GtkIconSize size = find_icon_size (priv->image, priv->size); - gtk_image_set_from_stock (GTK_IMAGE (priv->image), - priv->image_data.stock_id, - size); -#endif -#ifdef GDK_WINDOWING_WIN32 - { - GdkPixbuf *pixbuf = - gtk_widget_render_icon (priv->dummy_widget, - priv->image_data.stock_id, - GTK_ICON_SIZE_SMALL_TOOLBAR, - NULL); - - prev_hicon = priv->nid.hIcon; - priv->nid.hIcon = gdk_win32_pixbuf_to_hicon_libgtk_only (pixbuf); - priv->nid.uFlags |= NIF_ICON; - if (priv->nid.hWnd != NULL && priv->visible) - if (!Shell_NotifyIconW (NIM_MODIFY, &priv->nid)) - g_warning (G_STRLOC ": Shell_NotifyIcon(NIM_MODIFY) failed"); - if (prev_hicon) - DestroyIcon (prev_hicon); - g_object_unref (pixbuf); - } -#endif -#ifdef GDK_WINDOWING_QUARTZ - { - GdkPixbuf *pixbuf; - - pixbuf = gtk_widget_render_icon (priv->dummy_widget, - priv->image_data.stock_id, - GTK_ICON_SIZE_SMALL_TOOLBAR, - NULL); - QUARTZ_POOL_ALLOC; - [priv->status_item setImage:pixbuf]; - QUARTZ_POOL_RELEASE; - g_object_unref (pixbuf); - } -#endif - } - break; - - case GTK_IMAGE_ICON_NAME: - { -#ifdef GDK_WINDOWING_X11 - GtkIconSize size = find_icon_size (priv->image, priv->size); - gtk_image_set_from_icon_name (GTK_IMAGE (priv->image), - priv->image_data.icon_name, - size); -#endif -#ifdef GDK_WINDOWING_WIN32 - { - GdkPixbuf *pixbuf = - gtk_icon_theme_load_icon (gtk_icon_theme_get_default (), - priv->image_data.icon_name, - priv->size, - 0, NULL); - - prev_hicon = priv->nid.hIcon; - priv->nid.hIcon = gdk_win32_pixbuf_to_hicon_libgtk_only (pixbuf); - priv->nid.uFlags |= NIF_ICON; - if (priv->nid.hWnd != NULL && priv->visible) - if (!Shell_NotifyIconW (NIM_MODIFY, &priv->nid)) - g_warning (G_STRLOC ": Shell_NotifyIcon(NIM_MODIFY) failed"); - if (prev_hicon) - DestroyIcon (prev_hicon); - g_object_unref (pixbuf); - } -#endif -#ifdef GDK_WINDOWING_QUARTZ - { - GdkPixbuf *pixbuf; - - pixbuf = gtk_icon_theme_load_icon (gtk_icon_theme_get_default (), - priv->image_data.icon_name, - priv->size, - 0, NULL); - - QUARTZ_POOL_ALLOC; - [priv->status_item setImage:pixbuf]; - QUARTZ_POOL_RELEASE; - g_object_unref (pixbuf); - } -#endif - - } - break; - - case GTK_IMAGE_GICON: - { -#ifdef GDK_WINDOWING_X11 - GtkIconSize size = find_icon_size (priv->image, priv->size); - gtk_image_set_from_gicon (GTK_IMAGE (priv->image), - priv->image_data.gicon, - size); -#endif -#ifdef GDK_WINDOWING_WIN32 - { - GtkIconInfo *info = - gtk_icon_theme_lookup_by_gicon (gtk_icon_theme_get_default (), - priv->image_data.gicon, - priv->size, - 0); - GdkPixbuf *pixbuf = gtk_icon_info_load_icon (info, NULL); - - prev_hicon = priv->nid.hIcon; - priv->nid.hIcon = gdk_win32_pixbuf_to_hicon_libgtk_only (pixbuf); - priv->nid.uFlags |= NIF_ICON; - if (priv->nid.hWnd != NULL && priv->visible) - if (!Shell_NotifyIconW (NIM_MODIFY, &priv->nid)) - g_warning (G_STRLOC ": Shell_NotifyIcon(NIM_MODIFY) failed"); - if (prev_hicon) - DestroyIcon (prev_hicon); - g_object_unref (pixbuf); - } -#endif -#ifdef GDK_WINDOWING_QUARTZ - { - GtkIconInfo *info = - gtk_icon_theme_lookup_by_gicon (gtk_icon_theme_get_default (), - priv->image_data.gicon, - priv->size, - 0); - GdkPixbuf *pixbuf = gtk_icon_info_load_icon (info, NULL); - - QUARTZ_POOL_ALLOC; - [priv->status_item setImage:pixbuf]; - QUARTZ_POOL_RELEASE; - g_object_unref (pixbuf); - } -#endif - - } - break; - - case GTK_IMAGE_EMPTY: + } + else + { #ifdef GDK_WINDOWING_X11 gtk_image_set_from_pixbuf (GTK_IMAGE (priv->image), NULL); #endif #ifdef GDK_WINDOWING_WIN32 priv->nid.uFlags &= ~NIF_ICON; if (priv->nid.hWnd != NULL && priv->visible) - if (!Shell_NotifyIconW (NIM_MODIFY, &priv->nid)) - g_warning (G_STRLOC ": Shell_NotifyIcon(NIM_MODIFY) failed"); + if (!Shell_NotifyIconW (NIM_MODIFY, &priv->nid)) + g_warning (G_STRLOC ": Shell_NotifyIcon(NIM_MODIFY) failed"); #endif #ifdef GDK_WINDOWING_QUARTZ - { - QUARTZ_POOL_ALLOC; - [priv->status_item setImage:NULL]; - QUARTZ_POOL_RELEASE; - } + [priv->status_item setImage:NULL]; #endif - break; - default: - g_assert_not_reached (); - break; } + + g_clear_object (&pixbuf); } #ifdef GDK_WINDOWING_X11 @@ -1580,7 +1443,6 @@ gtk_status_icon_size_allocate (GtkStatusIcon *status_icon, GtkStatusIconPrivate *priv = status_icon->priv; GtkOrientation orientation; gint size; - gint xpad, ypad; orientation = _gtk_tray_icon_get_orientation (GTK_TRAY_ICON (priv->tray_icon)); @@ -1589,11 +1451,6 @@ gtk_status_icon_size_allocate (GtkStatusIcon *status_icon, else size = allocation->width; - gtk_misc_get_padding (GTK_MISC (priv->image), &xpad, &ypad); - - priv->image_width = allocation->width - xpad * 2; - priv->image_height = allocation->height - ypad * 2; - if (priv->size != size) { priv->size = size; @@ -1632,15 +1489,36 @@ gtk_status_icon_padding_changed (GtkStatusIcon *status_icon) padding = _gtk_tray_icon_get_padding (GTK_TRAY_ICON (priv->tray_icon)); if (orientation == GTK_ORIENTATION_HORIZONTAL) - gtk_misc_set_padding (GTK_MISC (priv->image), padding, 0); + { + gtk_widget_set_margin_left (priv->image, padding); + gtk_widget_set_margin_right (priv->image, padding); + } + else + { + gtk_widget_set_margin_bottom (priv->image, padding); + gtk_widget_set_margin_top (priv->image, padding); + } +} + +static void +gtk_status_icon_icon_size_changed (GtkStatusIcon *status_icon) +{ + GtkStatusIconPrivate *priv = status_icon->priv; + gint icon_size; + + icon_size = _gtk_tray_icon_get_icon_size (GTK_TRAY_ICON (priv->tray_icon)); + + if (icon_size != 0) + gtk_image_set_pixel_size (GTK_IMAGE (priv->image), icon_size); else - gtk_misc_set_padding (GTK_MISC (priv->image), 0, padding); + gtk_image_set_pixel_size (GTK_IMAGE (priv->image), -1); } static void gtk_status_icon_embedded_changed (GtkStatusIcon *status_icon) { gtk_status_icon_padding_changed (status_icon); + gtk_status_icon_icon_size_changed (status_icon); g_object_notify (G_OBJECT (status_icon), "embedded"); } @@ -1655,10 +1533,13 @@ static void gtk_status_icon_fg_changed (GtkStatusIcon *status_icon) { GtkStatusIconPrivate *priv = status_icon->priv; - GdkColor color; + GdkRGBA *rgba; + + g_object_get (priv->tray_icon, "fg-color", &rgba, NULL); + + gtk_widget_override_color (priv->image, GTK_STATE_FLAG_NORMAL, rgba); - g_object_get (priv->tray_icon, "fg-color", &color, NULL); - gtk_widget_modify_fg (priv->image, GTK_STATE_NORMAL, &color); + gdk_rgba_free (rgba); } static void @@ -1668,7 +1549,6 @@ gtk_status_icon_color_changed (GtkTrayIcon *tray, { GtkStatusIconPrivate *priv = status_icon->priv; const gchar *name; - GdkColor color; switch (pspec->name[0]) { @@ -1688,8 +1568,13 @@ gtk_status_icon_color_changed (GtkTrayIcon *tray, if (name) { - g_object_get (priv->tray_icon, pspec->name, &color, NULL); - gtk_widget_modify_symbolic_color (priv->image, name, &color); + GdkRGBA rgba; + + g_object_get (priv->tray_icon, pspec->name, &rgba, NULL); + + rgba.alpha = 1; + + gtk_widget_override_symbolic_color (priv->image, name, &rgba); } } @@ -1735,14 +1620,14 @@ gtk_status_icon_button_press (GtkStatusIcon *status_icon, if (handled) return TRUE; - if (event->button == 1 && event->type == GDK_BUTTON_PRESS) + if (gdk_event_triggers_context_menu ((GdkEvent *) event)) { - emit_activate_signal (status_icon); + emit_popup_menu_signal (status_icon, event->button, event->time); return TRUE; } - else if (event->button == 3 && event->type == GDK_BUTTON_PRESS) + else if (event->button == GDK_BUTTON_PRIMARY && event->type == GDK_BUTTON_PRESS) { - emit_popup_menu_signal (status_icon, event->button, event->time); + emit_activate_signal (status_icon); return TRUE; } @@ -1791,38 +1676,22 @@ static void gtk_status_icon_reset_image_data (GtkStatusIcon *status_icon) { GtkStatusIconPrivate *priv = status_icon->priv; + GtkImageType storage_type = _gtk_icon_helper_get_storage_type (priv->icon_helper); - switch (priv->storage_type) + switch (storage_type) { case GTK_IMAGE_PIXBUF: - if (priv->image_data.pixbuf) - g_object_unref (priv->image_data.pixbuf); - priv->image_data.pixbuf = NULL; g_object_notify (G_OBJECT (status_icon), "pixbuf"); break; - case GTK_IMAGE_STOCK: - g_free (priv->image_data.stock_id); - priv->image_data.stock_id = NULL; - g_object_notify (G_OBJECT (status_icon), "stock"); - break; - + break; case GTK_IMAGE_ICON_NAME: - g_free (priv->image_data.icon_name); - priv->image_data.icon_name = NULL; - g_object_notify (G_OBJECT (status_icon), "icon-name"); break; - case GTK_IMAGE_GICON: - if (priv->image_data.gicon) - g_object_unref (priv->image_data.gicon); - priv->image_data.gicon = NULL; - g_object_notify (G_OBJECT (status_icon), "gicon"); break; - case GTK_IMAGE_EMPTY: break; default: @@ -1830,7 +1699,7 @@ gtk_status_icon_reset_image_data (GtkStatusIcon *status_icon) break; } - priv->storage_type = GTK_IMAGE_EMPTY; + _gtk_icon_helper_clear (priv->icon_helper); g_object_notify (G_OBJECT (status_icon), "storage-type"); } @@ -1845,25 +1714,27 @@ gtk_status_icon_set_image (GtkStatusIcon *status_icon, gtk_status_icon_reset_image_data (status_icon); - priv->storage_type = storage_type; g_object_notify (G_OBJECT (status_icon), "storage-type"); + /* the icon size we pass here doesn't really matter, since + * we force a pixel size before doing the actual rendering anyway. + */ switch (storage_type) { case GTK_IMAGE_PIXBUF: - priv->image_data.pixbuf = (GdkPixbuf *)data; + _gtk_icon_helper_set_pixbuf (priv->icon_helper, data); g_object_notify (G_OBJECT (status_icon), "pixbuf"); break; case GTK_IMAGE_STOCK: - priv->image_data.stock_id = g_strdup ((const gchar *)data); + _gtk_icon_helper_set_stock_id (priv->icon_helper, data, GTK_ICON_SIZE_SMALL_TOOLBAR); g_object_notify (G_OBJECT (status_icon), "stock"); break; case GTK_IMAGE_ICON_NAME: - priv->image_data.icon_name = g_strdup ((const gchar *)data); + _gtk_icon_helper_set_icon_name (priv->icon_helper, data, GTK_ICON_SIZE_SMALL_TOOLBAR); g_object_notify (G_OBJECT (status_icon), "icon-name"); break; case GTK_IMAGE_GICON: - priv->image_data.gicon = (GIcon *)data; + _gtk_icon_helper_set_gicon (priv->icon_helper, data, GTK_ICON_SIZE_SMALL_TOOLBAR); g_object_notify (G_OBJECT (status_icon), "gicon"); break; default: @@ -1892,9 +1763,6 @@ gtk_status_icon_set_from_pixbuf (GtkStatusIcon *status_icon, g_return_if_fail (GTK_IS_STATUS_ICON (status_icon)); g_return_if_fail (pixbuf == NULL || GDK_IS_PIXBUF (pixbuf)); - if (pixbuf) - g_object_ref (pixbuf); - gtk_status_icon_set_image (status_icon, GTK_IMAGE_PIXBUF, (gpointer) pixbuf); } @@ -1902,7 +1770,7 @@ gtk_status_icon_set_from_pixbuf (GtkStatusIcon *status_icon, /** * gtk_status_icon_set_from_file: * @status_icon: a #GtkStatusIcon - * @filename: a filename + * @filename: (type filename): a filename * * Makes @status_icon display the file @filename. * See gtk_status_icon_new_from_file() for details. @@ -1986,9 +1854,6 @@ gtk_status_icon_set_from_gicon (GtkStatusIcon *status_icon, g_return_if_fail (GTK_IS_STATUS_ICON (status_icon)); g_return_if_fail (icon != NULL); - if (icon) - g_object_ref (icon); - gtk_status_icon_set_image (status_icon, GTK_IMAGE_GICON, (gpointer) icon); } @@ -2010,7 +1875,7 @@ gtk_status_icon_get_storage_type (GtkStatusIcon *status_icon) { g_return_val_if_fail (GTK_IS_STATUS_ICON (status_icon), GTK_IMAGE_EMPTY); - return status_icon->priv->storage_type; + return _gtk_icon_helper_get_storage_type (status_icon->priv->icon_helper); } /** * gtk_status_icon_get_pixbuf: @@ -2022,7 +1887,8 @@ gtk_status_icon_get_storage_type (GtkStatusIcon *status_icon) * The caller of this function does not own a reference to the * returned pixbuf. * - * Return value: the displayed pixbuf, or %NULL if the image is empty. + * Return value: (transfer none): the displayed pixbuf, + * or %NULL if the image is empty. * * Since: 2.10 **/ @@ -2035,13 +1901,7 @@ gtk_status_icon_get_pixbuf (GtkStatusIcon *status_icon) priv = status_icon->priv; - g_return_val_if_fail (priv->storage_type == GTK_IMAGE_PIXBUF || - priv->storage_type == GTK_IMAGE_EMPTY, NULL); - - if (priv->storage_type == GTK_IMAGE_EMPTY) - priv->image_data.pixbuf = NULL; - - return priv->image_data.pixbuf; + return _gtk_icon_helper_peek_pixbuf (priv->icon_helper); } /** @@ -2059,7 +1919,7 @@ gtk_status_icon_get_pixbuf (GtkStatusIcon *status_icon) * * Since: 2.10 **/ -G_CONST_RETURN gchar * +const gchar * gtk_status_icon_get_stock (GtkStatusIcon *status_icon) { GtkStatusIconPrivate *priv; @@ -2068,13 +1928,7 @@ gtk_status_icon_get_stock (GtkStatusIcon *status_icon) priv = status_icon->priv; - g_return_val_if_fail (priv->storage_type == GTK_IMAGE_STOCK || - priv->storage_type == GTK_IMAGE_EMPTY, NULL); - - if (priv->storage_type == GTK_IMAGE_EMPTY) - priv->image_data.stock_id = NULL; - - return priv->image_data.stock_id; + return _gtk_icon_helper_get_stock_id (priv->icon_helper); } /** @@ -2091,7 +1945,7 @@ gtk_status_icon_get_stock (GtkStatusIcon *status_icon) * * Since: 2.10 **/ -G_CONST_RETURN gchar * +const gchar * gtk_status_icon_get_icon_name (GtkStatusIcon *status_icon) { GtkStatusIconPrivate *priv; @@ -2100,13 +1954,7 @@ gtk_status_icon_get_icon_name (GtkStatusIcon *status_icon) priv = status_icon->priv; - g_return_val_if_fail (priv->storage_type == GTK_IMAGE_ICON_NAME || - priv->storage_type == GTK_IMAGE_EMPTY, NULL); - - if (priv->storage_type == GTK_IMAGE_EMPTY) - priv->image_data.icon_name = NULL; - - return priv->image_data.icon_name; + return _gtk_icon_helper_get_icon_name (priv->icon_helper); } /** @@ -2121,7 +1969,7 @@ gtk_status_icon_get_icon_name (GtkStatusIcon *status_icon) * * If this function fails, @icon is left unchanged; * - * Returns: the displayed icon, or %NULL if the image is empty + * Returns: (transfer none): the displayed icon, or %NULL if the image is empty * * Since: 2.14 **/ @@ -2134,13 +1982,7 @@ gtk_status_icon_get_gicon (GtkStatusIcon *status_icon) priv = status_icon->priv; - g_return_val_if_fail (priv->storage_type == GTK_IMAGE_GICON || - priv->storage_type == GTK_IMAGE_EMPTY, NULL); - - if (priv->storage_type == GTK_IMAGE_EMPTY) - priv->image_data.gicon = NULL; - - return priv->image_data.gicon; + return _gtk_icon_helper_peek_gicon (priv->icon_helper); } /** @@ -2190,13 +2032,13 @@ gtk_status_icon_set_screen (GtkStatusIcon *status_icon, #endif } -/** +/** * gtk_status_icon_get_screen: * @status_icon: a #GtkStatusIcon * * Returns the #GdkScreen associated with @status_icon. * - * Return value: a #GdkScreen. + * Return value: (transfer none): a #GdkScreen. * * Since: 2.12 */ @@ -2205,7 +2047,7 @@ gtk_status_icon_get_screen (GtkStatusIcon *status_icon) { g_return_val_if_fail (GTK_IS_STATUS_ICON (status_icon), NULL); -#ifdef GDK_WINDOWING_X11 +#ifdef GDK_WINDOWING_X11 return gtk_window_get_screen (GTK_WINDOW (status_icon->priv->tray_icon)); #else return gdk_screen_get_default (); @@ -2325,11 +2167,12 @@ gtk_status_icon_is_embedded (GtkStatusIcon *status_icon) /** * gtk_status_icon_position_menu: * @menu: the #GtkMenu - * @x: return location for the x position - * @y: return location for the y position - * @push_in: whether the first menu item should be offset (pushed in) to be - * aligned with the menu popup position (only useful for GtkOptionMenu). - * @user_data: the status icon to position the menu on + * @x: (out): return location for the x position + * @y: (out): return location for the y position + * @push_in: (out): whether the first menu item should be offset + * (pushed in) to be aligned with the menu popup position + * (only useful for GtkOptionMenu). + * @user_data: (type GtkStatusIcon): the status icon to position the menu on * * Menu positioning function to use with gtk_menu_popup() * to position @menu aligned to the status icon @user_data. @@ -2375,11 +2218,12 @@ gtk_status_icon_position_menu (GtkMenu *menu, monitor_num = 0; gtk_menu_set_monitor (menu, monitor_num); - gdk_screen_get_monitor_geometry (screen, monitor_num, &monitor); + gdk_screen_get_monitor_workarea (screen, monitor_num, &monitor); gdk_window_get_origin (window, x, y); - gtk_widget_size_request (GTK_WIDGET (menu), &menu_req); + menu_req.width = gtk_widget_get_allocated_width (GTK_WIDGET (menu)); + menu_req.height = gtk_widget_get_allocated_height (GTK_WIDGET (menu)); gtk_widget_get_allocation (widget, &allocation); if (_gtk_tray_icon_get_orientation (tray_icon) == GTK_ORIENTATION_VERTICAL) @@ -2435,6 +2279,7 @@ gtk_status_icon_position_menu (GtkMenu *menu, #ifdef GDK_WINDOWING_WIN32 GtkStatusIcon *status_icon; GtkStatusIconPrivate *priv; + GtkRequisition menu_req; g_return_if_fail (GTK_IS_MENU (menu)); g_return_if_fail (GTK_IS_STATUS_ICON (user_data)); @@ -2442,8 +2287,11 @@ gtk_status_icon_position_menu (GtkMenu *menu, status_icon = GTK_STATUS_ICON (user_data); priv = status_icon->priv; + gtk_widget_size_request (GTK_WIDGET (menu), &menu_req); + *x = priv->last_click_x; - *y = priv->last_click_y; + *y = priv->taskbar_top - menu_req.height; + *push_in = TRUE; #endif } @@ -2451,14 +2299,14 @@ gtk_status_icon_position_menu (GtkMenu *menu, /** * gtk_status_icon_get_geometry: * @status_icon: a #GtkStatusIcon - * @screen: (out) (transfer none) (allow-none): return location for the screen, or %NULL if the - * information is not needed - * @area: (out) (allow-none): return location for the area occupied by the status - * icon, or %NULL - * @orientation: (out) (allow-none): return location for the orientation of the panel - * in which the status icon is embedded, or %NULL. A panel - * at the top or bottom of the screen is horizontal, a panel - * at the left or right is vertical. + * @screen: (out) (transfer none) (allow-none): return location for + * the screen, or %NULL if the information is not needed + * @area: (out) (allow-none): return location for the area occupied by + * the status icon, or %NULL + * @orientation: (out) (allow-none): return location for the + * orientation of the panel in which the status icon is embedded, + * or %NULL. A panel at the top or bottom of the screen is + * horizontal, a panel at the left or right is vertical. * * Obtains information about the location of the status icon * on screen. This information can be used to e.g. position @@ -2842,7 +2690,7 @@ gtk_status_icon_set_title (GtkStatusIcon *status_icon, * * Since: 2.18 */ -G_CONST_RETURN gchar * +const gchar * gtk_status_icon_get_title (GtkStatusIcon *status_icon) { GtkStatusIconPrivate *priv; @@ -2886,8 +2734,17 @@ gtk_status_icon_set_name (GtkStatusIcon *status_icon, priv = status_icon->priv; #ifdef GDK_WINDOWING_X11 - gtk_window_set_wmclass (GTK_WINDOW (priv->tray_icon), name, name); + if (gtk_widget_get_realized (priv->tray_icon)) + { + /* gtk_window_set_wmclass() only operates on non-realized windows, + * so temporarily unrealize the tray here + */ + gtk_widget_hide (priv->tray_icon); + gtk_widget_unrealize (priv->tray_icon); + gtk_window_set_wmclass (GTK_WINDOW (priv->tray_icon), name, name); + gtk_widget_show (priv->tray_icon); + } + else + gtk_window_set_wmclass (GTK_WINDOW (priv->tray_icon), name, name); #endif - - g_object_notify (G_OBJECT (status_icon), "name"); }