X-Git-Url: http://pileus.org/git/?a=blobdiff_plain;f=gtk%2Fgtkstatusicon.c;h=679ca95d04f11d7699fb0daa01482d3715e5ca83;hb=9f41970832b60f3cf6644dfbd154df7ec24f26ce;hp=6b39398f4f1d709ca5d45a5b85738a4d51fa6e7b;hpb=1b34902d33768b5f92fc00947b92225ed2ff73f2;p=~andy%2Fgtk diff --git a/gtk/gtkstatusicon.c b/gtk/gtkstatusicon.c index 6b39398f4..679ca95d0 100644 --- a/gtk/gtkstatusicon.c +++ b/gtk/gtkstatusicon.c @@ -16,9 +16,7 @@ * Library General Public License for more details. * * You should have received a copy of the GNU Library General Public - * License along with this library; if not, write to the - * Free Software Foundation, Inc., 59 Temple Place - Suite 330, - * Boston, MA 02111-1307, USA. + * License along with this library. If not, see . * * Authors: * Mark McLoughlin @@ -28,39 +26,64 @@ */ #include "config.h" + #include +#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. + */ -#include "gtkalias.h" #define BLINK_TIMEOUT 500 @@ -78,7 +101,11 @@ enum PROP_VISIBLE, PROP_ORIENTATION, PROP_EMBEDDED, - PROP_BLINKING + PROP_BLINKING, + PROP_HAS_TOOLTIP, + PROP_TOOLTIP_TEXT, + PROP_TOOLTIP_MARKUP, + PROP_TITLE }; enum @@ -86,6 +113,10 @@ enum ACTIVATE_SIGNAL, POPUP_MENU_SIGNAL, SIZE_CHANGED_SIGNAL, + BUTTON_PRESS_EVENT_SIGNAL, + BUTTON_RELEASE_EVENT_SIGNAL, + SCROLL_EVENT_SIGNAL, + QUERY_TOOLTIP_SIGNAL, LAST_SIGNAL }; @@ -100,41 +131,28 @@ 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; + gchar *title; #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; - - GdkPixbuf *blank_icon; - guint blinking_timeout; - - guint blinking : 1; - guint blink_off : 1; - guint visible : 1; + gint size; + GtkIconHelper *icon_helper; + guint visible : 1; }; static GObject* gtk_status_icon_constructor (GType type, @@ -157,6 +175,19 @@ static void gtk_status_icon_screen_changed (GtkStatusIcon *status_icon, GdkScreen *old_screen); 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, + GtkStatusIcon *status_icon); +static gboolean gtk_status_icon_scroll (GtkStatusIcon *status_icon, + GdkEventScroll *event); +static gboolean gtk_status_icon_query_tooltip (GtkStatusIcon *status_icon, + gint x, + gint y, + gboolean keyboard_tip, + GtkTooltip *tooltip); static gboolean gtk_status_icon_key_press (GtkStatusIcon *status_icon, GdkEventKey *event); @@ -164,7 +195,8 @@ static void gtk_status_icon_popup_menu (GtkStatusIcon *status_icon); #endif static gboolean gtk_status_icon_button_press (GtkStatusIcon *status_icon, GdkEventButton *event); -static void gtk_status_icon_disable_blinking (GtkStatusIcon *status_icon); +static gboolean gtk_status_icon_button_release (GtkStatusIcon *status_icon, + GdkEventButton *event); static void gtk_status_icon_reset_image_data (GtkStatusIcon *status_icon); static void gtk_status_icon_update_image (GtkStatusIcon *status_icon); @@ -180,6 +212,11 @@ gtk_status_icon_class_init (GtkStatusIconClass *class) gobject_class->set_property = gtk_status_icon_set_property; gobject_class->get_property = gtk_status_icon_get_property; + class->button_press_event = NULL; + class->button_release_event = NULL; + class->scroll_event = NULL; + class->query_tooltip = NULL; + g_object_class_install_property (gobject_class, PROP_PIXBUF, g_param_spec_object ("pixbuf", @@ -255,19 +292,11 @@ gtk_status_icon_class_init (GtkStatusIconClass *class) GDK_TYPE_SCREEN, GTK_PARAM_READWRITE)); - g_object_class_install_property (gobject_class, - PROP_BLINKING, - g_param_spec_boolean ("blinking", - P_("Blinking"), - P_("Whether or not the status icon is blinking"), - FALSE, - GTK_PARAM_READWRITE)); - g_object_class_install_property (gobject_class, PROP_VISIBLE, g_param_spec_boolean ("visible", P_("Visible"), - P_("Whether or not the status icon is visible"), + P_("Whether the status icon is visible"), TRUE, GTK_PARAM_READWRITE)); @@ -283,7 +312,7 @@ gtk_status_icon_class_init (GtkStatusIconClass *class) PROP_EMBEDDED, g_param_spec_boolean ("embedded", P_("Embedded"), - P_("Whether or not the status icon is embedded"), + P_("Whether the status icon is embedded"), FALSE, GTK_PARAM_READABLE)); @@ -304,6 +333,100 @@ gtk_status_icon_class_init (GtkStatusIconClass *class) GTK_ORIENTATION_HORIZONTAL, GTK_PARAM_READABLE)); +/** + * GtkStatusIcon:has-tooltip: + * + * Enables or disables the emission of #GtkStatusIcon::query-tooltip on + * @status_icon. A value of %TRUE indicates that @status_icon can have a + * tooltip, in this case the status icon will be queried using + * #GtkStatusIcon::query-tooltip to determine whether it will provide a + * tooltip or not. + * + * Note that setting this property to %TRUE for the first time will change + * the event masks of the windows of this status icon to include leave-notify + * and motion-notify events. This will not be undone when the property is set + * to %FALSE again. + * + * Whether this property is respected is platform dependent. + * For plain text tooltips, use #GtkStatusIcon:tooltip-text in preference. + * + * Since: 2.16 + */ + g_object_class_install_property (gobject_class, + PROP_HAS_TOOLTIP, + g_param_spec_boolean ("has-tooltip", + P_("Has tooltip"), + P_("Whether this tray icon has a tooltip"), + FALSE, + GTK_PARAM_READWRITE)); + /** + * GtkStatusIcon:tooltip-text: + * + * Sets the text of tooltip to be the given string. + * + * Also see gtk_tooltip_set_text(). + * + * This is a convenience property which will take care of getting the + * tooltip shown if the given string is not %NULL. + * #GtkStatusIcon:has-tooltip will automatically be set to %TRUE and + * the default handler for the #GtkStatusIcon::query-tooltip signal + * will take care of displaying the tooltip. + * + * Note that some platforms have limitations on the length of tooltips + * that they allow on status icons, e.g. Windows only shows the first + * 64 characters. + * + * Since: 2.16 + */ + g_object_class_install_property (gobject_class, + PROP_TOOLTIP_TEXT, + g_param_spec_string ("tooltip-text", + P_("Tooltip Text"), + P_("The contents of the tooltip for this widget"), + NULL, + GTK_PARAM_READWRITE)); + /** + * GtkStatusIcon:tooltip-markup: + * + * Sets the text of tooltip to be the given string, which is marked up + * with the Pango text markup + * language. Also see gtk_tooltip_set_markup(). + * + * This is a convenience property which will take care of getting the + * tooltip shown if the given string is not %NULL. + * #GtkStatusIcon:has-tooltip will automatically be set to %TRUE and + * the default handler for the #GtkStatusIcon::query-tooltip signal + * will take care of displaying the tooltip. + * + * On some platforms, embedded markup will be ignored. + * + * Since: 2.16 + */ + g_object_class_install_property (gobject_class, + PROP_TOOLTIP_MARKUP, + g_param_spec_string ("tooltip-markup", + P_("Tooltip markup"), + P_("The contents of the tooltip for this tray icon"), + NULL, + GTK_PARAM_READWRITE)); + + + /** + * GtkStatusIcon:title: + * + * The title of this tray icon. This should be a short, human-readable, + * localized string describing the tray icon. It may be used by tools + * like screen readers to render the tray icon. + * + * Since: 2.18 + */ + g_object_class_install_property (gobject_class, + PROP_TITLE, + g_param_spec_string ("title", + P_("Title"), + P_("The title of this tray icon"), + NULL, + GTK_PARAM_READWRITE)); /** * GtkStatusIcon::activate: @@ -386,6 +509,130 @@ gtk_status_icon_class_init (GtkStatusIconClass *class) 1, G_TYPE_INT); + /** + * GtkStatusIcon::button-press-event: + * @status_icon: the object which received the 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. + * + * Whether this event is emitted is platform-dependent. Use the ::activate + * and ::popup-menu signals in preference. + * + * Return value: %TRUE to stop other handlers from being invoked + * for the event. %FALSE to propagate the event further. + * + * Since: 2.14 + */ + status_icon_signals [BUTTON_PRESS_EVENT_SIGNAL] = + g_signal_new (I_("button_press_event"), + G_TYPE_FROM_CLASS (gobject_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (GtkStatusIconClass, button_press_event), + g_signal_accumulator_true_handled, NULL, + _gtk_marshal_BOOLEAN__BOXED, + G_TYPE_BOOLEAN, 1, + GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE); + + /** + * GtkStatusIcon::button-release-event: + * @status_icon: the object which received the 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. + * + * Whether this event is emitted is platform-dependent. Use the ::activate + * and ::popup-menu signals in preference. + * + * Return value: %TRUE to stop other handlers from being invoked + * for the event. %FALSE to propagate the event further. + * + * Since: 2.14 + */ + status_icon_signals [BUTTON_RELEASE_EVENT_SIGNAL] = + g_signal_new (I_("button_release_event"), + G_TYPE_FROM_CLASS (gobject_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (GtkStatusIconClass, button_release_event), + g_signal_accumulator_true_handled, NULL, + _gtk_marshal_BOOLEAN__BOXED, + G_TYPE_BOOLEAN, 1, + GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE); + + /** + * GtkStatusIcon::scroll-event: + * @status_icon: the object which received the 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 + * button press events for buttons 4 and 5 when the wheel is turned. + * + * Whether this event is emitted is platform-dependent. + * + * Returns: %TRUE to stop other handlers from being invoked for the event. + * %FALSE to propagate the event further. + * + * Since: 2.16 + */ + status_icon_signals[SCROLL_EVENT_SIGNAL] = + g_signal_new (I_("scroll_event"), + G_TYPE_FROM_CLASS (gobject_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (GtkStatusIconClass, scroll_event), + g_signal_accumulator_true_handled, NULL, + _gtk_marshal_BOOLEAN__BOXED, + G_TYPE_BOOLEAN, 1, + GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE); + + /** + * GtkStatusIcon::query-tooltip: + * @status_icon: the object which received the signal + * @x: the x coordinate of the cursor position where the request has been + * emitted, relative to @status_icon + * @y: the y coordinate of the cursor position where the request has been + * emitted, relative to @status_icon + * @keyboard_mode: %TRUE if the tooltip was trigged using the keyboard + * @tooltip: a #GtkTooltip + * + * Emitted when the #GtkSettings:gtk-tooltip-timeout has expired with the + * cursor hovering above @status_icon; or emitted when @status_icon got + * focus in keyboard mode. + * + * Using the given coordinates, the signal handler should determine + * whether a tooltip should be shown for @status_icon. If this is + * the case %TRUE should be returned, %FALSE otherwise. Note that if + * @keyboard_mode is %TRUE, the values of @x and @y are undefined and + * should not be used. + * + * The signal handler is free to manipulate @tooltip with the therefore + * destined function calls. + * + * Whether this signal is emitted is platform-dependent. + * For plain text tooltips, use #GtkStatusIcon:tooltip-text in preference. + * + * Returns: %TRUE if @tooltip should be shown right now, %FALSE otherwise. + * + * Since: 2.16 + */ + status_icon_signals [QUERY_TOOLTIP_SIGNAL] = + g_signal_new (I_("query_tooltip"), + G_TYPE_FROM_CLASS (gobject_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (GtkStatusIconClass, query_tooltip), + g_signal_accumulator_true_handled, NULL, + _gtk_marshal_BOOLEAN__INT_INT_BOOLEAN_OBJECT, + G_TYPE_BOOLEAN, 4, + G_TYPE_INT, + G_TYPE_INT, + G_TYPE_BOOLEAN, + GTK_TYPE_TOOLTIP); + g_type_class_add_private (class, sizeof (GtkStatusIconPrivate)); } @@ -410,7 +657,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; } @@ -426,12 +673,15 @@ button_callback (gpointer data) { ButtonCallbackData *bc = (ButtonCallbackData *) data; - gtk_status_icon_button_press (bc->status_icon, bc->event); + if (bc->event->type == GDK_BUTTON_PRESS) + gtk_status_icon_button_press (bc->status_icon, bc->event); + else + gtk_status_icon_button_release (bc->status_icon, bc->event); gdk_event_free ((GdkEvent *) bc->event); g_free (data); - return FALSE; + return G_SOURCE_REMOVE; } static UINT taskbar_created_msg = 0; @@ -459,7 +709,7 @@ wndproc (HWND hwnd, if (!Shell_NotifyIconW (NIM_ADD, &priv->nid)) { - g_warning ("%s:%d:Shell_NotifyIcon(NIM_ADD) failed", __FILE__, __LINE__-2); + g_warning (G_STRLOC ": Shell_NotifyIcon(NIM_ADD) failed"); priv->nid.hWnd = NULL; continue; } @@ -472,17 +722,62 @@ wndproc (HWND hwnd, if (message == WM_GTK_TRAY_NOTIFICATION) { ButtonCallbackData *bc; + guint button; switch (lparam) { case WM_LBUTTONDOWN: + button = 1; + goto buttondown0; + + case WM_MBUTTONDOWN: + button = 2; + goto buttondown0; + case WM_RBUTTONDOWN: + button = 3; + goto buttondown0; + + case WM_XBUTTONDOWN: + if (HIWORD (wparam) == XBUTTON1) + button = 4; + else + button = 5; + + buttondown0: bc = g_new (ButtonCallbackData, 1); bc->event = (GdkEventButton *) gdk_event_new (GDK_BUTTON_PRESS); bc->status_icon = GTK_STATUS_ICON (wparam); - build_button_event (bc->status_icon->priv, bc->event, (lparam == WM_LBUTTONDOWN) ? 1 : 3); + build_button_event (bc->status_icon->priv, bc->event, button); + g_idle_add (button_callback, bc); + break; + + case WM_LBUTTONUP: + button = 1; + goto buttonup0; + + case WM_MBUTTONUP: + button = 2; + goto buttonup0; + + case WM_RBUTTONUP: + button = 3; + goto buttonup0; + + case WM_XBUTTONUP: + if (HIWORD (wparam) == XBUTTON1) + button = 4; + else + button = 5; + + buttonup0: + bc = g_new (ButtonCallbackData, 1); + bc->event = (GdkEventButton *) gdk_event_new (GDK_BUTTON_RELEASE); + bc->status_icon = GTK_STATUS_ICON (wparam); + build_button_event (bc->status_icon->priv, bc->event, button); g_idle_add (button_callback, bc); break; + default : break; } @@ -539,40 +834,67 @@ gtk_status_icon_init (GtkStatusIcon *status_icon) priv = G_TYPE_INSTANCE_GET_PRIVATE (status_icon, GTK_TYPE_STATUS_ICON, GtkStatusIconPrivate); status_icon->priv = priv; - - priv->storage_type = GTK_IMAGE_EMPTY; + + priv->icon_helper = _gtk_icon_helper_new (); + _gtk_icon_helper_set_force_scale_pixbuf (priv->icon_helper, TRUE); 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), - GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK); - - g_signal_connect_swapped (priv->tray_icon, "key-press-event", - G_CALLBACK (gtk_status_icon_key_press), status_icon); - g_signal_connect_swapped (priv->tray_icon, "popup-menu", - G_CALLBACK (gtk_status_icon_popup_menu), status_icon); - g_signal_connect_swapped (priv->tray_icon, "notify::embedded", - G_CALLBACK (gtk_status_icon_embedded_changed), status_icon); - g_signal_connect_swapped (priv->tray_icon, "notify::orientation", - G_CALLBACK (gtk_status_icon_orientation_changed), status_icon); - g_signal_connect_swapped (priv->tray_icon, "button-press-event", - G_CALLBACK (gtk_status_icon_button_press), status_icon); - g_signal_connect_swapped (priv->tray_icon, "screen-changed", - G_CALLBACK (gtk_status_icon_screen_changed), status_icon); - priv->image = gtk_image_new (); - GTK_WIDGET_SET_FLAGS (priv->image, GTK_CAN_FOCUS); - gtk_container_add (GTK_CONTAINER (priv->tray_icon), priv->image); - gtk_widget_show (priv->image); - - g_signal_connect_swapped (priv->image, "size-allocate", - G_CALLBACK (gtk_status_icon_size_allocate), status_icon); - + if (GDK_IS_X11_DISPLAY (gdk_display_get_default ())) + { + priv->size = 0; + priv->tray_icon = GTK_WIDGET (_gtk_tray_icon_new (NULL)); + + gtk_widget_add_events (GTK_WIDGET (priv->tray_icon), + GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | + GDK_SCROLL_MASK); + + g_signal_connect_swapped (priv->tray_icon, "key-press-event", + G_CALLBACK (gtk_status_icon_key_press), status_icon); + g_signal_connect_swapped (priv->tray_icon, "popup-menu", + G_CALLBACK (gtk_status_icon_popup_menu), status_icon); + g_signal_connect_swapped (priv->tray_icon, "notify::embedded", + G_CALLBACK (gtk_status_icon_embedded_changed), status_icon); + g_signal_connect_swapped (priv->tray_icon, "notify::orientation", + 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", + G_CALLBACK (gtk_status_icon_color_changed), status_icon); + g_signal_connect (priv->tray_icon, "notify::warning-color", + G_CALLBACK (gtk_status_icon_color_changed), status_icon); + g_signal_connect (priv->tray_icon, "notify::success-color", + G_CALLBACK (gtk_status_icon_color_changed), status_icon); + g_signal_connect_swapped (priv->tray_icon, "button-press-event", + G_CALLBACK (gtk_status_icon_button_press), status_icon); + g_signal_connect_swapped (priv->tray_icon, "button-release-event", + G_CALLBACK (gtk_status_icon_button_release), status_icon); + g_signal_connect_swapped (priv->tray_icon, "scroll-event", + G_CALLBACK (gtk_status_icon_scroll), status_icon); + g_signal_connect_swapped (priv->tray_icon, "query-tooltip", + G_CALLBACK (gtk_status_icon_query_tooltip), status_icon); + g_signal_connect_swapped (priv->tray_icon, "screen-changed", + G_CALLBACK (gtk_status_icon_screen_changed), status_icon); + priv->image = gtk_image_new (); + gtk_widget_set_can_focus (priv->image, TRUE); + 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 @@ -580,23 +902,21 @@ gtk_status_icon_init (GtkStatusIcon *status_icon) /* Get position and orientation of Windows taskbar. */ { APPBARDATA abd; - + abd.cbSize = sizeof (abd); SHAppBarMessage (ABM_GETTASKBARPOS, &abd); if (abd.rc.bottom - abd.rc.top > abd.rc.right - abd.rc.left) 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)); @@ -605,9 +925,20 @@ 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 ("%s:%d:Shell_NotifyIcon(NIM_ADD) failed", __FILE__, __LINE__-2); + g_warning (G_STRLOC ": Shell_NotifyIcon(NIM_ADD) failed"); priv->nid.hWnd = NULL; } @@ -616,14 +947,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; @@ -648,8 +975,8 @@ gtk_status_icon_constructor (GType type, #ifdef GDK_WINDOWING_X11 status_icon = GTK_STATUS_ICON (object); priv = status_icon->priv; - - if (priv->visible) + + if (priv->visible && priv->tray_icon) gtk_widget_show (priv->tray_icon); #endif @@ -662,16 +989,43 @@ gtk_status_icon_finalize (GObject *object) GtkStatusIcon *status_icon = GTK_STATUS_ICON (object); GtkStatusIconPrivate *priv = status_icon->priv; - gtk_status_icon_disable_blinking (status_icon); - gtk_status_icon_reset_image_data (status_icon); - - if (priv->blank_icon) - g_object_unref (priv->blank_icon); - priv->blank_icon = NULL; + g_clear_object (&priv->icon_helper); #ifdef GDK_WINDOWING_X11 - gtk_widget_destroy (priv->tray_icon); + if (priv->tray_icon) + { + g_signal_handlers_disconnect_by_func (priv->tray_icon, + gtk_status_icon_key_press, status_icon); + g_signal_handlers_disconnect_by_func (priv->tray_icon, + gtk_status_icon_popup_menu, status_icon); + g_signal_handlers_disconnect_by_func (priv->tray_icon, + gtk_status_icon_embedded_changed, status_icon); + g_signal_handlers_disconnect_by_func (priv->tray_icon, + 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, + gtk_status_icon_color_changed, status_icon); + g_signal_handlers_disconnect_by_func (priv->tray_icon, + gtk_status_icon_button_press, status_icon); + g_signal_handlers_disconnect_by_func (priv->tray_icon, + gtk_status_icon_button_release, status_icon); + g_signal_handlers_disconnect_by_func (priv->tray_icon, + gtk_status_icon_scroll, status_icon); + g_signal_handlers_disconnect_by_func (priv->tray_icon, + gtk_status_icon_query_tooltip, status_icon); + g_signal_handlers_disconnect_by_func (priv->tray_icon, + 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 @@ -679,16 +1033,16 @@ gtk_status_icon_finalize (GObject *object) Shell_NotifyIconW (NIM_DELETE, &priv->nid); if (priv->nid.hIcon) DestroyIcon (priv->nid.hIcon); - - gtk_widget_destroy (priv->dummy_widget); + g_free (priv->tooltip_text); status_icons = g_slist_remove (status_icons, status_icon); #endif - + #ifdef GDK_WINDOWING_QUARTZ QUARTZ_POOL_ALLOC; [priv->status_item release]; QUARTZ_POOL_RELEASE; + g_free (priv->tooltip_text); #endif G_OBJECT_CLASS (gtk_status_icon_parent_class)->finalize (object); @@ -722,12 +1076,21 @@ gtk_status_icon_set_property (GObject *object, case PROP_SCREEN: gtk_status_icon_set_screen (status_icon, g_value_get_object (value)); break; - case PROP_BLINKING: - gtk_status_icon_set_blinking (status_icon, g_value_get_boolean (value)); - break; case PROP_VISIBLE: gtk_status_icon_set_visible (status_icon, g_value_get_boolean (value)); break; + case PROP_HAS_TOOLTIP: + gtk_status_icon_set_has_tooltip (status_icon, g_value_get_boolean (value)); + break; + case PROP_TOOLTIP_TEXT: + gtk_status_icon_set_tooltip_text (status_icon, g_value_get_string (value)); + break; + case PROP_TOOLTIP_MARKUP: + gtk_status_icon_set_tooltip_markup (status_icon, g_value_get_string (value)); + break; + case PROP_TITLE: + gtk_status_icon_set_title (status_icon, g_value_get_string (value)); + break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; @@ -741,44 +1104,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 - { - GIcon *icon; - - gtk_status_icon_get_gicon (status_icon, &icon); - g_value_set_object (value, 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)); @@ -789,9 +1128,6 @@ gtk_status_icon_get_property (GObject *object, case PROP_SCREEN: g_value_set_object (value, gtk_status_icon_get_screen (status_icon)); break; - case PROP_BLINKING: - g_value_set_boolean (value, gtk_status_icon_get_blinking (status_icon)); - break; case PROP_VISIBLE: g_value_set_boolean (value, gtk_status_icon_get_visible (status_icon)); break; @@ -800,12 +1136,27 @@ gtk_status_icon_get_property (GObject *object, break; case PROP_ORIENTATION: #ifdef GDK_WINDOWING_X11 - g_value_set_enum (value, _gtk_tray_icon_get_orientation (GTK_TRAY_ICON (status_icon->priv->tray_icon))); + if (status_icon->priv->tray_icon) + g_value_set_enum (value, _gtk_tray_icon_get_orientation (GTK_TRAY_ICON (status_icon->priv->tray_icon))); + else + g_value_set_enum (value, GTK_ORIENTATION_HORIZONTAL); #endif #ifdef GDK_WINDOWING_WIN32 g_value_set_enum (value, status_icon->priv->orientation); #endif break; + case PROP_HAS_TOOLTIP: + g_value_set_boolean (value, gtk_status_icon_get_has_tooltip (status_icon)); + break; + case PROP_TOOLTIP_TEXT: + g_value_set_string (value, gtk_status_icon_get_tooltip_text (status_icon)); + break; + case PROP_TOOLTIP_MARKUP: + g_value_set_string (value, gtk_status_icon_get_tooltip_markup (status_icon)); + break; + case PROP_TITLE: + g_value_set_string (value, gtk_status_icon_get_title (status_icon)); + break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; @@ -850,7 +1201,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. * @@ -965,47 +1316,15 @@ emit_size_changed_signal (GtkStatusIcon *status_icon, #endif -static GdkPixbuf * -gtk_status_icon_blank_icon (GtkStatusIcon *status_icon) -{ - GtkStatusIconPrivate *priv = status_icon->priv; - - if (priv->blank_icon) - { - gint width, height; - - width = gdk_pixbuf_get_width (priv->blank_icon); - height = gdk_pixbuf_get_height (priv->blank_icon); - - - if (width == priv->image_width && height == priv->image_height) - return priv->blank_icon; - else - { - g_object_unref (priv->blank_icon); - priv->blank_icon = NULL; - } - } - - priv->blank_icon = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8, - priv->image_width, - priv->image_height); - if (priv->blank_icon) - gdk_pixbuf_fill (priv->blank_icon, 0); - - return priv->blank_icon; -} - -#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); @@ -1013,20 +1332,19 @@ 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++) + for (s = GTK_ICON_SIZE_MENU; s <= GTK_ICON_SIZE_DIALOG; s++) { - if (gtk_icon_size_lookup_for_settings (settings, s, &w, &h) && - w <= pixel_size && h <= pixel_size) + if (gtk_icon_size_lookup_for_settings (settings, s, &w, &h)) { - d = MAX (pixel_size - w, pixel_size - h); + d = MAX (abs (pixel_size - w), abs (pixel_size - h)); if (d < dist) { dist = d; - size = s; + size = MAX (w, h); } } } @@ -1034,8 +1352,6 @@ find_icon_size (GtkWidget *widget, return size; } -#endif - static void gtk_status_icon_update_image (GtkStatusIcon *status_icon) { @@ -1043,260 +1359,67 @@ gtk_status_icon_update_image (GtkStatusIcon *status_icon) #ifdef GDK_WINDOWING_WIN32 HICON prev_hicon; #endif + GtkStyleContext *context; + GtkWidget *widget; + GdkPixbuf *pixbuf; + gint round_size; + +#ifdef GDK_WINDOWING_X11 + widget = priv->image; +#else + widget = priv->dummy_widget; +#endif - if (priv->blink_off) + if (widget == NULL) + return; + + context = gtk_widget_get_style_context (widget); + round_size = round_pixel_size (widget, priv->size); + + _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), - gtk_status_icon_blank_icon (status_icon)); + 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 (gtk_status_icon_blank_icon (status_icon)); + 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 ("%s:%d:Shell_NotifyIcon(NIM_MODIFY) failed", __FILE__, __LINE__-1); + if (!Shell_NotifyIconW (NIM_MODIFY, &priv->nid)) + g_warning (G_STRLOC ": Shell_NotifyIcon(NIM_MODIFY) failed"); if (prev_hicon) - DestroyIcon (prev_hicon); + DestroyIcon (prev_hicon); #endif #ifdef GDK_WINDOWING_QUARTZ QUARTZ_POOL_ALLOC; - [priv->status_item setImage:gtk_status_icon_blank_icon (status_icon)]; + [priv->status_item setImage:pixbuf]; QUARTZ_POOL_RELEASE; #endif - return; } - - switch (priv->storage_type) + else { - case GTK_IMAGE_PIXBUF: - { - GdkPixbuf *pixbuf; - - pixbuf = priv->image_data.pixbuf; - - if (pixbuf) - { - GdkPixbuf *scaled; - gint size; - gint width; - gint height; - - size = priv->size; - - 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); - -#ifdef GDK_WINDOWING_X11 - gtk_image_set_from_pixbuf (GTK_IMAGE (priv->image), scaled); -#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 ("%s:%d:Shell_NotifyIcon(NIM_MODIFY) failed", __FILE__, __LINE__-1); - if (prev_hicon) - DestroyIcon (prev_hicon); -#endif -#ifdef GDK_WINDOWING_QUARTZ - QUARTZ_POOL_ALLOC; - [priv->status_item setImage:scaled]; - QUARTZ_POOL_RELEASE; -#endif - - g_object_unref (scaled); - } - else - { #ifdef GDK_WINDOWING_X11 - gtk_image_set_from_pixbuf (GTK_IMAGE (priv->image), NULL); + 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 ("%s:%d:Shell_NotifyIcon(NIM_MODIFY) failed", __FILE__, __LINE__-1); + 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 ("%s:%d:Shell_NotifyIcon(NIM_MODIFY) failed", __FILE__, __LINE__-1); - 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 ("%s:%d:Shell_NotifyIcon(NIM_MODIFY) failed", __FILE__, __LINE__-1); - if (prev_hicon) - DestroyIcon (prev_hicon); - g_object_unref (pixbuf); - } -#endif -#ifdef GDK_WINDOWING_QUARTZ - { - GdkPixbuf *pixbuf; + g_clear_object (&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 ("%s:%d:Shell_NotifyIcon(NIM_MODIFY) failed", __FILE__, __LINE__-1); - 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: -#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 ("%s:%d:Shell_NotifyIcon(NIM_MODIFY) failed", __FILE__, __LINE__-1); -#endif -#ifdef GDK_WINDOWING_QUARTZ - { - QUARTZ_POOL_ALLOC; - [priv->status_item setImage:NULL]; - QUARTZ_POOL_RELEASE; - } -#endif - break; - default: - g_assert_not_reached (); - break; - } -} - -#ifdef GDK_WINDOWING_X11 +#ifdef GDK_WINDOWING_X11 static void gtk_status_icon_size_allocate (GtkStatusIcon *status_icon, @@ -1313,9 +1436,6 @@ gtk_status_icon_size_allocate (GtkStatusIcon *status_icon, else size = allocation->width; - priv->image_width = allocation->width - GTK_MISC (priv->image)->xpad * 2; - priv->image_height = allocation->height - GTK_MISC (priv->image)->ypad * 2; - if (priv->size != size) { priv->size = size; @@ -1339,22 +1459,106 @@ gtk_status_icon_screen_changed (GtkStatusIcon *status_icon, } } -#endif +static void +gtk_status_icon_padding_changed (GtkStatusIcon *status_icon) +{ + GtkStatusIconPrivate *priv = status_icon->priv; + GtkOrientation orientation; + gint padding; -#ifdef GDK_WINDOWING_X11 + orientation = _gtk_tray_icon_get_orientation (GTK_TRAY_ICON (priv->tray_icon)); + padding = _gtk_tray_icon_get_padding (GTK_TRAY_ICON (priv->tray_icon)); + + if (orientation == GTK_ORIENTATION_HORIZONTAL) + { + 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_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"); } static void gtk_status_icon_orientation_changed (GtkStatusIcon *status_icon) { + gtk_status_icon_padding_changed (status_icon); g_object_notify (G_OBJECT (status_icon), "orientation"); } +static void +gtk_status_icon_fg_changed (GtkStatusIcon *status_icon) +{ + GtkStatusIconPrivate *priv = status_icon->priv; + GdkRGBA *rgba; + + g_object_get (priv->tray_icon, "fg-color", &rgba, NULL); + + gtk_widget_override_color (priv->image, GTK_STATE_FLAG_NORMAL, rgba); + + gdk_rgba_free (rgba); +} + +static void +gtk_status_icon_color_changed (GtkTrayIcon *tray, + GParamSpec *pspec, + GtkStatusIcon *status_icon) +{ + GtkStatusIconPrivate *priv = status_icon->priv; + const gchar *name; + + switch (pspec->name[0]) + { + case 'e': + name = "error"; + break; + case 'w': + name = "warning"; + break; + case 's': + name = "success"; + break; + default: + name = NULL; + break; + } + + if (name) + { + GdkRGBA rgba; + + g_object_get (priv->tray_icon, pspec->name, &rgba, NULL); + + rgba.alpha = 1; + + gtk_widget_override_symbolic_color (priv->image, name, &rgba); + } +} + static gboolean gtk_status_icon_key_press (GtkStatusIcon *status_icon, GdkEventKey *event) @@ -1364,11 +1568,11 @@ gtk_status_icon_key_press (GtkStatusIcon *status_icon, state = event->state & gtk_accelerator_get_default_mod_mask (); keyval = event->keyval; if (state == 0 && - (keyval == GDK_Return || - keyval == GDK_KP_Enter || - keyval == GDK_ISO_Enter || - keyval == GDK_space || - keyval == GDK_KP_Space)) + (keyval == GDK_KEY_Return || + keyval == GDK_KEY_KP_Enter || + keyval == GDK_KEY_ISO_Enter || + keyval == GDK_KEY_space || + keyval == GDK_KEY_KP_Space)) { emit_activate_signal (status_icon); return TRUE; @@ -1383,61 +1587,94 @@ gtk_status_icon_popup_menu (GtkStatusIcon *status_icon) emit_popup_menu_signal (status_icon, 0, gtk_get_current_event_time ()); } -#endif +#endif /* GDK_WINDOWING_X11 */ static gboolean gtk_status_icon_button_press (GtkStatusIcon *status_icon, GdkEventButton *event) { - if (event->button == 1 && event->type == GDK_BUTTON_PRESS) + gboolean handled = FALSE; + + g_signal_emit (status_icon, + status_icon_signals [BUTTON_PRESS_EVENT_SIGNAL], 0, + event, &handled); + if (handled) + return TRUE; + + 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; } return FALSE; } +static gboolean +gtk_status_icon_button_release (GtkStatusIcon *status_icon, + GdkEventButton *event) +{ + gboolean handled = FALSE; + g_signal_emit (status_icon, + status_icon_signals [BUTTON_RELEASE_EVENT_SIGNAL], 0, + event, &handled); + return handled; +} + +#ifdef GDK_WINDOWING_X11 + +static gboolean +gtk_status_icon_scroll (GtkStatusIcon *status_icon, + GdkEventScroll *event) +{ + gboolean handled = FALSE; + g_signal_emit (status_icon, + status_icon_signals [SCROLL_EVENT_SIGNAL], 0, + event, &handled); + return handled; +} + +static gboolean +gtk_status_icon_query_tooltip (GtkStatusIcon *status_icon, + gint x, + gint y, + gboolean keyboard_tip, + GtkTooltip *tooltip) +{ + gboolean handled = FALSE; + g_signal_emit (status_icon, + status_icon_signals [QUERY_TOOLTIP_SIGNAL], 0, + x, y, keyboard_tip, tooltip, &handled); + return handled; +} + +#endif /* GDK_WINDOWING_X11 */ + 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: - g_free (priv->image_data.gicon); - priv->image_data.gicon = NULL; - g_object_notify (G_OBJECT (status_icon), "gicon"); break; - case GTK_IMAGE_EMPTY: break; default: @@ -1445,7 +1682,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"); } @@ -1460,25 +1697,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: @@ -1493,9 +1732,9 @@ gtk_status_icon_set_image (GtkStatusIcon *status_icon, /** * gtk_status_icon_set_from_pixbuf: * @status_icon: a #GtkStatusIcon - * @pixbuf: a #GdkPixbuf or %NULL - * - * Makes @status_icon display @pixbuf. + * @pixbuf: (allow-none): a #GdkPixbuf or %NULL + * + * Makes @status_icon display @pixbuf. * See gtk_status_icon_new_from_pixbuf() for details. * * Since: 2.10 @@ -1507,9 +1746,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); } @@ -1517,7 +1753,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. @@ -1622,7 +1858,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: @@ -1634,7 +1870,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 **/ @@ -1647,13 +1884,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); } /** @@ -1671,7 +1902,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; @@ -1680,13 +1911,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); } /** @@ -1703,7 +1928,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; @@ -1712,19 +1937,12 @@ 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); } /** * gtk_status_icon_get_gicon: * @status_icon: a #GtkStatusIcon - * @icon: a place to store a #GIcon * * Retrieves the #GIcon being displayed by the #GtkStatusIcon. * The storage type of the status icon must be %GTK_IMAGE_EMPTY or @@ -1734,25 +1952,20 @@ gtk_status_icon_get_icon_name (GtkStatusIcon *status_icon) * * If this function fails, @icon is left unchanged; * + * Returns: (transfer none): the displayed icon, or %NULL if the image is empty + * * Since: 2.14 **/ -void -gtk_status_icon_get_gicon (GtkStatusIcon *status_icon, - GIcon **icon) +GIcon * +gtk_status_icon_get_gicon (GtkStatusIcon *status_icon) { GtkStatusIconPrivate *priv; - g_return_if_fail (GTK_IS_STATUS_ICON (status_icon)); + g_return_val_if_fail (GTK_IS_STATUS_ICON (status_icon), NULL); priv = status_icon->priv; - g_return_if_fail (priv->storage_type == GTK_IMAGE_GICON || - priv->storage_type == GTK_IMAGE_EMPTY); - - if (priv->storage_type == GTK_IMAGE_EMPTY) - priv->image_data.gicon = NULL; - - *icon = priv->image_data.gicon; + return _gtk_icon_helper_peek_gicon (priv->icon_helper); } /** @@ -1798,17 +2011,18 @@ gtk_status_icon_set_screen (GtkStatusIcon *status_icon, g_return_if_fail (GDK_IS_SCREEN (screen)); #ifdef GDK_WINDOWING_X11 - gtk_window_set_screen (GTK_WINDOW (status_icon->priv->tray_icon), screen); + if (status_icon->priv->tray_icon) + gtk_window_set_screen (GTK_WINDOW (status_icon->priv->tray_icon), screen); #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 */ @@ -1817,101 +2031,12 @@ gtk_status_icon_get_screen (GtkStatusIcon *status_icon) { g_return_val_if_fail (GTK_IS_STATUS_ICON (status_icon), NULL); -#ifdef GDK_WINDOWING_X11 - return gtk_window_get_screen (GTK_WINDOW (status_icon->priv->tray_icon)); -#else - return gdk_screen_get_default (); -#endif -} - -/** - * gtk_status_icon_set_tooltip: - * @status_icon: a #GtkStatusIcon - * @tooltip_text: the tooltip text, or %NULL - * - * Sets the tooltip of the status icon. - * - * Since: 2.10 - **/ -void -gtk_status_icon_set_tooltip (GtkStatusIcon *status_icon, - const gchar *tooltip_text) -{ - GtkStatusIconPrivate *priv; - - g_return_if_fail (GTK_IS_STATUS_ICON (status_icon)); - - priv = status_icon->priv; - #ifdef GDK_WINDOWING_X11 - - gtk_widget_set_tooltip_text (priv->tray_icon, tooltip_text); - -#endif -#ifdef GDK_WINDOWING_WIN32 - if (tooltip_text == NULL) - priv->nid.uFlags &= ~NIF_TIP; + if (status_icon->priv->tray_icon) + return gtk_window_get_screen (GTK_WINDOW (status_icon->priv->tray_icon)); else - { - WCHAR *wcs = g_utf8_to_utf16 (tooltip_text, -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 (priv->nid.hWnd != NULL && priv->visible) - if (!Shell_NotifyIconW (NIM_MODIFY, &priv->nid)) - g_warning ("%s:%d:Shell_NotifyIconW(NIM_MODIFY) failed", __FILE__, __LINE__-1); #endif -#ifdef GDK_WINDOWING_QUARTZ - QUARTZ_POOL_ALLOC; - [priv->status_item setToolTip:tooltip_text]; - QUARTZ_POOL_RELEASE; -#endif -} - -static gboolean -gtk_status_icon_blinker (GtkStatusIcon *status_icon) -{ - GtkStatusIconPrivate *priv = status_icon->priv; - - priv->blink_off = !priv->blink_off; - - gtk_status_icon_update_image (status_icon); - - return TRUE; -} - -static void -gtk_status_icon_enable_blinking (GtkStatusIcon *status_icon) -{ - GtkStatusIconPrivate *priv = status_icon->priv; - - if (!priv->blinking_timeout) - { - gtk_status_icon_blinker (status_icon); - - priv->blinking_timeout = - gdk_threads_add_timeout (BLINK_TIMEOUT, - (GSourceFunc) gtk_status_icon_blinker, - status_icon); - } -} - -static void -gtk_status_icon_disable_blinking (GtkStatusIcon *status_icon) -{ - GtkStatusIconPrivate *priv = status_icon->priv; - - if (priv->blinking_timeout) - { - g_source_remove (priv->blinking_timeout); - priv->blinking_timeout = 0; - priv->blink_off = FALSE; - - gtk_status_icon_update_image (status_icon); - } + return gdk_screen_get_default (); } /** @@ -1940,12 +2065,15 @@ gtk_status_icon_set_visible (GtkStatusIcon *status_icon, priv->visible = visible; #ifdef GDK_WINDOWING_X11 - if (visible) - gtk_widget_show (priv->tray_icon); - else if (GTK_WIDGET_REALIZED (priv->tray_icon)) + if (priv->tray_icon) { - gtk_widget_hide (priv->tray_icon); - gtk_widget_unrealize (priv->tray_icon); + if (visible) + gtk_widget_show (priv->tray_icon); + else if (gtk_widget_get_realized (priv->tray_icon)) + { + gtk_widget_hide (priv->tray_icon); + gtk_widget_unrealize (priv->tray_icon); + } } #endif #ifdef GDK_WINDOWING_WIN32 @@ -1987,62 +2115,6 @@ gtk_status_icon_get_visible (GtkStatusIcon *status_icon) return status_icon->priv->visible; } -/** - * gtk_status_icon_set_blinking: - * @status_icon: a #GtkStatusIcon - * @blinking: %TRUE to turn blinking on, %FALSE to turn it off - * - * Makes the status icon start or stop blinking. - * Note that blinking user interface elements may be problematic - * for some users, and thus may be turned off, in which case - * this setting has no effect. - * - * Since: 2.10 - **/ -void -gtk_status_icon_set_blinking (GtkStatusIcon *status_icon, - gboolean blinking) -{ - GtkStatusIconPrivate *priv; - - g_return_if_fail (GTK_IS_STATUS_ICON (status_icon)); - - priv = status_icon->priv; - - blinking = blinking != FALSE; - - if (priv->blinking != blinking) - { - priv->blinking = blinking; - - if (blinking) - gtk_status_icon_enable_blinking (status_icon); - else - gtk_status_icon_disable_blinking (status_icon); - - g_object_notify (G_OBJECT (status_icon), "blinking"); - } -} - -/** - * gtk_status_icon_get_blinking: - * @status_icon: a #GtkStatusIcon - * - * Returns whether the icon is blinking, see - * gtk_status_icon_set_blinking(). - * - * Return value: %TRUE if the icon is blinking - * - * Since: 2.10 - **/ -gboolean -gtk_status_icon_get_blinking (GtkStatusIcon *status_icon) -{ - g_return_val_if_fail (GTK_IS_STATUS_ICON (status_icon), FALSE); - - return status_icon->priv->blinking; -} - /** * gtk_status_icon_is_embedded: * @status_icon: a #GtkStatusIcon @@ -2058,16 +2130,11 @@ gtk_status_icon_get_blinking (GtkStatusIcon *status_icon) gboolean gtk_status_icon_is_embedded (GtkStatusIcon *status_icon) { -#ifdef GDK_WINDOWING_X11 - GtkPlug *plug; -#endif - g_return_val_if_fail (GTK_IS_STATUS_ICON (status_icon), FALSE); #ifdef GDK_WINDOWING_X11 - plug = GTK_PLUG (status_icon->priv->tray_icon); - - if (plug->socket_window) + if (status_icon->priv->tray_icon && + gtk_plug_get_embedded (GTK_PLUG (status_icon->priv->tray_icon))) return TRUE; else return FALSE; @@ -2083,11 +2150,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. @@ -2102,21 +2170,28 @@ gtk_status_icon_position_menu (GtkMenu *menu, gpointer user_data) { #ifdef GDK_WINDOWING_X11 - GtkStatusIcon *status_icon; - GtkStatusIconPrivate *priv; + GtkStatusIcon *status_icon = GTK_STATUS_ICON (user_data); + GtkStatusIconPrivate *priv = status_icon->priv; + GtkAllocation allocation; GtkTrayIcon *tray_icon; GtkWidget *widget; GdkScreen *screen; GtkTextDirection direction; GtkRequisition menu_req; GdkRectangle monitor; + GdkWindow *window; gint monitor_num, height, width, xoffset, yoffset; - + g_return_if_fail (GTK_IS_MENU (menu)); g_return_if_fail (GTK_IS_STATUS_ICON (user_data)); - status_icon = GTK_STATUS_ICON (user_data); - priv = status_icon->priv; + if (priv->tray_icon == NULL) + { + *x = 0; + *y = 0; + return; + } + tray_icon = GTK_TRAY_ICON (priv->tray_icon); widget = priv->tray_icon; @@ -2125,30 +2200,33 @@ gtk_status_icon_position_menu (GtkMenu *menu, screen = gtk_widget_get_screen (widget); gtk_menu_set_screen (menu, screen); - monitor_num = gdk_screen_get_monitor_at_window (screen, widget->window); + window = gtk_widget_get_window (widget); + monitor_num = gdk_screen_get_monitor_at_window (screen, window); if (monitor_num < 0) 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 (widget->window, x, y); - - gtk_widget_size_request (GTK_WIDGET (menu), &menu_req); + gdk_window_get_origin (window, x, y); + + 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) { width = 0; - height = widget->allocation.height; - xoffset = widget->allocation.width; + height = allocation.height; + xoffset = allocation.width; yoffset = 0; } else { - width = widget->allocation.width; + width = allocation.width; height = 0; xoffset = 0; - yoffset = widget->allocation.height; + yoffset = allocation.height; } if (direction == GTK_TEXT_DIR_RTL) @@ -2189,6 +2267,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)); @@ -2196,8 +2275,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 } @@ -2205,14 +2287,14 @@ gtk_status_icon_position_menu (GtkMenu *menu, /** * gtk_status_icon_get_geometry: * @status_icon: a #GtkStatusIcon - * @screen: return location for the screen, or %NULL if the - * information is not needed - * @area: return location for the area occupied by the status - * icon, or %NULL - * @orientation: 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 @@ -2232,20 +2314,23 @@ gtk_status_icon_position_menu (GtkMenu *menu, * * Since: 2.10 */ -gboolean +gboolean gtk_status_icon_get_geometry (GtkStatusIcon *status_icon, GdkScreen **screen, GdkRectangle *area, GtkOrientation *orientation) { #ifdef GDK_WINDOWING_X11 + GtkStatusIconPrivate *priv = status_icon->priv; + GtkAllocation allocation; GtkWidget *widget; - GtkStatusIconPrivate *priv; gint x, y; g_return_val_if_fail (GTK_IS_STATUS_ICON (status_icon), FALSE); - priv = status_icon->priv; + if (priv->tray_icon == NULL) + return FALSE; + widget = priv->tray_icon; if (screen) @@ -2253,11 +2338,14 @@ gtk_status_icon_get_geometry (GtkStatusIcon *status_icon, if (area) { - gdk_window_get_origin (widget->window, &x, &y); + gdk_window_get_origin (gtk_widget_get_window (widget), + &x, &y); + + gtk_widget_get_allocation (widget, &allocation); area->x = x; area->y = y; - area->width = widget->allocation.width; - area->height = widget->allocation.height; + area->width = allocation.width; + area->height = allocation.height; } if (orientation) @@ -2269,6 +2357,255 @@ gtk_status_icon_get_geometry (GtkStatusIcon *status_icon, #endif /* GDK_WINDOWING_X11 */ } +/** + * gtk_status_icon_set_has_tooltip: + * @status_icon: a #GtkStatusIcon + * @has_tooltip: whether or not @status_icon has a tooltip + * + * Sets the has-tooltip property on @status_icon to @has_tooltip. + * See #GtkStatusIcon:has-tooltip for more information. + * + * Since: 2.16 + */ +void +gtk_status_icon_set_has_tooltip (GtkStatusIcon *status_icon, + gboolean has_tooltip) +{ + GtkStatusIconPrivate *priv; + + g_return_if_fail (GTK_IS_STATUS_ICON (status_icon)); + + priv = status_icon->priv; + +#ifdef GDK_WINDOWING_X11 + if (priv->tray_icon) + gtk_widget_set_has_tooltip (priv->tray_icon, has_tooltip); +#endif +#ifdef GDK_WINDOWING_WIN32 + if (!has_tooltip && priv->tooltip_text) + gtk_status_icon_set_tooltip_text (status_icon, NULL); +#endif +#ifdef GDK_WINDOWING_QUARTZ + if (!has_tooltip && priv->tooltip_text) + gtk_status_icon_set_tooltip_text (status_icon, NULL); +#endif +} + +/** + * gtk_status_icon_get_has_tooltip: + * @status_icon: a #GtkStatusIcon + * + * Returns the current value of the has-tooltip property. + * See #GtkStatusIcon:has-tooltip for more information. + * + * Return value: current value of has-tooltip on @status_icon. + * + * Since: 2.16 + */ +gboolean +gtk_status_icon_get_has_tooltip (GtkStatusIcon *status_icon) +{ + GtkStatusIconPrivate *priv; + gboolean has_tooltip = FALSE; + + g_return_val_if_fail (GTK_IS_STATUS_ICON (status_icon), FALSE); + + priv = status_icon->priv; + +#ifdef GDK_WINDOWING_X11 + if (priv->tray_icon) + has_tooltip = gtk_widget_get_has_tooltip (priv->tray_icon); +#endif +#ifdef GDK_WINDOWING_WIN32 + has_tooltip = (priv->tooltip_text != NULL); +#endif +#ifdef GDK_WINDOWING_QUARTZ + has_tooltip = (priv->tooltip_text != NULL); +#endif + + return has_tooltip; +} + +/** + * gtk_status_icon_set_tooltip_text: + * @status_icon: a #GtkStatusIcon + * @text: the contents of the tooltip for @status_icon + * + * Sets @text as the contents of the tooltip. + * + * This function will take care of setting #GtkStatusIcon:has-tooltip to + * %TRUE and of the default handler for the #GtkStatusIcon::query-tooltip + * signal. + * + * See also the #GtkStatusIcon:tooltip-text property and + * gtk_tooltip_set_text(). + * + * Since: 2.16 + */ +void +gtk_status_icon_set_tooltip_text (GtkStatusIcon *status_icon, + const gchar *text) +{ + GtkStatusIconPrivate *priv; + + g_return_if_fail (GTK_IS_STATUS_ICON (status_icon)); + + priv = status_icon->priv; + +#ifdef GDK_WINDOWING_X11 + if (priv->tray_icon) + gtk_widget_set_tooltip_text (priv->tray_icon, text); +#endif +#ifdef GDK_WINDOWING_WIN32 + if (text == NULL) + priv->nid.uFlags &= ~NIF_TIP; + else + { + WCHAR *wcs = g_utf8_to_utf16 (text, -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 (priv->nid.hWnd != NULL && priv->visible) + if (!Shell_NotifyIconW (NIM_MODIFY, &priv->nid)) + g_warning (G_STRLOC ": Shell_NotifyIconW(NIM_MODIFY) failed"); + + g_free (priv->tooltip_text); + priv->tooltip_text = g_strdup (text); +#endif +#ifdef GDK_WINDOWING_QUARTZ + QUARTZ_POOL_ALLOC; + [priv->status_item setToolTip:text]; + QUARTZ_POOL_RELEASE; + + g_free (priv->tooltip_text); + priv->tooltip_text = g_strdup (text); +#endif +} + +/** + * gtk_status_icon_get_tooltip_text: + * @status_icon: a #GtkStatusIcon + * + * Gets the contents of the tooltip for @status_icon. + * + * Return value: the tooltip text, or %NULL. You should free the + * returned string with g_free() when done. + * + * Since: 2.16 + */ +gchar * +gtk_status_icon_get_tooltip_text (GtkStatusIcon *status_icon) +{ + GtkStatusIconPrivate *priv; + gchar *tooltip_text = NULL; + + g_return_val_if_fail (GTK_IS_STATUS_ICON (status_icon), NULL); + + priv = status_icon->priv; + +#ifdef GDK_WINDOWING_X11 + if (priv->tray_icon) + tooltip_text = gtk_widget_get_tooltip_text (priv->tray_icon); +#endif +#ifdef GDK_WINDOWING_WIN32 + if (priv->tooltip_text) + tooltip_text = g_strdup (priv->tooltip_text); +#endif +#ifdef GDK_WINDOWING_QUARTZ + if (priv->tooltip_text) + tooltip_text = g_strdup (priv->tooltip_text); +#endif + + return tooltip_text; +} + +/** + * gtk_status_icon_set_tooltip_markup: + * @status_icon: a #GtkStatusIcon + * @markup: (allow-none): the contents of the tooltip for @status_icon, or %NULL + * + * Sets @markup as the contents of the tooltip, which is marked up with + * the Pango text markup language. + * + * This function will take care of setting #GtkStatusIcon:has-tooltip to %TRUE + * and of the default handler for the #GtkStatusIcon::query-tooltip signal. + * + * See also the #GtkStatusIcon:tooltip-markup property and + * gtk_tooltip_set_markup(). + * + * Since: 2.16 + */ +void +gtk_status_icon_set_tooltip_markup (GtkStatusIcon *status_icon, + const gchar *markup) +{ + GtkStatusIconPrivate *priv; +#ifndef GDK_WINDOWING_X11 + gchar *text = NULL; +#endif + + g_return_if_fail (GTK_IS_STATUS_ICON (status_icon)); + + priv = status_icon->priv; + +#ifdef GDK_WINDOWING_X11 + if (priv->tray_icon) + gtk_widget_set_tooltip_markup (priv->tray_icon, markup); +#endif +#ifdef GDK_WINDOWING_WIN32 + if (markup) + pango_parse_markup (markup, -1, 0, NULL, &text, NULL, NULL); + gtk_status_icon_set_tooltip_text (status_icon, text); + g_free (text); +#endif +#ifdef GDK_WINDOWING_QUARTZ + if (markup) + pango_parse_markup (markup, -1, 0, NULL, &text, NULL, NULL); + gtk_status_icon_set_tooltip_text (status_icon, text); + g_free (text); +#endif +} + +/** + * gtk_status_icon_get_tooltip_markup: + * @status_icon: a #GtkStatusIcon + * + * Gets the contents of the tooltip for @status_icon. + * + * Return value: the tooltip text, or %NULL. You should free the + * returned string with g_free() when done. + * + * Since: 2.16 + */ +gchar * +gtk_status_icon_get_tooltip_markup (GtkStatusIcon *status_icon) +{ + GtkStatusIconPrivate *priv; + gchar *markup = NULL; + + g_return_val_if_fail (GTK_IS_STATUS_ICON (status_icon), NULL); + + priv = status_icon->priv; + +#ifdef GDK_WINDOWING_X11 + if (priv->tray_icon) + markup = gtk_widget_get_tooltip_markup (priv->tray_icon); +#endif +#ifdef GDK_WINDOWING_WIN32 + if (priv->tooltip_text) + markup = g_markup_escape_text (priv->tooltip_text, -1); +#endif +#ifdef GDK_WINDOWING_QUARTZ + if (priv->tooltip_text) + markup = g_markup_escape_text (priv->tooltip_text, -1); +#endif + + return markup; +} + /** * gtk_status_icon_get_x11_window_id: * @status_icon: a #GtkStatusIcon @@ -2293,12 +2630,126 @@ guint32 gtk_status_icon_get_x11_window_id (GtkStatusIcon *status_icon) { #ifdef GDK_WINDOWING_X11 - gtk_widget_realize (GTK_WIDGET (status_icon->priv->tray_icon)); - return GDK_WINDOW_XID (GTK_WIDGET (status_icon->priv->tray_icon)->window); -#else + if (status_icon->priv->tray_icon) + { + gtk_widget_realize (GTK_WIDGET (status_icon->priv->tray_icon)); + return GDK_WINDOW_XID (gtk_widget_get_window (GTK_WIDGET (status_icon->priv->tray_icon))); + } + else +#endif return 0; +} + +/** + * gtk_status_icon_set_title: + * @status_icon: a #GtkStatusIcon + * @title: the title + * + * Sets the title of this tray icon. + * This should be a short, human-readable, localized string + * describing the tray icon. It may be used by tools like screen + * readers to render the tray icon. + * + * Since: 2.18 + */ +void +gtk_status_icon_set_title (GtkStatusIcon *status_icon, + const gchar *title) +{ + GtkStatusIconPrivate *priv; + + g_return_if_fail (GTK_IS_STATUS_ICON (status_icon)); + + priv = status_icon->priv; + +#ifdef GDK_WINDOWING_X11 + if (priv->tray_icon) + gtk_window_set_title (GTK_WINDOW (priv->tray_icon), title); +#endif +#ifdef GDK_WINDOWING_QUARTZ + g_free (priv->title); + priv->title = g_strdup (title); +#endif +#ifdef GDK_WINDOWING_WIN32 + g_free (priv->title); + priv->title = g_strdup (title); #endif + + g_object_notify (G_OBJECT (status_icon), "title"); } -#define __GTK_STATUS_ICON_C__ -#include "gtkaliasdef.c" +/** + * gtk_status_icon_get_title: + * @status_icon: a #GtkStatusIcon + * + * Gets the title of this tray icon. See gtk_status_icon_set_title(). + * + * Returns: the title of the status icon + * + * Since: 2.18 + */ +const gchar * +gtk_status_icon_get_title (GtkStatusIcon *status_icon) +{ + GtkStatusIconPrivate *priv; + const gchar *title = NULL; + + g_return_val_if_fail (GTK_IS_STATUS_ICON (status_icon), NULL); + + priv = status_icon->priv; + +#ifdef GDK_WINDOWING_X11 + if (priv->tray_icon) + title = gtk_window_get_title (GTK_WINDOW (priv->tray_icon)); +#endif +#ifdef GDK_WINDOWING_QUARTZ + title = priv->title; +#endif +#ifdef GDK_WINDOWING_WIN32 + title = priv->title; +#endif + + return title; +} + + +/** + * gtk_status_icon_set_name: + * @status_icon: a #GtkStatusIcon + * @name: the name + * + * Sets the name of this tray icon. + * This should be a string identifying this icon. It is may be + * used for sorting the icons in the tray and will not be shown to + * the user. + * + * Since: 2.20 + */ +void +gtk_status_icon_set_name (GtkStatusIcon *status_icon, + const gchar *name) +{ + GtkStatusIconPrivate *priv; + + g_return_if_fail (GTK_IS_STATUS_ICON (status_icon)); + + priv = status_icon->priv; + +#ifdef GDK_WINDOWING_X11 + if (priv->tray_icon) + { + 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 +}