brl/gnome-shell
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
12b31e6bd0
gnome-shell/src/shell-gtk-embed.c

366 lines
12 KiB
C
Raw Normal View History

Add size negotiation to the tray icons * Rename ShellGtkWindowActor to ShellGtkEmbed, and make it require a ShellEmbeddedWindow rather than a general GtkWindow. * Add ShellEmbeddedWindow subclass of GtkWindow that bypasses most of the GtkWindow complexity for size negotiation, and calls out to a clutter actor instead; also automatically handle reparenting the GtkWindow into the stage window. * Use the reworked ShellGtkEmbed in ShellTrayManager, this simplifies the code a bit, and more importantly results in the tray icons having the correct size negotiation, rather than having a fixed 24x24 size. http://bugzilla.gnome.org/show_bug.cgi?id=580047
2009-05-03 13:05:15 -04:00
/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
include "config.h" in all .c files Also, fix shell-global.c to actually compile with config.h included. Was supposed to fix bug 602802, but doesn't...
2009-11-24 09:07:40 -05:00
#include "config.h"
Add size negotiation to the tray icons * Rename ShellGtkWindowActor to ShellGtkEmbed, and make it require a ShellEmbeddedWindow rather than a general GtkWindow. * Add ShellEmbeddedWindow subclass of GtkWindow that bypasses most of the GtkWindow complexity for size negotiation, and calls out to a clutter actor instead; also automatically handle reparenting the GtkWindow into the stage window. * Use the reworked ShellGtkEmbed in ShellTrayManager, this simplifies the code a bit, and more importantly results in the tray icons having the correct size negotiation, rather than having a fixed 24x24 size. http://bugzilla.gnome.org/show_bug.cgi?id=580047
2009-05-03 13:05:15 -04:00
#include "shell-embedded-window-private.h"
Don't use ClutterX11TexturePixmap directly to embed docked windows Previously when a client requests that a window should be docked the shell would reparent the socket window onto the stage's window and then use ClutterX11TexturePixmap to get a texture to represent the window. This will not work if Clutter is no longer using the X11 winsys for example if it becomes its own display server. Instead this patch leaves the socket window as a child of the root window and lets mutter create a MetaWindow out of it. If Mutter is acting as a display server then this mechanism will still work via the headless x server. The ShellGtkEmbed instance now registers for notification of the ‘window-created’ signal of the display so that it can find the MetaWindow that gets created to represent the socket window. When this window is found it is prevented from being displayed on the screen by setting the actor's opacity to 0. An input shape is then set on the window to prevent it receiving any input. Instead of being a subclass of ClutterX11TexturePixmap, ShellGtkEmbed is now a subclass of ClutterClone. When the MetaWindow is found for the socket window the clone's source is set to the invisible actor for the window so it can be displayed in the panel as before. The ShellEmbeddedWindow no longer needs to know what the stage is because it no longer reparents the socket window. Therefore the ShellTrayManager doesn't need to know the stage either so shell_tray_manager_manage_stage has been replaced with just shell_tray_manager_manage_screen. https://bugzilla.gnome.org/show_bug.cgi?id=693438
2013-02-12 17:31:38 -05:00
#include "shell-global.h"
gtk-embed: Hide window actors from pick Since we started to support tray icons on wayland, the icon we show is not the actual XEmbed window. Instead, we let mutter create a MetaWindow for it, then use its window actor as source for a clone we (or nowadays: extensions) can add, remove and destroy freely. To not let the real icon get in the way, we set an empty input shape and make its window actor fully transparent. This works OK on X11, but on wayland all events still go through Clutter, so any reactive surface actor inside the window actor will block events for any actors underneath (and status icons go into the top-windows group, so almost all actors are affected). Luckily we can pile another hack onto the pile of status icon hacks ... https://gitlab.gnome.org/GNOME/gnome-shell/issues/191
2019-02-15 11:04:10 -05:00
#include "shell-util.h"
Add size negotiation to the tray icons * Rename ShellGtkWindowActor to ShellGtkEmbed, and make it require a ShellEmbeddedWindow rather than a general GtkWindow. * Add ShellEmbeddedWindow subclass of GtkWindow that bypasses most of the GtkWindow complexity for size negotiation, and calls out to a clutter actor instead; also automatically handle reparenting the GtkWindow into the stage window. * Use the reworked ShellGtkEmbed in ShellTrayManager, this simplifies the code a bit, and more importantly results in the tray icons having the correct size negotiation, rather than having a fixed 24x24 size. http://bugzilla.gnome.org/show_bug.cgi?id=580047
2009-05-03 13:05:15 -04:00
#include <gdk/gdkx.h>
Don't use ClutterX11TexturePixmap directly to embed docked windows Previously when a client requests that a window should be docked the shell would reparent the socket window onto the stage's window and then use ClutterX11TexturePixmap to get a texture to represent the window. This will not work if Clutter is no longer using the X11 winsys for example if it becomes its own display server. Instead this patch leaves the socket window as a child of the root window and lets mutter create a MetaWindow out of it. If Mutter is acting as a display server then this mechanism will still work via the headless x server. The ShellGtkEmbed instance now registers for notification of the ‘window-created’ signal of the display so that it can find the MetaWindow that gets created to represent the socket window. When this window is found it is prevented from being displayed on the screen by setting the actor's opacity to 0. An input shape is then set on the window to prevent it receiving any input. Instead of being a subclass of ClutterX11TexturePixmap, ShellGtkEmbed is now a subclass of ClutterClone. When the MetaWindow is found for the socket window the clone's source is set to the invisible actor for the window so it can be displayed in the panel as before. The ShellEmbeddedWindow no longer needs to know what the stage is because it no longer reparents the socket window. Therefore the ShellTrayManager doesn't need to know the stage either so shell_tray_manager_manage_stage has been replaced with just shell_tray_manager_manage_screen. https://bugzilla.gnome.org/show_bug.cgi?id=693438
2013-02-12 17:31:38 -05:00
#include <meta/display.h>
#include <meta/window.h>
Add size negotiation to the tray icons * Rename ShellGtkWindowActor to ShellGtkEmbed, and make it require a ShellEmbeddedWindow rather than a general GtkWindow. * Add ShellEmbeddedWindow subclass of GtkWindow that bypasses most of the GtkWindow complexity for size negotiation, and calls out to a clutter actor instead; also automatically handle reparenting the GtkWindow into the stage window. * Use the reworked ShellGtkEmbed in ShellTrayManager, this simplifies the code a bit, and more importantly results in the tray icons having the correct size negotiation, rather than having a fixed 24x24 size. http://bugzilla.gnome.org/show_bug.cgi?id=580047
2009-05-03 13:05:15 -04:00
enum {
PROP_0,
PROP_WINDOW
};
shell: Use G_DECLARE_*_TYPE macros Cut down on boilerplate by using the (no longer that) new helper macros. We don't care about breaking ABI in private libraries, so use G_DECLARE_FINAL_TYPE even where the class struct used to be exposed in the header, except for types we inherit from ourselves (obviously) or where the class exposes any vfuncs (where changes could affect inheritance in extensions).
2015-09-24 14:07:44 -04:00
typedef struct _ShellGtkEmbedPrivate ShellGtkEmbedPrivate;
Add size negotiation to the tray icons * Rename ShellGtkWindowActor to ShellGtkEmbed, and make it require a ShellEmbeddedWindow rather than a general GtkWindow. * Add ShellEmbeddedWindow subclass of GtkWindow that bypasses most of the GtkWindow complexity for size negotiation, and calls out to a clutter actor instead; also automatically handle reparenting the GtkWindow into the stage window. * Use the reworked ShellGtkEmbed in ShellTrayManager, this simplifies the code a bit, and more importantly results in the tray icons having the correct size negotiation, rather than having a fixed 24x24 size. http://bugzilla.gnome.org/show_bug.cgi?id=580047
2009-05-03 13:05:15 -04:00
struct _ShellGtkEmbedPrivate
{
ShellEmbeddedWindow *window;
Don't use ClutterX11TexturePixmap directly to embed docked windows Previously when a client requests that a window should be docked the shell would reparent the socket window onto the stage's window and then use ClutterX11TexturePixmap to get a texture to represent the window. This will not work if Clutter is no longer using the X11 winsys for example if it becomes its own display server. Instead this patch leaves the socket window as a child of the root window and lets mutter create a MetaWindow out of it. If Mutter is acting as a display server then this mechanism will still work via the headless x server. The ShellGtkEmbed instance now registers for notification of the ‘window-created’ signal of the display so that it can find the MetaWindow that gets created to represent the socket window. When this window is found it is prevented from being displayed on the screen by setting the actor's opacity to 0. An input shape is then set on the window to prevent it receiving any input. Instead of being a subclass of ClutterX11TexturePixmap, ShellGtkEmbed is now a subclass of ClutterClone. When the MetaWindow is found for the socket window the clone's source is set to the invisible actor for the window so it can be displayed in the panel as before. The ShellEmbeddedWindow no longer needs to know what the stage is because it no longer reparents the socket window. Therefore the ShellTrayManager doesn't need to know the stage either so shell_tray_manager_manage_stage has been replaced with just shell_tray_manager_manage_screen. https://bugzilla.gnome.org/show_bug.cgi?id=693438
2013-02-12 17:31:38 -05:00
ClutterActor *window_actor;
cleanup: Use g_clear_signal_handler() where possible `g_clear_signal_handler()` is usually cleaner and saver than `g_signal_handler_disconnect()`. We use it new code, lets also adopt the existing one. See also https://gitlab.gnome.org/GNOME/mutter/merge_requests/868 and https://gitlab.gnome.org/GNOME/mutter/merge_requests/940 https://gitlab.gnome.org/GNOME/gnome-shell/merge_requests/842
2019-11-21 17:00:53 -05:00
gulong window_actor_destroyed_handler;
Don't use ClutterX11TexturePixmap directly to embed docked windows Previously when a client requests that a window should be docked the shell would reparent the socket window onto the stage's window and then use ClutterX11TexturePixmap to get a texture to represent the window. This will not work if Clutter is no longer using the X11 winsys for example if it becomes its own display server. Instead this patch leaves the socket window as a child of the root window and lets mutter create a MetaWindow out of it. If Mutter is acting as a display server then this mechanism will still work via the headless x server. The ShellGtkEmbed instance now registers for notification of the ‘window-created’ signal of the display so that it can find the MetaWindow that gets created to represent the socket window. When this window is found it is prevented from being displayed on the screen by setting the actor's opacity to 0. An input shape is then set on the window to prevent it receiving any input. Instead of being a subclass of ClutterX11TexturePixmap, ShellGtkEmbed is now a subclass of ClutterClone. When the MetaWindow is found for the socket window the clone's source is set to the invisible actor for the window so it can be displayed in the panel as before. The ShellEmbeddedWindow no longer needs to know what the stage is because it no longer reparents the socket window. Therefore the ShellTrayManager doesn't need to know the stage either so shell_tray_manager_manage_stage has been replaced with just shell_tray_manager_manage_screen. https://bugzilla.gnome.org/show_bug.cgi?id=693438
2013-02-12 17:31:38 -05:00
cleanup: Use g_clear_signal_handler() where possible `g_clear_signal_handler()` is usually cleaner and saver than `g_signal_handler_disconnect()`. We use it new code, lets also adopt the existing one. See also https://gitlab.gnome.org/GNOME/mutter/merge_requests/868 and https://gitlab.gnome.org/GNOME/mutter/merge_requests/940 https://gitlab.gnome.org/GNOME/gnome-shell/merge_requests/842
2019-11-21 17:00:53 -05:00
gulong window_created_handler;
Add size negotiation to the tray icons * Rename ShellGtkWindowActor to ShellGtkEmbed, and make it require a ShellEmbeddedWindow rather than a general GtkWindow. * Add ShellEmbeddedWindow subclass of GtkWindow that bypasses most of the GtkWindow complexity for size negotiation, and calls out to a clutter actor instead; also automatically handle reparenting the GtkWindow into the stage window. * Use the reworked ShellGtkEmbed in ShellTrayManager, this simplifies the code a bit, and more importantly results in the tray icons having the correct size negotiation, rather than having a fixed 24x24 size. http://bugzilla.gnome.org/show_bug.cgi?id=580047
2009-05-03 13:05:15 -04:00
};
shell: Use G_DEFINE_TYPE_WITH_PRIVATE() and friends
2015-09-24 12:56:13 -04:00
G_DEFINE_TYPE_WITH_PRIVATE (ShellGtkEmbed, shell_gtk_embed, CLUTTER_TYPE_CLONE);
Add size negotiation to the tray icons * Rename ShellGtkWindowActor to ShellGtkEmbed, and make it require a ShellEmbeddedWindow rather than a general GtkWindow. * Add ShellEmbeddedWindow subclass of GtkWindow that bypasses most of the GtkWindow complexity for size negotiation, and calls out to a clutter actor instead; also automatically handle reparenting the GtkWindow into the stage window. * Use the reworked ShellGtkEmbed in ShellTrayManager, this simplifies the code a bit, and more importantly results in the tray icons having the correct size negotiation, rather than having a fixed 24x24 size. http://bugzilla.gnome.org/show_bug.cgi?id=580047
2009-05-03 13:05:15 -04:00
static void shell_gtk_embed_set_window (ShellGtkEmbed *embed,
ShellEmbeddedWindow *window);
static void
shell-gtk-embed: Use GtkWidget instead of GtkObject GtkObject has been deprecated and removed from GTK+.
2010-09-27 06:36:43 -04:00
shell_gtk_embed_on_window_destroy (GtkWidget *object,
Add size negotiation to the tray icons * Rename ShellGtkWindowActor to ShellGtkEmbed, and make it require a ShellEmbeddedWindow rather than a general GtkWindow. * Add ShellEmbeddedWindow subclass of GtkWindow that bypasses most of the GtkWindow complexity for size negotiation, and calls out to a clutter actor instead; also automatically handle reparenting the GtkWindow into the stage window. * Use the reworked ShellGtkEmbed in ShellTrayManager, this simplifies the code a bit, and more importantly results in the tray icons having the correct size negotiation, rather than having a fixed 24x24 size. http://bugzilla.gnome.org/show_bug.cgi?id=580047
2009-05-03 13:05:15 -04:00
ShellGtkEmbed *embed)
{
shell_gtk_embed_set_window (embed, NULL);
}
static void
Don't use ClutterX11TexturePixmap directly to embed docked windows Previously when a client requests that a window should be docked the shell would reparent the socket window onto the stage's window and then use ClutterX11TexturePixmap to get a texture to represent the window. This will not work if Clutter is no longer using the X11 winsys for example if it becomes its own display server. Instead this patch leaves the socket window as a child of the root window and lets mutter create a MetaWindow out of it. If Mutter is acting as a display server then this mechanism will still work via the headless x server. The ShellGtkEmbed instance now registers for notification of the ‘window-created’ signal of the display so that it can find the MetaWindow that gets created to represent the socket window. When this window is found it is prevented from being displayed on the screen by setting the actor's opacity to 0. An input shape is then set on the window to prevent it receiving any input. Instead of being a subclass of ClutterX11TexturePixmap, ShellGtkEmbed is now a subclass of ClutterClone. When the MetaWindow is found for the socket window the clone's source is set to the invisible actor for the window so it can be displayed in the panel as before. The ShellEmbeddedWindow no longer needs to know what the stage is because it no longer reparents the socket window. Therefore the ShellTrayManager doesn't need to know the stage either so shell_tray_manager_manage_stage has been replaced with just shell_tray_manager_manage_screen. https://bugzilla.gnome.org/show_bug.cgi?id=693438
2013-02-12 17:31:38 -05:00
shell_gtk_embed_remove_window_actor (ShellGtkEmbed *embed)
{
shell: Use G_DECLARE_*_TYPE macros Cut down on boilerplate by using the (no longer that) new helper macros. We don't care about breaking ABI in private libraries, so use G_DECLARE_FINAL_TYPE even where the class struct used to be exposed in the header, except for types we inherit from ourselves (obviously) or where the class exposes any vfuncs (where changes could affect inheritance in extensions).
2015-09-24 14:07:44 -04:00
ShellGtkEmbedPrivate *priv = shell_gtk_embed_get_instance_private (embed);
Don't use ClutterX11TexturePixmap directly to embed docked windows Previously when a client requests that a window should be docked the shell would reparent the socket window onto the stage's window and then use ClutterX11TexturePixmap to get a texture to represent the window. This will not work if Clutter is no longer using the X11 winsys for example if it becomes its own display server. Instead this patch leaves the socket window as a child of the root window and lets mutter create a MetaWindow out of it. If Mutter is acting as a display server then this mechanism will still work via the headless x server. The ShellGtkEmbed instance now registers for notification of the ‘window-created’ signal of the display so that it can find the MetaWindow that gets created to represent the socket window. When this window is found it is prevented from being displayed on the screen by setting the actor's opacity to 0. An input shape is then set on the window to prevent it receiving any input. Instead of being a subclass of ClutterX11TexturePixmap, ShellGtkEmbed is now a subclass of ClutterClone. When the MetaWindow is found for the socket window the clone's source is set to the invisible actor for the window so it can be displayed in the panel as before. The ShellEmbeddedWindow no longer needs to know what the stage is because it no longer reparents the socket window. Therefore the ShellTrayManager doesn't need to know the stage either so shell_tray_manager_manage_stage has been replaced with just shell_tray_manager_manage_screen. https://bugzilla.gnome.org/show_bug.cgi?id=693438
2013-02-12 17:31:38 -05:00
if (priv->window_actor)
{
cleanup: Use g_clear_signal_handler() where possible `g_clear_signal_handler()` is usually cleaner and saver than `g_signal_handler_disconnect()`. We use it new code, lets also adopt the existing one. See also https://gitlab.gnome.org/GNOME/mutter/merge_requests/868 and https://gitlab.gnome.org/GNOME/mutter/merge_requests/940 https://gitlab.gnome.org/GNOME/gnome-shell/merge_requests/842
2019-11-21 17:00:53 -05:00
g_clear_signal_handler (&priv->window_actor_destroyed_handler,
priv->window_actor);
Don't use ClutterX11TexturePixmap directly to embed docked windows Previously when a client requests that a window should be docked the shell would reparent the socket window onto the stage's window and then use ClutterX11TexturePixmap to get a texture to represent the window. This will not work if Clutter is no longer using the X11 winsys for example if it becomes its own display server. Instead this patch leaves the socket window as a child of the root window and lets mutter create a MetaWindow out of it. If Mutter is acting as a display server then this mechanism will still work via the headless x server. The ShellGtkEmbed instance now registers for notification of the ‘window-created’ signal of the display so that it can find the MetaWindow that gets created to represent the socket window. When this window is found it is prevented from being displayed on the screen by setting the actor's opacity to 0. An input shape is then set on the window to prevent it receiving any input. Instead of being a subclass of ClutterX11TexturePixmap, ShellGtkEmbed is now a subclass of ClutterClone. When the MetaWindow is found for the socket window the clone's source is set to the invisible actor for the window so it can be displayed in the panel as before. The ShellEmbeddedWindow no longer needs to know what the stage is because it no longer reparents the socket window. Therefore the ShellTrayManager doesn't need to know the stage either so shell_tray_manager_manage_stage has been replaced with just shell_tray_manager_manage_screen. https://bugzilla.gnome.org/show_bug.cgi?id=693438
2013-02-12 17:31:38 -05:00
g_object_unref (priv->window_actor);
priv->window_actor = NULL;
}
clutter_clone_set_source (CLUTTER_CLONE (embed), NULL);
}
static void
shell_gtk_embed_window_created_cb (MetaDisplay *display,
MetaWindow *window,
Add size negotiation to the tray icons * Rename ShellGtkWindowActor to ShellGtkEmbed, and make it require a ShellEmbeddedWindow rather than a general GtkWindow. * Add ShellEmbeddedWindow subclass of GtkWindow that bypasses most of the GtkWindow complexity for size negotiation, and calls out to a clutter actor instead; also automatically handle reparenting the GtkWindow into the stage window. * Use the reworked ShellGtkEmbed in ShellTrayManager, this simplifies the code a bit, and more importantly results in the tray icons having the correct size negotiation, rather than having a fixed 24x24 size. http://bugzilla.gnome.org/show_bug.cgi?id=580047
2009-05-03 13:05:15 -04:00
ShellGtkEmbed *embed)
{
shell: Use G_DECLARE_*_TYPE macros Cut down on boilerplate by using the (no longer that) new helper macros. We don't care about breaking ABI in private libraries, so use G_DECLARE_FINAL_TYPE even where the class struct used to be exposed in the header, except for types we inherit from ourselves (obviously) or where the class exposes any vfuncs (where changes could affect inheritance in extensions).
2015-09-24 14:07:44 -04:00
ShellGtkEmbedPrivate *priv = shell_gtk_embed_get_instance_private (embed);
Don't use ClutterX11TexturePixmap directly to embed docked windows Previously when a client requests that a window should be docked the shell would reparent the socket window onto the stage's window and then use ClutterX11TexturePixmap to get a texture to represent the window. This will not work if Clutter is no longer using the X11 winsys for example if it becomes its own display server. Instead this patch leaves the socket window as a child of the root window and lets mutter create a MetaWindow out of it. If Mutter is acting as a display server then this mechanism will still work via the headless x server. The ShellGtkEmbed instance now registers for notification of the ‘window-created’ signal of the display so that it can find the MetaWindow that gets created to represent the socket window. When this window is found it is prevented from being displayed on the screen by setting the actor's opacity to 0. An input shape is then set on the window to prevent it receiving any input. Instead of being a subclass of ClutterX11TexturePixmap, ShellGtkEmbed is now a subclass of ClutterClone. When the MetaWindow is found for the socket window the clone's source is set to the invisible actor for the window so it can be displayed in the panel as before. The ShellEmbeddedWindow no longer needs to know what the stage is because it no longer reparents the socket window. Therefore the ShellTrayManager doesn't need to know the stage either so shell_tray_manager_manage_stage has been replaced with just shell_tray_manager_manage_screen. https://bugzilla.gnome.org/show_bug.cgi?id=693438
2013-02-12 17:31:38 -05:00
Window xwindow = meta_window_get_xwindow (window);
GdkWindow *gdk_window = gtk_widget_get_window (GTK_WIDGET (priv->window));
gtk-embed: Don't try to compare with unrealized window After having embedded a Gtk window, we start to listen for the corresponding MetaWindow to know when it has been mapped by the compositor. If the embedder does not realize the window immediately, and some other window is created and mapped before the embedder realizes the window, we would prior to this patch try to dereference the not created GdkWindow. Fix this by NULL checking the GdkWindow before dereferencing. We will never miss the needed MetaWindow creation since it can not have been mapped have it not yet been realized. https://bugzilla.gnome.org/show_bug.cgi?id=776130
2016-12-15 06:34:10 -05:00
if (gdk_window && xwindow == gdk_x11_window_get_xid (gdk_window))
Don't use ClutterX11TexturePixmap directly to embed docked windows Previously when a client requests that a window should be docked the shell would reparent the socket window onto the stage's window and then use ClutterX11TexturePixmap to get a texture to represent the window. This will not work if Clutter is no longer using the X11 winsys for example if it becomes its own display server. Instead this patch leaves the socket window as a child of the root window and lets mutter create a MetaWindow out of it. If Mutter is acting as a display server then this mechanism will still work via the headless x server. The ShellGtkEmbed instance now registers for notification of the ‘window-created’ signal of the display so that it can find the MetaWindow that gets created to represent the socket window. When this window is found it is prevented from being displayed on the screen by setting the actor's opacity to 0. An input shape is then set on the window to prevent it receiving any input. Instead of being a subclass of ClutterX11TexturePixmap, ShellGtkEmbed is now a subclass of ClutterClone. When the MetaWindow is found for the socket window the clone's source is set to the invisible actor for the window so it can be displayed in the panel as before. The ShellEmbeddedWindow no longer needs to know what the stage is because it no longer reparents the socket window. Therefore the ShellTrayManager doesn't need to know the stage either so shell_tray_manager_manage_stage has been replaced with just shell_tray_manager_manage_screen. https://bugzilla.gnome.org/show_bug.cgi?id=693438
2013-02-12 17:31:38 -05:00
{
ClutterActor *window_actor =
CLUTTER_ACTOR (meta_window_get_compositor_private (window));
GCallback remove_cb = G_CALLBACK (shell_gtk_embed_remove_window_actor);
cairo_region_t *empty_region;
clutter_clone_set_source (CLUTTER_CLONE (embed), window_actor);
/* We want to explicitly clear the clone source when the window
actor is destroyed because otherwise we might end up keeping
it alive after it has been disposed. Otherwise this can cause
a crash if there is a paint after mutter notices that the top
level window has been destroyed, which causes it to dispose
the window, and before the tray manager notices that the
window is gone which would otherwise reset the window and
unref the clone */
priv->window_actor = g_object_ref (window_actor);
priv->window_actor_destroyed_handler =
g_signal_connect_swapped (window_actor,
"destroy",
remove_cb,
embed);
/* Hide the original actor otherwise it will appear in the scene
as a normal window */
clutter_actor_set_opacity (window_actor, 0);
gtk-embed: Hide window actors from pick Since we started to support tray icons on wayland, the icon we show is not the actual XEmbed window. Instead, we let mutter create a MetaWindow for it, then use its window actor as source for a clone we (or nowadays: extensions) can add, remove and destroy freely. To not let the real icon get in the way, we set an empty input shape and make its window actor fully transparent. This works OK on X11, but on wayland all events still go through Clutter, so any reactive surface actor inside the window actor will block events for any actors underneath (and status icons go into the top-windows group, so almost all actors are affected). Luckily we can pile another hack onto the pile of status icon hacks ... https://gitlab.gnome.org/GNOME/gnome-shell/issues/191
2019-02-15 11:04:10 -05:00
/* Also make sure it (or any of its children) doesn't block
events on wayland */
shell_util_set_hidden_from_pick (window_actor, TRUE);
Don't use ClutterX11TexturePixmap directly to embed docked windows Previously when a client requests that a window should be docked the shell would reparent the socket window onto the stage's window and then use ClutterX11TexturePixmap to get a texture to represent the window. This will not work if Clutter is no longer using the X11 winsys for example if it becomes its own display server. Instead this patch leaves the socket window as a child of the root window and lets mutter create a MetaWindow out of it. If Mutter is acting as a display server then this mechanism will still work via the headless x server. The ShellGtkEmbed instance now registers for notification of the ‘window-created’ signal of the display so that it can find the MetaWindow that gets created to represent the socket window. When this window is found it is prevented from being displayed on the screen by setting the actor's opacity to 0. An input shape is then set on the window to prevent it receiving any input. Instead of being a subclass of ClutterX11TexturePixmap, ShellGtkEmbed is now a subclass of ClutterClone. When the MetaWindow is found for the socket window the clone's source is set to the invisible actor for the window so it can be displayed in the panel as before. The ShellEmbeddedWindow no longer needs to know what the stage is because it no longer reparents the socket window. Therefore the ShellTrayManager doesn't need to know the stage either so shell_tray_manager_manage_stage has been replaced with just shell_tray_manager_manage_screen. https://bugzilla.gnome.org/show_bug.cgi?id=693438
2013-02-12 17:31:38 -05:00
/* Set an empty input shape on the window so that it can't get
gtk-embed: Fix typo in comment
2015-03-19 21:27:07 -04:00
any input. This probably isn't the ideal way to achieve this.
Don't use ClutterX11TexturePixmap directly to embed docked windows Previously when a client requests that a window should be docked the shell would reparent the socket window onto the stage's window and then use ClutterX11TexturePixmap to get a texture to represent the window. This will not work if Clutter is no longer using the X11 winsys for example if it becomes its own display server. Instead this patch leaves the socket window as a child of the root window and lets mutter create a MetaWindow out of it. If Mutter is acting as a display server then this mechanism will still work via the headless x server. The ShellGtkEmbed instance now registers for notification of the ‘window-created’ signal of the display so that it can find the MetaWindow that gets created to represent the socket window. When this window is found it is prevented from being displayed on the screen by setting the actor's opacity to 0. An input shape is then set on the window to prevent it receiving any input. Instead of being a subclass of ClutterX11TexturePixmap, ShellGtkEmbed is now a subclass of ClutterClone. When the MetaWindow is found for the socket window the clone's source is set to the invisible actor for the window so it can be displayed in the panel as before. The ShellEmbeddedWindow no longer needs to know what the stage is because it no longer reparents the socket window. Therefore the ShellTrayManager doesn't need to know the stage either so shell_tray_manager_manage_stage has been replaced with just shell_tray_manager_manage_screen. https://bugzilla.gnome.org/show_bug.cgi?id=693438
2013-02-12 17:31:38 -05:00
It would probably be better to force the window to go behind
Mutter's guard window, but this is quite difficult to do as
Mutter doesn't manage the stacking for override redirect
windows and the guard window is repeatedly lowered to the
bottom of the stack. */
empty_region = cairo_region_create ();
gdk_window_input_shape_combine_region (gdk_window,
empty_region,
0, 0 /* offset x/y */);
cairo_region_destroy (empty_region);
shell-gtk-embed: Lower tray icon windows to the bottom of the stack Otherwise they break the "top level window" detection used by the unredirect code in mutter, causes game windows not to be unredirected when tray icons are present. https://bugzilla.gnome.org/show_bug.cgi?id=701224
2013-05-29 18:53:37 -04:00
gdk_window_lower (gdk_window);
Don't use ClutterX11TexturePixmap directly to embed docked windows Previously when a client requests that a window should be docked the shell would reparent the socket window onto the stage's window and then use ClutterX11TexturePixmap to get a texture to represent the window. This will not work if Clutter is no longer using the X11 winsys for example if it becomes its own display server. Instead this patch leaves the socket window as a child of the root window and lets mutter create a MetaWindow out of it. If Mutter is acting as a display server then this mechanism will still work via the headless x server. The ShellGtkEmbed instance now registers for notification of the ‘window-created’ signal of the display so that it can find the MetaWindow that gets created to represent the socket window. When this window is found it is prevented from being displayed on the screen by setting the actor's opacity to 0. An input shape is then set on the window to prevent it receiving any input. Instead of being a subclass of ClutterX11TexturePixmap, ShellGtkEmbed is now a subclass of ClutterClone. When the MetaWindow is found for the socket window the clone's source is set to the invisible actor for the window so it can be displayed in the panel as before. The ShellEmbeddedWindow no longer needs to know what the stage is because it no longer reparents the socket window. Therefore the ShellTrayManager doesn't need to know the stage either so shell_tray_manager_manage_stage has been replaced with just shell_tray_manager_manage_screen. https://bugzilla.gnome.org/show_bug.cgi?id=693438
2013-02-12 17:31:38 -05:00
/* Now that we've found the window we don't need to listen for
new windows anymore */
cleanup: Use g_clear_signal_handler() where possible `g_clear_signal_handler()` is usually cleaner and saver than `g_signal_handler_disconnect()`. We use it new code, lets also adopt the existing one. See also https://gitlab.gnome.org/GNOME/mutter/merge_requests/868 and https://gitlab.gnome.org/GNOME/mutter/merge_requests/940 https://gitlab.gnome.org/GNOME/gnome-shell/merge_requests/842
2019-11-21 17:00:53 -05:00
g_clear_signal_handler (&priv->window_created_handler,
display);
Don't use ClutterX11TexturePixmap directly to embed docked windows Previously when a client requests that a window should be docked the shell would reparent the socket window onto the stage's window and then use ClutterX11TexturePixmap to get a texture to represent the window. This will not work if Clutter is no longer using the X11 winsys for example if it becomes its own display server. Instead this patch leaves the socket window as a child of the root window and lets mutter create a MetaWindow out of it. If Mutter is acting as a display server then this mechanism will still work via the headless x server. The ShellGtkEmbed instance now registers for notification of the ‘window-created’ signal of the display so that it can find the MetaWindow that gets created to represent the socket window. When this window is found it is prevented from being displayed on the screen by setting the actor's opacity to 0. An input shape is then set on the window to prevent it receiving any input. Instead of being a subclass of ClutterX11TexturePixmap, ShellGtkEmbed is now a subclass of ClutterClone. When the MetaWindow is found for the socket window the clone's source is set to the invisible actor for the window so it can be displayed in the panel as before. The ShellEmbeddedWindow no longer needs to know what the stage is because it no longer reparents the socket window. Therefore the ShellTrayManager doesn't need to know the stage either so shell_tray_manager_manage_stage has been replaced with just shell_tray_manager_manage_screen. https://bugzilla.gnome.org/show_bug.cgi?id=693438
2013-02-12 17:31:38 -05:00
}
Add size negotiation to the tray icons * Rename ShellGtkWindowActor to ShellGtkEmbed, and make it require a ShellEmbeddedWindow rather than a general GtkWindow. * Add ShellEmbeddedWindow subclass of GtkWindow that bypasses most of the GtkWindow complexity for size negotiation, and calls out to a clutter actor instead; also automatically handle reparenting the GtkWindow into the stage window. * Use the reworked ShellGtkEmbed in ShellTrayManager, this simplifies the code a bit, and more importantly results in the tray icons having the correct size negotiation, rather than having a fixed 24x24 size. http://bugzilla.gnome.org/show_bug.cgi?id=580047
2009-05-03 13:05:15 -04:00
}
gtk-embed: Handle unmap/map of the embedded window The current code assumes that an embedded window will correspond to a single MetaWindow over the entire lifetime of the icon, which is incorrect - the embedded window is unmanaged on Unmap and a new MetaWindow will be created the next time the embedded window is mapped. As we currently ignore the new MetaWindow completely, it will be shown normally in the scene instead of the embedded clone as intended. Fix this by setting up clone and window actor each time the embedded window is mapped rather than once in shell_gtk_embed_set_window(). https://bugzilla.gnome.org/show_bug.cgi?id=745824
2015-03-19 19:06:34 -04:00
static void
shell_gtk_embed_on_window_mapped (GtkWidget *object,
ShellGtkEmbed *embed)
{
shell: Use G_DECLARE_*_TYPE macros Cut down on boilerplate by using the (no longer that) new helper macros. We don't care about breaking ABI in private libraries, so use G_DECLARE_FINAL_TYPE even where the class struct used to be exposed in the header, except for types we inherit from ourselves (obviously) or where the class exposes any vfuncs (where changes could affect inheritance in extensions).
2015-09-24 14:07:44 -04:00
ShellGtkEmbedPrivate *priv = shell_gtk_embed_get_instance_private (embed);
gtk-embed: Handle unmap/map of the embedded window The current code assumes that an embedded window will correspond to a single MetaWindow over the entire lifetime of the icon, which is incorrect - the embedded window is unmanaged on Unmap and a new MetaWindow will be created the next time the embedded window is mapped. As we currently ignore the new MetaWindow completely, it will be shown normally in the scene instead of the embedded clone as intended. Fix this by setting up clone and window actor each time the embedded window is mapped rather than once in shell_gtk_embed_set_window(). https://bugzilla.gnome.org/show_bug.cgi?id=745824
2015-03-19 19:06:34 -04:00
MetaDisplay *display = shell_global_get_display (shell_global_get ());
gtk-embed: ensure we only listen for window-created events once If a tray icon gets a mapped and unmapped and the mapped again in quick succession, we can end up with multiple handlers listening for window creation events. This commit tries to guard against that by only listening for window-created events when we don't know the actor associated with the icon. https://bugzilla.gnome.org/show_bug.cgi?id=787361
2017-09-14 14:46:13 -04:00
if (priv->window_created_handler == 0 && priv->window_actor == NULL)
/* Listen for new windows so we can detect when Mutter has
created a MutterWindow for this window */
priv->window_created_handler =
g_signal_connect (display,
"window-created",
G_CALLBACK (shell_gtk_embed_window_created_cb),
embed);
gtk-embed: Handle unmap/map of the embedded window The current code assumes that an embedded window will correspond to a single MetaWindow over the entire lifetime of the icon, which is incorrect - the embedded window is unmanaged on Unmap and a new MetaWindow will be created the next time the embedded window is mapped. As we currently ignore the new MetaWindow completely, it will be shown normally in the scene instead of the embedded clone as intended. Fix this by setting up clone and window actor each time the embedded window is mapped rather than once in shell_gtk_embed_set_window(). https://bugzilla.gnome.org/show_bug.cgi?id=745824
2015-03-19 19:06:34 -04:00
}
Add size negotiation to the tray icons * Rename ShellGtkWindowActor to ShellGtkEmbed, and make it require a ShellEmbeddedWindow rather than a general GtkWindow. * Add ShellEmbeddedWindow subclass of GtkWindow that bypasses most of the GtkWindow complexity for size negotiation, and calls out to a clutter actor instead; also automatically handle reparenting the GtkWindow into the stage window. * Use the reworked ShellGtkEmbed in ShellTrayManager, this simplifies the code a bit, and more importantly results in the tray icons having the correct size negotiation, rather than having a fixed 24x24 size. http://bugzilla.gnome.org/show_bug.cgi?id=580047
2009-05-03 13:05:15 -04:00
static void
shell_gtk_embed_set_window (ShellGtkEmbed *embed,
ShellEmbeddedWindow *window)
{
shell: Use G_DECLARE_*_TYPE macros Cut down on boilerplate by using the (no longer that) new helper macros. We don't care about breaking ABI in private libraries, so use G_DECLARE_FINAL_TYPE even where the class struct used to be exposed in the header, except for types we inherit from ourselves (obviously) or where the class exposes any vfuncs (where changes could affect inheritance in extensions).
2015-09-24 14:07:44 -04:00
ShellGtkEmbedPrivate *priv = shell_gtk_embed_get_instance_private (embed);
Don't use ClutterX11TexturePixmap directly to embed docked windows Previously when a client requests that a window should be docked the shell would reparent the socket window onto the stage's window and then use ClutterX11TexturePixmap to get a texture to represent the window. This will not work if Clutter is no longer using the X11 winsys for example if it becomes its own display server. Instead this patch leaves the socket window as a child of the root window and lets mutter create a MetaWindow out of it. If Mutter is acting as a display server then this mechanism will still work via the headless x server. The ShellGtkEmbed instance now registers for notification of the ‘window-created’ signal of the display so that it can find the MetaWindow that gets created to represent the socket window. When this window is found it is prevented from being displayed on the screen by setting the actor's opacity to 0. An input shape is then set on the window to prevent it receiving any input. Instead of being a subclass of ClutterX11TexturePixmap, ShellGtkEmbed is now a subclass of ClutterClone. When the MetaWindow is found for the socket window the clone's source is set to the invisible actor for the window so it can be displayed in the panel as before. The ShellEmbeddedWindow no longer needs to know what the stage is because it no longer reparents the socket window. Therefore the ShellTrayManager doesn't need to know the stage either so shell_tray_manager_manage_stage has been replaced with just shell_tray_manager_manage_screen. https://bugzilla.gnome.org/show_bug.cgi?id=693438
2013-02-12 17:31:38 -05:00
MetaDisplay *display = shell_global_get_display (shell_global_get ());
Add size negotiation to the tray icons * Rename ShellGtkWindowActor to ShellGtkEmbed, and make it require a ShellEmbeddedWindow rather than a general GtkWindow. * Add ShellEmbeddedWindow subclass of GtkWindow that bypasses most of the GtkWindow complexity for size negotiation, and calls out to a clutter actor instead; also automatically handle reparenting the GtkWindow into the stage window. * Use the reworked ShellGtkEmbed in ShellTrayManager, this simplifies the code a bit, and more importantly results in the tray icons having the correct size negotiation, rather than having a fixed 24x24 size. http://bugzilla.gnome.org/show_bug.cgi?id=580047
2009-05-03 13:05:15 -04:00
shell: Use G_DECLARE_*_TYPE macros Cut down on boilerplate by using the (no longer that) new helper macros. We don't care about breaking ABI in private libraries, so use G_DECLARE_FINAL_TYPE even where the class struct used to be exposed in the header, except for types we inherit from ourselves (obviously) or where the class exposes any vfuncs (where changes could affect inheritance in extensions).
2015-09-24 14:07:44 -04:00
if (priv->window)
Add size negotiation to the tray icons * Rename ShellGtkWindowActor to ShellGtkEmbed, and make it require a ShellEmbeddedWindow rather than a general GtkWindow. * Add ShellEmbeddedWindow subclass of GtkWindow that bypasses most of the GtkWindow complexity for size negotiation, and calls out to a clutter actor instead; also automatically handle reparenting the GtkWindow into the stage window. * Use the reworked ShellGtkEmbed in ShellTrayManager, this simplifies the code a bit, and more importantly results in the tray icons having the correct size negotiation, rather than having a fixed 24x24 size. http://bugzilla.gnome.org/show_bug.cgi?id=580047
2009-05-03 13:05:15 -04:00
{
cleanup: Use g_clear_signal_handler() where possible `g_clear_signal_handler()` is usually cleaner and saver than `g_signal_handler_disconnect()`. We use it new code, lets also adopt the existing one. See also https://gitlab.gnome.org/GNOME/mutter/merge_requests/868 and https://gitlab.gnome.org/GNOME/mutter/merge_requests/940 https://gitlab.gnome.org/GNOME/gnome-shell/merge_requests/842
2019-11-21 17:00:53 -05:00
g_clear_signal_handler (&priv->window_created_handler, display);
Don't use ClutterX11TexturePixmap directly to embed docked windows Previously when a client requests that a window should be docked the shell would reparent the socket window onto the stage's window and then use ClutterX11TexturePixmap to get a texture to represent the window. This will not work if Clutter is no longer using the X11 winsys for example if it becomes its own display server. Instead this patch leaves the socket window as a child of the root window and lets mutter create a MetaWindow out of it. If Mutter is acting as a display server then this mechanism will still work via the headless x server. The ShellGtkEmbed instance now registers for notification of the ‘window-created’ signal of the display so that it can find the MetaWindow that gets created to represent the socket window. When this window is found it is prevented from being displayed on the screen by setting the actor's opacity to 0. An input shape is then set on the window to prevent it receiving any input. Instead of being a subclass of ClutterX11TexturePixmap, ShellGtkEmbed is now a subclass of ClutterClone. When the MetaWindow is found for the socket window the clone's source is set to the invisible actor for the window so it can be displayed in the panel as before. The ShellEmbeddedWindow no longer needs to know what the stage is because it no longer reparents the socket window. Therefore the ShellTrayManager doesn't need to know the stage either so shell_tray_manager_manage_stage has been replaced with just shell_tray_manager_manage_screen. https://bugzilla.gnome.org/show_bug.cgi?id=693438
2013-02-12 17:31:38 -05:00
shell_gtk_embed_remove_window_actor (embed);
shell: Use G_DECLARE_*_TYPE macros Cut down on boilerplate by using the (no longer that) new helper macros. We don't care about breaking ABI in private libraries, so use G_DECLARE_FINAL_TYPE even where the class struct used to be exposed in the header, except for types we inherit from ourselves (obviously) or where the class exposes any vfuncs (where changes could affect inheritance in extensions).
2015-09-24 14:07:44 -04:00
_shell_embedded_window_set_actor (priv->window, NULL);
Add size negotiation to the tray icons * Rename ShellGtkWindowActor to ShellGtkEmbed, and make it require a ShellEmbeddedWindow rather than a general GtkWindow. * Add ShellEmbeddedWindow subclass of GtkWindow that bypasses most of the GtkWindow complexity for size negotiation, and calls out to a clutter actor instead; also automatically handle reparenting the GtkWindow into the stage window. * Use the reworked ShellGtkEmbed in ShellTrayManager, this simplifies the code a bit, and more importantly results in the tray icons having the correct size negotiation, rather than having a fixed 24x24 size. http://bugzilla.gnome.org/show_bug.cgi?id=580047
2009-05-03 13:05:15 -04:00
shell: Use G_DECLARE_*_TYPE macros Cut down on boilerplate by using the (no longer that) new helper macros. We don't care about breaking ABI in private libraries, so use G_DECLARE_FINAL_TYPE even where the class struct used to be exposed in the header, except for types we inherit from ourselves (obviously) or where the class exposes any vfuncs (where changes could affect inheritance in extensions).
2015-09-24 14:07:44 -04:00
g_object_unref (priv->window);
Add size negotiation to the tray icons * Rename ShellGtkWindowActor to ShellGtkEmbed, and make it require a ShellEmbeddedWindow rather than a general GtkWindow. * Add ShellEmbeddedWindow subclass of GtkWindow that bypasses most of the GtkWindow complexity for size negotiation, and calls out to a clutter actor instead; also automatically handle reparenting the GtkWindow into the stage window. * Use the reworked ShellGtkEmbed in ShellTrayManager, this simplifies the code a bit, and more importantly results in the tray icons having the correct size negotiation, rather than having a fixed 24x24 size. http://bugzilla.gnome.org/show_bug.cgi?id=580047
2009-05-03 13:05:15 -04:00
shell: Use G_DECLARE_*_TYPE macros Cut down on boilerplate by using the (no longer that) new helper macros. We don't care about breaking ABI in private libraries, so use G_DECLARE_FINAL_TYPE even where the class struct used to be exposed in the header, except for types we inherit from ourselves (obviously) or where the class exposes any vfuncs (where changes could affect inheritance in extensions).
2015-09-24 14:07:44 -04:00
g_signal_handlers_disconnect_by_func (priv->window,
Add size negotiation to the tray icons * Rename ShellGtkWindowActor to ShellGtkEmbed, and make it require a ShellEmbeddedWindow rather than a general GtkWindow. * Add ShellEmbeddedWindow subclass of GtkWindow that bypasses most of the GtkWindow complexity for size negotiation, and calls out to a clutter actor instead; also automatically handle reparenting the GtkWindow into the stage window. * Use the reworked ShellGtkEmbed in ShellTrayManager, this simplifies the code a bit, and more importantly results in the tray icons having the correct size negotiation, rather than having a fixed 24x24 size. http://bugzilla.gnome.org/show_bug.cgi?id=580047
2009-05-03 13:05:15 -04:00
(gpointer)shell_gtk_embed_on_window_destroy,
embed);
gtk-embed: Handle unmap/map of the embedded window The current code assumes that an embedded window will correspond to a single MetaWindow over the entire lifetime of the icon, which is incorrect - the embedded window is unmanaged on Unmap and a new MetaWindow will be created the next time the embedded window is mapped. As we currently ignore the new MetaWindow completely, it will be shown normally in the scene instead of the embedded clone as intended. Fix this by setting up clone and window actor each time the embedded window is mapped rather than once in shell_gtk_embed_set_window(). https://bugzilla.gnome.org/show_bug.cgi?id=745824
2015-03-19 19:06:34 -04:00
shell: Use G_DECLARE_*_TYPE macros Cut down on boilerplate by using the (no longer that) new helper macros. We don't care about breaking ABI in private libraries, so use G_DECLARE_FINAL_TYPE even where the class struct used to be exposed in the header, except for types we inherit from ourselves (obviously) or where the class exposes any vfuncs (where changes could affect inheritance in extensions).
2015-09-24 14:07:44 -04:00
g_signal_handlers_disconnect_by_func (priv->window,
gtk-embed: Handle unmap/map of the embedded window The current code assumes that an embedded window will correspond to a single MetaWindow over the entire lifetime of the icon, which is incorrect - the embedded window is unmanaged on Unmap and a new MetaWindow will be created the next time the embedded window is mapped. As we currently ignore the new MetaWindow completely, it will be shown normally in the scene instead of the embedded clone as intended. Fix this by setting up clone and window actor each time the embedded window is mapped rather than once in shell_gtk_embed_set_window(). https://bugzilla.gnome.org/show_bug.cgi?id=745824
2015-03-19 19:06:34 -04:00
(gpointer)shell_gtk_embed_on_window_mapped,
embed);
Add size negotiation to the tray icons * Rename ShellGtkWindowActor to ShellGtkEmbed, and make it require a ShellEmbeddedWindow rather than a general GtkWindow. * Add ShellEmbeddedWindow subclass of GtkWindow that bypasses most of the GtkWindow complexity for size negotiation, and calls out to a clutter actor instead; also automatically handle reparenting the GtkWindow into the stage window. * Use the reworked ShellGtkEmbed in ShellTrayManager, this simplifies the code a bit, and more importantly results in the tray icons having the correct size negotiation, rather than having a fixed 24x24 size. http://bugzilla.gnome.org/show_bug.cgi?id=580047
2009-05-03 13:05:15 -04:00
}
shell: Use G_DECLARE_*_TYPE macros Cut down on boilerplate by using the (no longer that) new helper macros. We don't care about breaking ABI in private libraries, so use G_DECLARE_FINAL_TYPE even where the class struct used to be exposed in the header, except for types we inherit from ourselves (obviously) or where the class exposes any vfuncs (where changes could affect inheritance in extensions).
2015-09-24 14:07:44 -04:00
priv->window = window;
Add size negotiation to the tray icons * Rename ShellGtkWindowActor to ShellGtkEmbed, and make it require a ShellEmbeddedWindow rather than a general GtkWindow. * Add ShellEmbeddedWindow subclass of GtkWindow that bypasses most of the GtkWindow complexity for size negotiation, and calls out to a clutter actor instead; also automatically handle reparenting the GtkWindow into the stage window. * Use the reworked ShellGtkEmbed in ShellTrayManager, this simplifies the code a bit, and more importantly results in the tray icons having the correct size negotiation, rather than having a fixed 24x24 size. http://bugzilla.gnome.org/show_bug.cgi?id=580047
2009-05-03 13:05:15 -04:00
shell: Use G_DECLARE_*_TYPE macros Cut down on boilerplate by using the (no longer that) new helper macros. We don't care about breaking ABI in private libraries, so use G_DECLARE_FINAL_TYPE even where the class struct used to be exposed in the header, except for types we inherit from ourselves (obviously) or where the class exposes any vfuncs (where changes could affect inheritance in extensions).
2015-09-24 14:07:44 -04:00
if (priv->window)
Add size negotiation to the tray icons * Rename ShellGtkWindowActor to ShellGtkEmbed, and make it require a ShellEmbeddedWindow rather than a general GtkWindow. * Add ShellEmbeddedWindow subclass of GtkWindow that bypasses most of the GtkWindow complexity for size negotiation, and calls out to a clutter actor instead; also automatically handle reparenting the GtkWindow into the stage window. * Use the reworked ShellGtkEmbed in ShellTrayManager, this simplifies the code a bit, and more importantly results in the tray icons having the correct size negotiation, rather than having a fixed 24x24 size. http://bugzilla.gnome.org/show_bug.cgi?id=580047
2009-05-03 13:05:15 -04:00
{
shell: Use G_DECLARE_*_TYPE macros Cut down on boilerplate by using the (no longer that) new helper macros. We don't care about breaking ABI in private libraries, so use G_DECLARE_FINAL_TYPE even where the class struct used to be exposed in the header, except for types we inherit from ourselves (obviously) or where the class exposes any vfuncs (where changes could affect inheritance in extensions).
2015-09-24 14:07:44 -04:00
g_object_ref (priv->window);
Add size negotiation to the tray icons * Rename ShellGtkWindowActor to ShellGtkEmbed, and make it require a ShellEmbeddedWindow rather than a general GtkWindow. * Add ShellEmbeddedWindow subclass of GtkWindow that bypasses most of the GtkWindow complexity for size negotiation, and calls out to a clutter actor instead; also automatically handle reparenting the GtkWindow into the stage window. * Use the reworked ShellGtkEmbed in ShellTrayManager, this simplifies the code a bit, and more importantly results in the tray icons having the correct size negotiation, rather than having a fixed 24x24 size. http://bugzilla.gnome.org/show_bug.cgi?id=580047
2009-05-03 13:05:15 -04:00
shell: Use G_DECLARE_*_TYPE macros Cut down on boilerplate by using the (no longer that) new helper macros. We don't care about breaking ABI in private libraries, so use G_DECLARE_FINAL_TYPE even where the class struct used to be exposed in the header, except for types we inherit from ourselves (obviously) or where the class exposes any vfuncs (where changes could affect inheritance in extensions).
2015-09-24 14:07:44 -04:00
_shell_embedded_window_set_actor (priv->window, embed);
Add size negotiation to the tray icons * Rename ShellGtkWindowActor to ShellGtkEmbed, and make it require a ShellEmbeddedWindow rather than a general GtkWindow. * Add ShellEmbeddedWindow subclass of GtkWindow that bypasses most of the GtkWindow complexity for size negotiation, and calls out to a clutter actor instead; also automatically handle reparenting the GtkWindow into the stage window. * Use the reworked ShellGtkEmbed in ShellTrayManager, this simplifies the code a bit, and more importantly results in the tray icons having the correct size negotiation, rather than having a fixed 24x24 size. http://bugzilla.gnome.org/show_bug.cgi?id=580047
2009-05-03 13:05:15 -04:00
shell: Use G_DECLARE_*_TYPE macros Cut down on boilerplate by using the (no longer that) new helper macros. We don't care about breaking ABI in private libraries, so use G_DECLARE_FINAL_TYPE even where the class struct used to be exposed in the header, except for types we inherit from ourselves (obviously) or where the class exposes any vfuncs (where changes could affect inheritance in extensions).
2015-09-24 14:07:44 -04:00
g_signal_connect (priv->window, "destroy",
Add size negotiation to the tray icons * Rename ShellGtkWindowActor to ShellGtkEmbed, and make it require a ShellEmbeddedWindow rather than a general GtkWindow. * Add ShellEmbeddedWindow subclass of GtkWindow that bypasses most of the GtkWindow complexity for size negotiation, and calls out to a clutter actor instead; also automatically handle reparenting the GtkWindow into the stage window. * Use the reworked ShellGtkEmbed in ShellTrayManager, this simplifies the code a bit, and more importantly results in the tray icons having the correct size negotiation, rather than having a fixed 24x24 size. http://bugzilla.gnome.org/show_bug.cgi?id=580047
2009-05-03 13:05:15 -04:00
G_CALLBACK (shell_gtk_embed_on_window_destroy), embed);
shell: Use G_DECLARE_*_TYPE macros Cut down on boilerplate by using the (no longer that) new helper macros. We don't care about breaking ABI in private libraries, so use G_DECLARE_FINAL_TYPE even where the class struct used to be exposed in the header, except for types we inherit from ourselves (obviously) or where the class exposes any vfuncs (where changes could affect inheritance in extensions).
2015-09-24 14:07:44 -04:00
g_signal_connect (priv->window, "map",
gtk-embed: Handle unmap/map of the embedded window The current code assumes that an embedded window will correspond to a single MetaWindow over the entire lifetime of the icon, which is incorrect - the embedded window is unmanaged on Unmap and a new MetaWindow will be created the next time the embedded window is mapped. As we currently ignore the new MetaWindow completely, it will be shown normally in the scene instead of the embedded clone as intended. Fix this by setting up clone and window actor each time the embedded window is mapped rather than once in shell_gtk_embed_set_window(). https://bugzilla.gnome.org/show_bug.cgi?id=745824
2015-03-19 19:06:34 -04:00
G_CALLBACK (shell_gtk_embed_on_window_mapped), embed);
Add size negotiation to the tray icons * Rename ShellGtkWindowActor to ShellGtkEmbed, and make it require a ShellEmbeddedWindow rather than a general GtkWindow. * Add ShellEmbeddedWindow subclass of GtkWindow that bypasses most of the GtkWindow complexity for size negotiation, and calls out to a clutter actor instead; also automatically handle reparenting the GtkWindow into the stage window. * Use the reworked ShellGtkEmbed in ShellTrayManager, this simplifies the code a bit, and more importantly results in the tray icons having the correct size negotiation, rather than having a fixed 24x24 size. http://bugzilla.gnome.org/show_bug.cgi?id=580047
2009-05-03 13:05:15 -04:00
}
clutter_actor_queue_relayout (CLUTTER_ACTOR (embed));
}
static void
shell_gtk_embed_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
ShellGtkEmbed *embed = SHELL_GTK_EMBED (object);
switch (prop_id)
{
case PROP_WINDOW:
shell_gtk_embed_set_window (embed, (ShellEmbeddedWindow *)g_value_get_object (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
shell_gtk_embed_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
ShellGtkEmbed *embed = SHELL_GTK_EMBED (object);
shell: Use G_DECLARE_*_TYPE macros Cut down on boilerplate by using the (no longer that) new helper macros. We don't care about breaking ABI in private libraries, so use G_DECLARE_FINAL_TYPE even where the class struct used to be exposed in the header, except for types we inherit from ourselves (obviously) or where the class exposes any vfuncs (where changes could affect inheritance in extensions).
2015-09-24 14:07:44 -04:00
ShellGtkEmbedPrivate *priv = shell_gtk_embed_get_instance_private (embed);
Add size negotiation to the tray icons * Rename ShellGtkWindowActor to ShellGtkEmbed, and make it require a ShellEmbeddedWindow rather than a general GtkWindow. * Add ShellEmbeddedWindow subclass of GtkWindow that bypasses most of the GtkWindow complexity for size negotiation, and calls out to a clutter actor instead; also automatically handle reparenting the GtkWindow into the stage window. * Use the reworked ShellGtkEmbed in ShellTrayManager, this simplifies the code a bit, and more importantly results in the tray icons having the correct size negotiation, rather than having a fixed 24x24 size. http://bugzilla.gnome.org/show_bug.cgi?id=580047
2009-05-03 13:05:15 -04:00
switch (prop_id)
{
case PROP_WINDOW:
shell: Use G_DECLARE_*_TYPE macros Cut down on boilerplate by using the (no longer that) new helper macros. We don't care about breaking ABI in private libraries, so use G_DECLARE_FINAL_TYPE even where the class struct used to be exposed in the header, except for types we inherit from ourselves (obviously) or where the class exposes any vfuncs (where changes could affect inheritance in extensions).
2015-09-24 14:07:44 -04:00
g_value_set_object (value, priv->window);
Add size negotiation to the tray icons * Rename ShellGtkWindowActor to ShellGtkEmbed, and make it require a ShellEmbeddedWindow rather than a general GtkWindow. * Add ShellEmbeddedWindow subclass of GtkWindow that bypasses most of the GtkWindow complexity for size negotiation, and calls out to a clutter actor instead; also automatically handle reparenting the GtkWindow into the stage window. * Use the reworked ShellGtkEmbed in ShellTrayManager, this simplifies the code a bit, and more importantly results in the tray icons having the correct size negotiation, rather than having a fixed 24x24 size. http://bugzilla.gnome.org/show_bug.cgi?id=580047
2009-05-03 13:05:15 -04:00
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
shell_gtk_embed_get_preferred_width (ClutterActor *actor,
Port gnome-shell to the Clutter-1.0 API - clutter_actor_get_transformed_position()/size() return floats - clutter_stage_get_actor_at_pos() takes a pick mode - ClutterTimeline no longer has a concept of frames - ClutterUnit is now replaced by float - cogl_texture_new_from_data() signature changed http://bugzilla.gnome.org/show_bug.cgi?id=585013
2009-06-06 13:07:41 -04:00
float for_height,
float *min_width_p,
float *natural_width_p)
Add size negotiation to the tray icons * Rename ShellGtkWindowActor to ShellGtkEmbed, and make it require a ShellEmbeddedWindow rather than a general GtkWindow. * Add ShellEmbeddedWindow subclass of GtkWindow that bypasses most of the GtkWindow complexity for size negotiation, and calls out to a clutter actor instead; also automatically handle reparenting the GtkWindow into the stage window. * Use the reworked ShellGtkEmbed in ShellTrayManager, this simplifies the code a bit, and more importantly results in the tray icons having the correct size negotiation, rather than having a fixed 24x24 size. http://bugzilla.gnome.org/show_bug.cgi?id=580047
2009-05-03 13:05:15 -04:00
{
ShellGtkEmbed *embed = SHELL_GTK_EMBED (actor);
shell: Use G_DECLARE_*_TYPE macros Cut down on boilerplate by using the (no longer that) new helper macros. We don't care about breaking ABI in private libraries, so use G_DECLARE_FINAL_TYPE even where the class struct used to be exposed in the header, except for types we inherit from ourselves (obviously) or where the class exposes any vfuncs (where changes could affect inheritance in extensions).
2015-09-24 14:07:44 -04:00
ShellGtkEmbedPrivate *priv = shell_gtk_embed_get_instance_private (embed);
Add size negotiation to the tray icons * Rename ShellGtkWindowActor to ShellGtkEmbed, and make it require a ShellEmbeddedWindow rather than a general GtkWindow. * Add ShellEmbeddedWindow subclass of GtkWindow that bypasses most of the GtkWindow complexity for size negotiation, and calls out to a clutter actor instead; also automatically handle reparenting the GtkWindow into the stage window. * Use the reworked ShellGtkEmbed in ShellTrayManager, this simplifies the code a bit, and more importantly results in the tray icons having the correct size negotiation, rather than having a fixed 24x24 size. http://bugzilla.gnome.org/show_bug.cgi?id=580047
2009-05-03 13:05:15 -04:00
shell: Use G_DECLARE_*_TYPE macros Cut down on boilerplate by using the (no longer that) new helper macros. We don't care about breaking ABI in private libraries, so use G_DECLARE_FINAL_TYPE even where the class struct used to be exposed in the header, except for types we inherit from ourselves (obviously) or where the class exposes any vfuncs (where changes could affect inheritance in extensions).
2015-09-24 14:07:44 -04:00
if (priv->window
&& gtk_widget_get_visible (GTK_WIDGET (priv->window)))
Add size negotiation to the tray icons * Rename ShellGtkWindowActor to ShellGtkEmbed, and make it require a ShellEmbeddedWindow rather than a general GtkWindow. * Add ShellEmbeddedWindow subclass of GtkWindow that bypasses most of the GtkWindow complexity for size negotiation, and calls out to a clutter actor instead; also automatically handle reparenting the GtkWindow into the stage window. * Use the reworked ShellGtkEmbed in ShellTrayManager, this simplifies the code a bit, and more importantly results in the tray icons having the correct size negotiation, rather than having a fixed 24x24 size. http://bugzilla.gnome.org/show_bug.cgi?id=580047
2009-05-03 13:05:15 -04:00
{
Replace deprecated gtk_widget_size_request
2011-11-11 03:50:18 -05:00
GtkRequisition min_req, natural_req;
shell: Use G_DECLARE_*_TYPE macros Cut down on boilerplate by using the (no longer that) new helper macros. We don't care about breaking ABI in private libraries, so use G_DECLARE_FINAL_TYPE even where the class struct used to be exposed in the header, except for types we inherit from ourselves (obviously) or where the class exposes any vfuncs (where changes could affect inheritance in extensions).
2015-09-24 14:07:44 -04:00
gtk_widget_get_preferred_size (GTK_WIDGET (priv->window), &min_req, &natural_req);
Add size negotiation to the tray icons * Rename ShellGtkWindowActor to ShellGtkEmbed, and make it require a ShellEmbeddedWindow rather than a general GtkWindow. * Add ShellEmbeddedWindow subclass of GtkWindow that bypasses most of the GtkWindow complexity for size negotiation, and calls out to a clutter actor instead; also automatically handle reparenting the GtkWindow into the stage window. * Use the reworked ShellGtkEmbed in ShellTrayManager, this simplifies the code a bit, and more importantly results in the tray icons having the correct size negotiation, rather than having a fixed 24x24 size. http://bugzilla.gnome.org/show_bug.cgi?id=580047
2009-05-03 13:05:15 -04:00
Replace deprecated gtk_widget_size_request
2011-11-11 03:50:18 -05:00
*min_width_p = min_req.width;
*natural_width_p = natural_req.width;
Add size negotiation to the tray icons * Rename ShellGtkWindowActor to ShellGtkEmbed, and make it require a ShellEmbeddedWindow rather than a general GtkWindow. * Add ShellEmbeddedWindow subclass of GtkWindow that bypasses most of the GtkWindow complexity for size negotiation, and calls out to a clutter actor instead; also automatically handle reparenting the GtkWindow into the stage window. * Use the reworked ShellGtkEmbed in ShellTrayManager, this simplifies the code a bit, and more importantly results in the tray icons having the correct size negotiation, rather than having a fixed 24x24 size. http://bugzilla.gnome.org/show_bug.cgi?id=580047
2009-05-03 13:05:15 -04:00
}
else
*min_width_p = *natural_width_p = 0;
}
static void
shell_gtk_embed_get_preferred_height (ClutterActor *actor,
Port gnome-shell to the Clutter-1.0 API - clutter_actor_get_transformed_position()/size() return floats - clutter_stage_get_actor_at_pos() takes a pick mode - ClutterTimeline no longer has a concept of frames - ClutterUnit is now replaced by float - cogl_texture_new_from_data() signature changed http://bugzilla.gnome.org/show_bug.cgi?id=585013
2009-06-06 13:07:41 -04:00
float for_width,
float *min_height_p,
float *natural_height_p)
Add size negotiation to the tray icons * Rename ShellGtkWindowActor to ShellGtkEmbed, and make it require a ShellEmbeddedWindow rather than a general GtkWindow. * Add ShellEmbeddedWindow subclass of GtkWindow that bypasses most of the GtkWindow complexity for size negotiation, and calls out to a clutter actor instead; also automatically handle reparenting the GtkWindow into the stage window. * Use the reworked ShellGtkEmbed in ShellTrayManager, this simplifies the code a bit, and more importantly results in the tray icons having the correct size negotiation, rather than having a fixed 24x24 size. http://bugzilla.gnome.org/show_bug.cgi?id=580047
2009-05-03 13:05:15 -04:00
{
ShellGtkEmbed *embed = SHELL_GTK_EMBED (actor);
shell: Use G_DECLARE_*_TYPE macros Cut down on boilerplate by using the (no longer that) new helper macros. We don't care about breaking ABI in private libraries, so use G_DECLARE_FINAL_TYPE even where the class struct used to be exposed in the header, except for types we inherit from ourselves (obviously) or where the class exposes any vfuncs (where changes could affect inheritance in extensions).
2015-09-24 14:07:44 -04:00
ShellGtkEmbedPrivate *priv = shell_gtk_embed_get_instance_private (embed);
Add size negotiation to the tray icons * Rename ShellGtkWindowActor to ShellGtkEmbed, and make it require a ShellEmbeddedWindow rather than a general GtkWindow. * Add ShellEmbeddedWindow subclass of GtkWindow that bypasses most of the GtkWindow complexity for size negotiation, and calls out to a clutter actor instead; also automatically handle reparenting the GtkWindow into the stage window. * Use the reworked ShellGtkEmbed in ShellTrayManager, this simplifies the code a bit, and more importantly results in the tray icons having the correct size negotiation, rather than having a fixed 24x24 size. http://bugzilla.gnome.org/show_bug.cgi?id=580047
2009-05-03 13:05:15 -04:00
shell: Use G_DECLARE_*_TYPE macros Cut down on boilerplate by using the (no longer that) new helper macros. We don't care about breaking ABI in private libraries, so use G_DECLARE_FINAL_TYPE even where the class struct used to be exposed in the header, except for types we inherit from ourselves (obviously) or where the class exposes any vfuncs (where changes could affect inheritance in extensions).
2015-09-24 14:07:44 -04:00
if (priv->window
&& gtk_widget_get_visible (GTK_WIDGET (priv->window)))
Add size negotiation to the tray icons * Rename ShellGtkWindowActor to ShellGtkEmbed, and make it require a ShellEmbeddedWindow rather than a general GtkWindow. * Add ShellEmbeddedWindow subclass of GtkWindow that bypasses most of the GtkWindow complexity for size negotiation, and calls out to a clutter actor instead; also automatically handle reparenting the GtkWindow into the stage window. * Use the reworked ShellGtkEmbed in ShellTrayManager, this simplifies the code a bit, and more importantly results in the tray icons having the correct size negotiation, rather than having a fixed 24x24 size. http://bugzilla.gnome.org/show_bug.cgi?id=580047
2009-05-03 13:05:15 -04:00
{
Replace deprecated gtk_widget_size_request
2011-11-11 03:50:18 -05:00
GtkRequisition min_req, natural_req;
shell: Use G_DECLARE_*_TYPE macros Cut down on boilerplate by using the (no longer that) new helper macros. We don't care about breaking ABI in private libraries, so use G_DECLARE_FINAL_TYPE even where the class struct used to be exposed in the header, except for types we inherit from ourselves (obviously) or where the class exposes any vfuncs (where changes could affect inheritance in extensions).
2015-09-24 14:07:44 -04:00
gtk_widget_get_preferred_size (GTK_WIDGET (priv->window), &min_req, &natural_req);
Add size negotiation to the tray icons * Rename ShellGtkWindowActor to ShellGtkEmbed, and make it require a ShellEmbeddedWindow rather than a general GtkWindow. * Add ShellEmbeddedWindow subclass of GtkWindow that bypasses most of the GtkWindow complexity for size negotiation, and calls out to a clutter actor instead; also automatically handle reparenting the GtkWindow into the stage window. * Use the reworked ShellGtkEmbed in ShellTrayManager, this simplifies the code a bit, and more importantly results in the tray icons having the correct size negotiation, rather than having a fixed 24x24 size. http://bugzilla.gnome.org/show_bug.cgi?id=580047
2009-05-03 13:05:15 -04:00
Replace deprecated gtk_widget_size_request
2011-11-11 03:50:18 -05:00
*min_height_p = min_req.height;
*natural_height_p = natural_req.height;
Add size negotiation to the tray icons * Rename ShellGtkWindowActor to ShellGtkEmbed, and make it require a ShellEmbeddedWindow rather than a general GtkWindow. * Add ShellEmbeddedWindow subclass of GtkWindow that bypasses most of the GtkWindow complexity for size negotiation, and calls out to a clutter actor instead; also automatically handle reparenting the GtkWindow into the stage window. * Use the reworked ShellGtkEmbed in ShellTrayManager, this simplifies the code a bit, and more importantly results in the tray icons having the correct size negotiation, rather than having a fixed 24x24 size. http://bugzilla.gnome.org/show_bug.cgi?id=580047
2009-05-03 13:05:15 -04:00
}
else
*min_height_p = *natural_height_p = 0;
}
static void
ShellGtkEmbed: revert to old actor/window position-syncing code Synchronizing the actor and window position on paint resulted in lots of syncing, and also resulted in the window mistakenly being left at 0,0 if the actor wasn't visible when the window first mapped. Revert back to the old way of doing it, by tying into clutter_actor_allocate, which was only failing before because of a bug elsewhere. https://bugzilla.gnome.org/show_bug.cgi?id=635695
2011-01-06 17:07:51 -05:00
shell_gtk_embed_allocate (ClutterActor *actor,
const ClutterActorBox *box,
ClutterAllocationFlags flags)
Add size negotiation to the tray icons * Rename ShellGtkWindowActor to ShellGtkEmbed, and make it require a ShellEmbeddedWindow rather than a general GtkWindow. * Add ShellEmbeddedWindow subclass of GtkWindow that bypasses most of the GtkWindow complexity for size negotiation, and calls out to a clutter actor instead; also automatically handle reparenting the GtkWindow into the stage window. * Use the reworked ShellGtkEmbed in ShellTrayManager, this simplifies the code a bit, and more importantly results in the tray icons having the correct size negotiation, rather than having a fixed 24x24 size. http://bugzilla.gnome.org/show_bug.cgi?id=580047
2009-05-03 13:05:15 -04:00
{
ShellGtkEmbed *embed = SHELL_GTK_EMBED (actor);
shell: Use G_DECLARE_*_TYPE macros Cut down on boilerplate by using the (no longer that) new helper macros. We don't care about breaking ABI in private libraries, so use G_DECLARE_FINAL_TYPE even where the class struct used to be exposed in the header, except for types we inherit from ourselves (obviously) or where the class exposes any vfuncs (where changes could affect inheritance in extensions).
2015-09-24 14:07:44 -04:00
ShellGtkEmbedPrivate *priv = shell_gtk_embed_get_instance_private (embed);
shell: Stop using anchor point Since the removal of the old (pre-3.16) message tray, legacy tray icons are very unlikely to be placed in a container that is animated using the deprecated anchor point. Just assume that the regular stage position is good enough. https://gitlab.gnome.org/GNOME/gnome-shell/merge_requests/572
2019-06-05 10:46:35 -04:00
float wx, wy;
Add size negotiation to the tray icons * Rename ShellGtkWindowActor to ShellGtkEmbed, and make it require a ShellEmbeddedWindow rather than a general GtkWindow. * Add ShellEmbeddedWindow subclass of GtkWindow that bypasses most of the GtkWindow complexity for size negotiation, and calls out to a clutter actor instead; also automatically handle reparenting the GtkWindow into the stage window. * Use the reworked ShellGtkEmbed in ShellTrayManager, this simplifies the code a bit, and more importantly results in the tray icons having the correct size negotiation, rather than having a fixed 24x24 size. http://bugzilla.gnome.org/show_bug.cgi?id=580047
2009-05-03 13:05:15 -04:00
ShellGtkEmbed: revert to old actor/window position-syncing code Synchronizing the actor and window position on paint resulted in lots of syncing, and also resulted in the window mistakenly being left at 0,0 if the actor wasn't visible when the window first mapped. Revert back to the old way of doing it, by tying into clutter_actor_allocate, which was only failing before because of a bug elsewhere. https://bugzilla.gnome.org/show_bug.cgi?id=635695
2011-01-06 17:07:51 -05:00
CLUTTER_ACTOR_CLASS (shell_gtk_embed_parent_class)->
allocate (actor, box, flags);
Add size negotiation to the tray icons * Rename ShellGtkWindowActor to ShellGtkEmbed, and make it require a ShellEmbeddedWindow rather than a general GtkWindow. * Add ShellEmbeddedWindow subclass of GtkWindow that bypasses most of the GtkWindow complexity for size negotiation, and calls out to a clutter actor instead; also automatically handle reparenting the GtkWindow into the stage window. * Use the reworked ShellGtkEmbed in ShellTrayManager, this simplifies the code a bit, and more importantly results in the tray icons having the correct size negotiation, rather than having a fixed 24x24 size. http://bugzilla.gnome.org/show_bug.cgi?id=580047
2009-05-03 13:05:15 -04:00
ShellGtkEmbed: revert to old actor/window position-syncing code Synchronizing the actor and window position on paint resulted in lots of syncing, and also resulted in the window mistakenly being left at 0,0 if the actor wasn't visible when the window first mapped. Revert back to the old way of doing it, by tying into clutter_actor_allocate, which was only failing before because of a bug elsewhere. https://bugzilla.gnome.org/show_bug.cgi?id=635695
2011-01-06 17:07:51 -05:00
/* Find the actor's new coordinates in terms of the stage (which is
* priv->window's parent window.
Add size negotiation to the tray icons * Rename ShellGtkWindowActor to ShellGtkEmbed, and make it require a ShellEmbeddedWindow rather than a general GtkWindow. * Add ShellEmbeddedWindow subclass of GtkWindow that bypasses most of the GtkWindow complexity for size negotiation, and calls out to a clutter actor instead; also automatically handle reparenting the GtkWindow into the stage window. * Use the reworked ShellGtkEmbed in ShellTrayManager, this simplifies the code a bit, and more importantly results in the tray icons having the correct size negotiation, rather than having a fixed 24x24 size. http://bugzilla.gnome.org/show_bug.cgi?id=580047
2009-05-03 13:05:15 -04:00
*/
shell: Stop using anchor point Since the removal of the old (pre-3.16) message tray, legacy tray icons are very unlikely to be placed in a container that is animated using the deprecated anchor point. Just assume that the regular stage position is good enough. https://gitlab.gnome.org/GNOME/gnome-shell/merge_requests/572
2019-06-05 10:46:35 -04:00
clutter_actor_get_transformed_position (actor, &wx, &wy);
Add size negotiation to the tray icons * Rename ShellGtkWindowActor to ShellGtkEmbed, and make it require a ShellEmbeddedWindow rather than a general GtkWindow. * Add ShellEmbeddedWindow subclass of GtkWindow that bypasses most of the GtkWindow complexity for size negotiation, and calls out to a clutter actor instead; also automatically handle reparenting the GtkWindow into the stage window. * Use the reworked ShellGtkEmbed in ShellTrayManager, this simplifies the code a bit, and more importantly results in the tray icons having the correct size negotiation, rather than having a fixed 24x24 size. http://bugzilla.gnome.org/show_bug.cgi?id=580047
2009-05-03 13:05:15 -04:00
shell: Use G_DECLARE_*_TYPE macros Cut down on boilerplate by using the (no longer that) new helper macros. We don't care about breaking ABI in private libraries, so use G_DECLARE_FINAL_TYPE even where the class struct used to be exposed in the header, except for types we inherit from ourselves (obviously) or where the class exposes any vfuncs (where changes could affect inheritance in extensions).
2015-09-24 14:07:44 -04:00
_shell_embedded_window_allocate (priv->window,
Port gnome-shell to the Clutter-1.0 API - clutter_actor_get_transformed_position()/size() return floats - clutter_stage_get_actor_at_pos() takes a pick mode - ClutterTimeline no longer has a concept of frames - ClutterUnit is now replaced by float - cogl_texture_new_from_data() signature changed http://bugzilla.gnome.org/show_bug.cgi?id=585013
2009-06-06 13:07:41 -04:00
(int)(0.5 + wx), (int)(0.5 + wy),
ShellGtkEmbed: revert to old actor/window position-syncing code Synchronizing the actor and window position on paint resulted in lots of syncing, and also resulted in the window mistakenly being left at 0,0 if the actor wasn't visible when the window first mapped. Revert back to the old way of doing it, by tying into clutter_actor_allocate, which was only failing before because of a bug elsewhere. https://bugzilla.gnome.org/show_bug.cgi?id=635695
2011-01-06 17:07:51 -05:00
box->x2 - box->x1,
box->y2 - box->y1);
Add size negotiation to the tray icons * Rename ShellGtkWindowActor to ShellGtkEmbed, and make it require a ShellEmbeddedWindow rather than a general GtkWindow. * Add ShellEmbeddedWindow subclass of GtkWindow that bypasses most of the GtkWindow complexity for size negotiation, and calls out to a clutter actor instead; also automatically handle reparenting the GtkWindow into the stage window. * Use the reworked ShellGtkEmbed in ShellTrayManager, this simplifies the code a bit, and more importantly results in the tray icons having the correct size negotiation, rather than having a fixed 24x24 size. http://bugzilla.gnome.org/show_bug.cgi?id=580047
2009-05-03 13:05:15 -04:00
}
static void
shell-embedded-window: Remove hacks for old and fixed Clutter bug We used to use realize/unrealize instead of map/unmap in ShellEmbeddedWindow because there originally was no map/unmap. The days of this are long gone... https://bugzilla.gnome.org/show_bug.cgi?id=672790
2012-03-25 06:02:17 -04:00
shell_gtk_embed_map (ClutterActor *actor)
Add size negotiation to the tray icons * Rename ShellGtkWindowActor to ShellGtkEmbed, and make it require a ShellEmbeddedWindow rather than a general GtkWindow. * Add ShellEmbeddedWindow subclass of GtkWindow that bypasses most of the GtkWindow complexity for size negotiation, and calls out to a clutter actor instead; also automatically handle reparenting the GtkWindow into the stage window. * Use the reworked ShellGtkEmbed in ShellTrayManager, this simplifies the code a bit, and more importantly results in the tray icons having the correct size negotiation, rather than having a fixed 24x24 size. http://bugzilla.gnome.org/show_bug.cgi?id=580047
2009-05-03 13:05:15 -04:00
{
ShellGtkEmbed *embed = SHELL_GTK_EMBED (actor);
shell: Use G_DECLARE_*_TYPE macros Cut down on boilerplate by using the (no longer that) new helper macros. We don't care about breaking ABI in private libraries, so use G_DECLARE_FINAL_TYPE even where the class struct used to be exposed in the header, except for types we inherit from ourselves (obviously) or where the class exposes any vfuncs (where changes could affect inheritance in extensions).
2015-09-24 14:07:44 -04:00
ShellGtkEmbedPrivate *priv = shell_gtk_embed_get_instance_private (embed);
Add size negotiation to the tray icons * Rename ShellGtkWindowActor to ShellGtkEmbed, and make it require a ShellEmbeddedWindow rather than a general GtkWindow. * Add ShellEmbeddedWindow subclass of GtkWindow that bypasses most of the GtkWindow complexity for size negotiation, and calls out to a clutter actor instead; also automatically handle reparenting the GtkWindow into the stage window. * Use the reworked ShellGtkEmbed in ShellTrayManager, this simplifies the code a bit, and more importantly results in the tray icons having the correct size negotiation, rather than having a fixed 24x24 size. http://bugzilla.gnome.org/show_bug.cgi?id=580047
2009-05-03 13:05:15 -04:00
shell: Use G_DECLARE_*_TYPE macros Cut down on boilerplate by using the (no longer that) new helper macros. We don't care about breaking ABI in private libraries, so use G_DECLARE_FINAL_TYPE even where the class struct used to be exposed in the header, except for types we inherit from ourselves (obviously) or where the class exposes any vfuncs (where changes could affect inheritance in extensions).
2015-09-24 14:07:44 -04:00
_shell_embedded_window_map (priv->window);
Add size negotiation to the tray icons * Rename ShellGtkWindowActor to ShellGtkEmbed, and make it require a ShellEmbeddedWindow rather than a general GtkWindow. * Add ShellEmbeddedWindow subclass of GtkWindow that bypasses most of the GtkWindow complexity for size negotiation, and calls out to a clutter actor instead; also automatically handle reparenting the GtkWindow into the stage window. * Use the reworked ShellGtkEmbed in ShellTrayManager, this simplifies the code a bit, and more importantly results in the tray icons having the correct size negotiation, rather than having a fixed 24x24 size. http://bugzilla.gnome.org/show_bug.cgi?id=580047
2009-05-03 13:05:15 -04:00
shell-embedded-window: Remove hacks for old and fixed Clutter bug We used to use realize/unrealize instead of map/unmap in ShellEmbeddedWindow because there originally was no map/unmap. The days of this are long gone... https://bugzilla.gnome.org/show_bug.cgi?id=672790
2012-03-25 06:02:17 -04:00
CLUTTER_ACTOR_CLASS (shell_gtk_embed_parent_class)->map (actor);
Add size negotiation to the tray icons * Rename ShellGtkWindowActor to ShellGtkEmbed, and make it require a ShellEmbeddedWindow rather than a general GtkWindow. * Add ShellEmbeddedWindow subclass of GtkWindow that bypasses most of the GtkWindow complexity for size negotiation, and calls out to a clutter actor instead; also automatically handle reparenting the GtkWindow into the stage window. * Use the reworked ShellGtkEmbed in ShellTrayManager, this simplifies the code a bit, and more importantly results in the tray icons having the correct size negotiation, rather than having a fixed 24x24 size. http://bugzilla.gnome.org/show_bug.cgi?id=580047
2009-05-03 13:05:15 -04:00
}
static void
shell-embedded-window: Remove hacks for old and fixed Clutter bug We used to use realize/unrealize instead of map/unmap in ShellEmbeddedWindow because there originally was no map/unmap. The days of this are long gone... https://bugzilla.gnome.org/show_bug.cgi?id=672790
2012-03-25 06:02:17 -04:00
shell_gtk_embed_unmap (ClutterActor *actor)
Add size negotiation to the tray icons * Rename ShellGtkWindowActor to ShellGtkEmbed, and make it require a ShellEmbeddedWindow rather than a general GtkWindow. * Add ShellEmbeddedWindow subclass of GtkWindow that bypasses most of the GtkWindow complexity for size negotiation, and calls out to a clutter actor instead; also automatically handle reparenting the GtkWindow into the stage window. * Use the reworked ShellGtkEmbed in ShellTrayManager, this simplifies the code a bit, and more importantly results in the tray icons having the correct size negotiation, rather than having a fixed 24x24 size. http://bugzilla.gnome.org/show_bug.cgi?id=580047
2009-05-03 13:05:15 -04:00
{
ShellGtkEmbed *embed = SHELL_GTK_EMBED (actor);
shell: Use G_DECLARE_*_TYPE macros Cut down on boilerplate by using the (no longer that) new helper macros. We don't care about breaking ABI in private libraries, so use G_DECLARE_FINAL_TYPE even where the class struct used to be exposed in the header, except for types we inherit from ourselves (obviously) or where the class exposes any vfuncs (where changes could affect inheritance in extensions).
2015-09-24 14:07:44 -04:00
ShellGtkEmbedPrivate *priv = shell_gtk_embed_get_instance_private (embed);
Add size negotiation to the tray icons * Rename ShellGtkWindowActor to ShellGtkEmbed, and make it require a ShellEmbeddedWindow rather than a general GtkWindow. * Add ShellEmbeddedWindow subclass of GtkWindow that bypasses most of the GtkWindow complexity for size negotiation, and calls out to a clutter actor instead; also automatically handle reparenting the GtkWindow into the stage window. * Use the reworked ShellGtkEmbed in ShellTrayManager, this simplifies the code a bit, and more importantly results in the tray icons having the correct size negotiation, rather than having a fixed 24x24 size. http://bugzilla.gnome.org/show_bug.cgi?id=580047
2009-05-03 13:05:15 -04:00
shell: Use G_DECLARE_*_TYPE macros Cut down on boilerplate by using the (no longer that) new helper macros. We don't care about breaking ABI in private libraries, so use G_DECLARE_FINAL_TYPE even where the class struct used to be exposed in the header, except for types we inherit from ourselves (obviously) or where the class exposes any vfuncs (where changes could affect inheritance in extensions).
2015-09-24 14:07:44 -04:00
_shell_embedded_window_unmap (priv->window);
Add size negotiation to the tray icons * Rename ShellGtkWindowActor to ShellGtkEmbed, and make it require a ShellEmbeddedWindow rather than a general GtkWindow. * Add ShellEmbeddedWindow subclass of GtkWindow that bypasses most of the GtkWindow complexity for size negotiation, and calls out to a clutter actor instead; also automatically handle reparenting the GtkWindow into the stage window. * Use the reworked ShellGtkEmbed in ShellTrayManager, this simplifies the code a bit, and more importantly results in the tray icons having the correct size negotiation, rather than having a fixed 24x24 size. http://bugzilla.gnome.org/show_bug.cgi?id=580047
2009-05-03 13:05:15 -04:00
shell-embedded-window: Remove hacks for old and fixed Clutter bug We used to use realize/unrealize instead of map/unmap in ShellEmbeddedWindow because there originally was no map/unmap. The days of this are long gone... https://bugzilla.gnome.org/show_bug.cgi?id=672790
2012-03-25 06:02:17 -04:00
CLUTTER_ACTOR_CLASS (shell_gtk_embed_parent_class)->unmap (actor);
Add size negotiation to the tray icons * Rename ShellGtkWindowActor to ShellGtkEmbed, and make it require a ShellEmbeddedWindow rather than a general GtkWindow. * Add ShellEmbeddedWindow subclass of GtkWindow that bypasses most of the GtkWindow complexity for size negotiation, and calls out to a clutter actor instead; also automatically handle reparenting the GtkWindow into the stage window. * Use the reworked ShellGtkEmbed in ShellTrayManager, this simplifies the code a bit, and more importantly results in the tray icons having the correct size negotiation, rather than having a fixed 24x24 size. http://bugzilla.gnome.org/show_bug.cgi?id=580047
2009-05-03 13:05:15 -04:00
}
static void
shell_gtk_embed_dispose (GObject *object)
{
ShellGtkEmbed *embed = SHELL_GTK_EMBED (object);
G_OBJECT_CLASS (shell_gtk_embed_parent_class)->dispose (object);
shell-gtk-embed: Fix NULL pointer dereference Clutter will try to unmap during a dispose if we have a parent, so if we set our own actor to NULL before the chain up, we're going to attempt to unmap our own NULL actor. Fix that by swapping the order in which we chain up. https://bugzilla.gnome.org/show_bug.cgi?id=672790
2012-03-25 06:07:15 -04:00
shell_gtk_embed_set_window (embed, NULL);
Add size negotiation to the tray icons * Rename ShellGtkWindowActor to ShellGtkEmbed, and make it require a ShellEmbeddedWindow rather than a general GtkWindow. * Add ShellEmbeddedWindow subclass of GtkWindow that bypasses most of the GtkWindow complexity for size negotiation, and calls out to a clutter actor instead; also automatically handle reparenting the GtkWindow into the stage window. * Use the reworked ShellGtkEmbed in ShellTrayManager, this simplifies the code a bit, and more importantly results in the tray icons having the correct size negotiation, rather than having a fixed 24x24 size. http://bugzilla.gnome.org/show_bug.cgi?id=580047
2009-05-03 13:05:15 -04:00
}
static void
shell_gtk_embed_class_init (ShellGtkEmbedClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
ClutterActorClass *actor_class = CLUTTER_ACTOR_CLASS (klass);
object_class->get_property = shell_gtk_embed_get_property;
object_class->set_property = shell_gtk_embed_set_property;
object_class->dispose = shell_gtk_embed_dispose;
actor_class->get_preferred_width = shell_gtk_embed_get_preferred_width;
actor_class->get_preferred_height = shell_gtk_embed_get_preferred_height;
ShellGtkEmbed: revert to old actor/window position-syncing code Synchronizing the actor and window position on paint resulted in lots of syncing, and also resulted in the window mistakenly being left at 0,0 if the actor wasn't visible when the window first mapped. Revert back to the old way of doing it, by tying into clutter_actor_allocate, which was only failing before because of a bug elsewhere. https://bugzilla.gnome.org/show_bug.cgi?id=635695
2011-01-06 17:07:51 -05:00
actor_class->allocate = shell_gtk_embed_allocate;
shell-embedded-window: Remove hacks for old and fixed Clutter bug We used to use realize/unrealize instead of map/unmap in ShellEmbeddedWindow because there originally was no map/unmap. The days of this are long gone... https://bugzilla.gnome.org/show_bug.cgi?id=672790
2012-03-25 06:02:17 -04:00
actor_class->map = shell_gtk_embed_map;
actor_class->unmap = shell_gtk_embed_unmap;
Add size negotiation to the tray icons * Rename ShellGtkWindowActor to ShellGtkEmbed, and make it require a ShellEmbeddedWindow rather than a general GtkWindow. * Add ShellEmbeddedWindow subclass of GtkWindow that bypasses most of the GtkWindow complexity for size negotiation, and calls out to a clutter actor instead; also automatically handle reparenting the GtkWindow into the stage window. * Use the reworked ShellGtkEmbed in ShellTrayManager, this simplifies the code a bit, and more importantly results in the tray icons having the correct size negotiation, rather than having a fixed 24x24 size. http://bugzilla.gnome.org/show_bug.cgi?id=580047
2009-05-03 13:05:15 -04:00
g_object_class_install_property (object_class,
PROP_WINDOW,
g_param_spec_object ("window",
"Window",
"ShellEmbeddedWindow to embed",
SHELL_TYPE_EMBEDDED_WINDOW,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
}
static void
shell_gtk_embed_init (ShellGtkEmbed *embed)
{
}
/*
* Public API
*/
ClutterActor *
shell_gtk_embed_new (ShellEmbeddedWindow *window)
{
g_return_val_if_fail (SHELL_IS_EMBEDDED_WINDOW (window), NULL);
return g_object_new (SHELL_TYPE_GTK_EMBED,
"window", window,
NULL);
}
Reference in New Issue Copy Permalink