static void
update_focus_app (ShellWindowTracker *self)
{
MetaWindow *new_focus_win;
ShellApp *new_focus_app;
new_focus_win = meta_display_get_focus_window (shell_global_get_display (shell_global_get ()));
/* we only consider an app focused if the focus window can be clearly
* associated with a running app; this is the case if the focus window
* or one of its parents is visible in the taskbar, e.g.
* - 'nautilus' should appear focused when its about dialog has focus
* - 'nautilus' should not appear focused when the DESKTOP has focus
*/
while (new_focus_win && meta_window_is_skip_taskbar (new_focus_win))
new_focus_win = meta_window_get_transient_for (new_focus_win);
new_focus_app = new_focus_win ? shell_window_tracker_get_window_app (self, new_focus_win) : NULL;
if (new_focus_app)
{
shell_app_update_window_actions (new_focus_app, new_focus_win);
shell_app_update_app_menu (new_focus_app, new_focus_win);
}
set_focus_app (self, new_focus_app);
}
/**
* shell_window_tracker_get_window_app
* @monitor: An app monitor instance
* @metawin: A #MetaWindow
*
* Returns: (transfer full): Application associated with window
*/
ShellApp *
shell_window_tracker_get_window_app (ShellWindowTracker *monitor,
MetaWindow *metawin)
{
MetaWindow *transient_for;
ShellApp *app;
transient_for = meta_window_get_transient_for (metawin);
if (transient_for != NULL)
metawin = transient_for;
app = g_hash_table_lookup (monitor->window_to_app, metawin);
if (app)
g_object_ref (app);
return app;
}
/**
* cinnamon_window_tracker_get_window_app:
* @tracker: An app monitor instance
* @metawin: A #MetaWindow
*
* Returns: (transfer full): Application associated with window
*/
CinnamonApp *
cinnamon_window_tracker_get_window_app (CinnamonWindowTracker *tracker,
MetaWindow *metawin)
{
MetaWindow *transient_for;
CinnamonApp *app;
transient_for = meta_window_get_transient_for (metawin);
if (transient_for != NULL)
metawin = transient_for;
app = g_hash_table_lookup (tracker->window_to_app, metawin);
if (app)
g_object_ref (app);
return app;
}
static MetaWindow*
get_default_focus_window (MetaStack *stack,
MetaWorkspace *workspace,
MetaWindow *not_this_one,
gboolean must_be_at_point,
int root_x,
int root_y)
{
/* Find the topmost, focusable, mapped, window.
* not_this_one is being unfocused or going away, so exclude it.
* Also, prefer to focus transient parent of not_this_one,
* or top window in same group as not_this_one.
*/
MetaWindow *transient_parent;
MetaWindow *topmost_in_group;
MetaWindow *topmost_overall;
MetaGroup *not_this_one_group;
GList *l;
transient_parent = NULL;
topmost_in_group = NULL;
topmost_overall = NULL;
if (not_this_one)
not_this_one_group = meta_window_get_group (not_this_one);
else
not_this_one_group = NULL;
stack_ensure_sorted (stack);
/* top of this layer is at the front of the list */
for (l = stack->sorted; l != NULL; l = l->next)
{
MetaWindow *window = l->data;
if (!window)
continue;
if (window == not_this_one)
continue;
if (window->unmaps_pending > 0)
continue;
if (window->minimized)
continue;
if (window->unmanaging)
continue;
if (!(window->input || window->take_focus))
continue;
if (workspace != NULL && !meta_window_located_on_workspace (window, workspace))
continue;
if (must_be_at_point && !window_contains_point (window, root_x, root_y))
continue;
if (not_this_one != NULL)
{
if (transient_parent == NULL &&
meta_window_get_transient_for (not_this_one) == window)
transient_parent = window;
if (topmost_in_group == NULL &&
not_this_one_group != NULL &&
not_this_one_group == meta_window_get_group (window))
topmost_in_group = window;
}
if (topmost_overall == NULL && window->type != META_WINDOW_DOCK)
topmost_overall = window;
/* We could try to bail out early here for efficiency in
* some cases, but it's just not worth the code.
*/
}
if (transient_parent)
return transient_parent;
else if (topmost_in_group)
return topmost_in_group;
else if (topmost_overall)
return topmost_overall;
else
return NULL;
}
void
meta_window_place (MetaWindow *window,
int x,
int y,
int *new_x,
int *new_y)
{
GList *windows = NULL;
const MetaMonitorInfo *xi;
meta_topic (META_DEBUG_PLACEMENT, "Placing window %s\n", window->desc);
switch (window->type)
{
/* Run placement algorithm on these. */
case META_WINDOW_NORMAL:
case META_WINDOW_DIALOG:
case META_WINDOW_MODAL_DIALOG:
case META_WINDOW_SPLASHSCREEN:
break;
/* Assume the app knows best how to place these, no placement
* algorithm ever (other than "leave them as-is")
*/
case META_WINDOW_DESKTOP:
case META_WINDOW_DOCK:
case META_WINDOW_TOOLBAR:
case META_WINDOW_MENU:
case META_WINDOW_UTILITY:
/* override redirect window types: */
case META_WINDOW_DROPDOWN_MENU:
case META_WINDOW_POPUP_MENU:
case META_WINDOW_TOOLTIP:
case META_WINDOW_NOTIFICATION:
case META_WINDOW_COMBO:
case META_WINDOW_DND:
case META_WINDOW_OVERRIDE_OTHER:
goto done;
}
if (meta_prefs_get_disable_workarounds ())
{
switch (window->type)
{
/* Only accept USPosition on normal windows because the app is full
* of shit claiming the user set -geometry for a dialog or dock
*/
case META_WINDOW_NORMAL:
if (window->size_hints.flags & USPosition)
{
/* don't constrain with placement algorithm */
meta_topic (META_DEBUG_PLACEMENT,
"Honoring USPosition for %s instead of using placement algorithm\n", window->desc);
goto done;
}
break;
/* Ignore even USPosition on dialogs, splashscreen */
case META_WINDOW_DIALOG:
case META_WINDOW_MODAL_DIALOG:
case META_WINDOW_SPLASHSCREEN:
break;
/* Assume the app knows best how to place these. */
case META_WINDOW_DESKTOP:
case META_WINDOW_DOCK:
case META_WINDOW_TOOLBAR:
case META_WINDOW_MENU:
case META_WINDOW_UTILITY:
/* override redirect window types: */
case META_WINDOW_DROPDOWN_MENU:
case META_WINDOW_POPUP_MENU:
case META_WINDOW_TOOLTIP:
case META_WINDOW_NOTIFICATION:
case META_WINDOW_COMBO:
case META_WINDOW_DND:
case META_WINDOW_OVERRIDE_OTHER:
if (window->size_hints.flags & PPosition)
{
meta_topic (META_DEBUG_PLACEMENT,
"Not placing non-normal non-dialog window with PPosition set\n");
goto done;
}
break;
}
}
else
{
/* workarounds enabled */
if ((window->size_hints.flags & PPosition) ||
(window->size_hints.flags & USPosition))
{
meta_topic (META_DEBUG_PLACEMENT,
"Not placing window with PPosition or USPosition set\n");
avoid_being_obscured_as_second_modal_dialog (window, &x, &y);
goto done;
}
}
if (window->type == META_WINDOW_DIALOG ||
window->type == META_WINDOW_MODAL_DIALOG)
{
MetaWindow *parent = meta_window_get_transient_for (window);
if (parent)
{
MetaRectangle frame_rect, parent_frame_rect;
meta_window_get_frame_rect (window, &frame_rect);
meta_window_get_frame_rect (parent, &parent_frame_rect);
y = parent_frame_rect.y;
/* center of parent */
x = parent_frame_rect.x + parent_frame_rect.width / 2;
/* center of child over center of parent */
x -= frame_rect.width / 2;
/* "visually" center window over parent, leaving twice as
* much space below as on top.
*/
y += (parent_frame_rect.height - frame_rect.height)/3;
meta_topic (META_DEBUG_PLACEMENT, "Centered window %s over transient parent\n",
window->desc);
avoid_being_obscured_as_second_modal_dialog (window, &x, &y);
goto done;
}
}
/* FIXME UTILITY with transient set should be stacked up
* on the sides of the parent window or something.
*/
if (window_place_centered (window))
{
/* Center on current monitor */
int w, h;
MetaRectangle frame_rect;
meta_window_get_frame_rect (window, &frame_rect);
/* Warning, this function is a round trip! */
xi = meta_screen_get_current_monitor_info (window->screen);
w = xi->rect.width;
h = xi->rect.height;
x = (w - frame_rect.width) / 2;
y = (h - frame_rect.height) / 2;
x += xi->rect.x;
y += xi->rect.y;
meta_topic (META_DEBUG_PLACEMENT, "Centered window %s on screen %d monitor %d\n",
window->desc, window->screen->number, xi->number);
goto done_check_denied_focus;
}
/* Find windows that matter (not minimized, on same workspace
* as placed window, may be shaded - if shaded we pretend it isn't
* for placement purposes)
*/
{
GSList *all_windows;
GSList *tmp;
all_windows = meta_display_list_windows (window->display, META_LIST_DEFAULT);
tmp = all_windows;
while (tmp != NULL)
{
MetaWindow *w = tmp->data;
if (w != window &&
meta_window_showing_on_its_workspace (w) &&
meta_window_located_on_workspace (w, window->workspace))
windows = g_list_prepend (windows, w);
tmp = tmp->next;
}
g_slist_free (all_windows);
}
/* Warning, this is a round trip! */
xi = meta_screen_get_current_monitor_info (window->screen);
/* Maximize windows if they are too big for their work area (bit of
* a hack here). Assume undecorated windows probably don't intend to
* be maximized.
*/
if (window->has_maximize_func && window->decorated &&
!window->fullscreen)
{
MetaRectangle workarea;
MetaRectangle frame_rect;
meta_window_get_work_area_for_monitor (window,
xi->number,
&workarea);
meta_window_get_frame_rect (window, &frame_rect);
/* If the window is bigger than the screen, then automaximize. Do NOT
* auto-maximize the directions independently. See #419810.
*/
if (frame_rect.width >= workarea.width && frame_rect.height >= workarea.height)
{
window->maximize_horizontally_after_placement = TRUE;
window->maximize_vertically_after_placement = TRUE;
}
}
/* "Origin" placement algorithm */
x = xi->rect.x;
y = xi->rect.y;
if (find_first_fit (window, windows,
xi->number,
x, y, &x, &y))
goto done_check_denied_focus;
/* No good fit? Fall back to cascading... */
find_next_cascade (window, windows, x, y, &x, &y);
done_check_denied_focus:
/* If the window is being denied focus and isn't a transient of the
* focus window, we do NOT want it to overlap with the focus window
* if at all possible. This is guaranteed to only be called if the
* focus_window is non-NULL, and we try to avoid that window.
*/
if (window->denied_focus_and_not_transient)
{
MetaWindow *focus_window;
gboolean found_fit;
focus_window = window->display->focus_window;
g_assert (focus_window != NULL);
/* No need to do anything if the window doesn't overlap at all */
found_fit = !window_overlaps_focus_window (window);
/* Try to do a first fit again, this time only taking into account the
* focus window.
*/
if (!found_fit)
{
GList *focus_window_list;
focus_window_list = g_list_prepend (NULL, focus_window);
/* Reset x and y ("origin" placement algorithm) */
x = xi->rect.x;
y = xi->rect.y;
found_fit = find_first_fit (window, focus_window_list,
xi->number,
x, y, &x, &y);
g_list_free (focus_window_list);
}
/* If that still didn't work, just place it where we can see as much
* as possible.
*/
if (!found_fit)
find_most_freespace (window, focus_window, x, y, &x, &y);
}
done:
if (windows)
g_list_free (windows);
*new_x = x;
*new_y = y;
}
void
meta_core_get (Display *xdisplay,
Window xwindow,
...)
{
va_list args;
MetaCoreGetType request;
MetaDisplay *display = meta_display_for_x_display (xdisplay);
MetaWindow *window = meta_display_lookup_x_window (display, xwindow);
va_start (args, xwindow);
request = va_arg (args, MetaCoreGetType);
/* Now, we special-case the first request slightly. Mostly, requests
* for information on windows which have no frame are errors.
* But sometimes we may want to know *whether* a window has a frame.
* In this case, pass the key META_CORE_WINDOW_HAS_FRAME
* as the *first* request, with a pointer to a boolean; if the window
* has no frame, this will be set to False and meta_core_get will
* exit immediately (so the values of any other requests will be
* undefined). Otherwise it will be set to True and meta_core_get will
* continue happily on its way.
*/
if (request != META_CORE_WINDOW_HAS_FRAME &&
(window == NULL || window->frame == NULL)) {
meta_bug ("No such frame window 0x%lx!\n", xwindow);
goto out;
}
while (request != META_CORE_GET_END) {
gpointer answer = va_arg (args, gpointer);
switch (request) {
case META_CORE_WINDOW_HAS_FRAME:
*((gboolean*)answer) = window != NULL && window->frame != NULL;
if (!*((gboolean*)answer)) goto out; /* see above */
break;
case META_CORE_GET_CLIENT_WIDTH:
*((gint*)answer) = window->rect.width;
break;
case META_CORE_GET_CLIENT_HEIGHT:
*((gint*)answer) = window->rect.height;
break;
case META_CORE_IS_TITLEBAR_ONSCREEN:
*((gboolean*)answer) = meta_window_titlebar_is_onscreen (window);
break;
case META_CORE_GET_CLIENT_XWINDOW:
*((Window*)answer) = window->xwindow;
break;
case META_CORE_GET_FRAME_FLAGS:
*((MetaFrameFlags*)answer) = meta_frame_get_flags (window->frame);
break;
case META_CORE_GET_FRAME_TYPE:
{
MetaFrameType base_type = META_FRAME_TYPE_LAST;
switch (window->type)
{
case META_WINDOW_NORMAL:
base_type = META_FRAME_TYPE_NORMAL;
break;
case META_WINDOW_DIALOG:
base_type = META_FRAME_TYPE_DIALOG;
break;
case META_WINDOW_MODAL_DIALOG:
if (meta_prefs_get_attach_modal_dialogs () &&
meta_window_get_transient_for (window) != NULL)
base_type = META_FRAME_TYPE_ATTACHED;
else
base_type = META_FRAME_TYPE_MODAL_DIALOG;
break;
case META_WINDOW_MENU:
base_type = META_FRAME_TYPE_MENU;
break;
case META_WINDOW_UTILITY:
base_type = META_FRAME_TYPE_UTILITY;
break;
case META_WINDOW_DESKTOP:
case META_WINDOW_DOCK:
case META_WINDOW_TOOLBAR:
case META_WINDOW_SPLASHSCREEN:
/* No frame */
base_type = META_FRAME_TYPE_LAST;
break;
}
if (base_type == META_FRAME_TYPE_LAST)
{
/* can't add border if undecorated */
*((MetaFrameType*)answer) = META_FRAME_TYPE_LAST;
}
else if (window->border_only && base_type != META_FRAME_TYPE_ATTACHED)
{
/* override base frame type */
*((MetaFrameType*)answer) = META_FRAME_TYPE_BORDER;
}
else
{
*((MetaFrameType*)answer) = base_type;
}
break;
}
case META_CORE_GET_MINI_ICON:
*((GdkPixbuf**)answer) = window->mini_icon;
break;
case META_CORE_GET_ICON:
*((GdkPixbuf**)answer) = window->icon;
break;
case META_CORE_GET_X:
meta_window_get_position (window, (int*)answer, NULL);
break;
case META_CORE_GET_Y:
meta_window_get_position (window, NULL, (int*)answer);
break;
case META_CORE_GET_FRAME_WORKSPACE:
*((gint*)answer) = meta_window_get_net_wm_desktop (window);
break;
case META_CORE_GET_FRAME_X:
*((gint*)answer) = window->frame->rect.x;
break;
case META_CORE_GET_FRAME_Y:
*((gint*)answer) = window->frame->rect.y;
break;
case META_CORE_GET_FRAME_WIDTH:
*((gint*)answer) = window->frame->rect.width;
break;
case META_CORE_GET_FRAME_HEIGHT:
*((gint*)answer) = window->frame->rect.height;
break;
case META_CORE_GET_THEME_VARIANT:
*((char**)answer) = window->gtk_theme_variant;
break;
case META_CORE_GET_SCREEN_WIDTH:
*((gint*)answer) = window->screen->rect.width;
break;
case META_CORE_GET_SCREEN_HEIGHT:
*((gint*)answer) = window->screen->rect.height;
break;
default:
meta_warning(_("Unknown window information request: %d"), request);
}
request = va_arg (args, MetaCoreGetType);
}
out:
va_end (args);
}
/**
* get_app_for_window:
*
* Determines the application associated with a window, using
* all available information such as the window's MetaGroup,
* and what we know about other windows.
*
* Returns: (transfer full): a #ShellApp, or NULL if none is found
*/
static ShellApp *
get_app_for_window (ShellWindowTracker *tracker,
MetaWindow *window)
{
ShellApp *result = NULL;
MetaWindow *transient_for;
const char *startup_id;
transient_for = meta_window_get_transient_for (window);
if (transient_for != NULL)
return get_app_for_window (tracker, transient_for);
/* First, we check whether we already know about this window,
* if so, just return that.
*/
if (meta_window_get_window_type (window) == META_WINDOW_NORMAL
|| meta_window_is_remote (window))
{
result = g_hash_table_lookup (tracker->window_to_app, window);
if (result != NULL)
{
g_object_ref (result);
return result;
}
}
if (meta_window_is_remote (window))
return _shell_app_new_for_window (window);
/* Check if the window has a GApplication ID attached; this is
* canonical if it does
*/
result = get_app_from_gapplication_id (window);
if (result != NULL)
return result;
/* Check if the app's WM_CLASS specifies an app; this is
* canonical if it does.
*/
result = get_app_from_window_wmclass (window);
if (result != NULL)
return result;
result = get_app_from_window_pid (tracker, window);
if (result != NULL)
return result;
/* Now we check whether we have a match through startup-notification */
startup_id = meta_window_get_startup_id (window);
if (startup_id)
{
GSList *iter, *sequences;
sequences = shell_window_tracker_get_startup_sequences (tracker);
for (iter = sequences; iter; iter = iter->next)
{
ShellStartupSequence *sequence = iter->data;
const char *id = shell_startup_sequence_get_id (sequence);
if (strcmp (id, startup_id) != 0)
continue;
result = shell_startup_sequence_get_app (sequence);
if (result)
{
result = g_object_ref (result);
break;
}
}
}
/* If we didn't get a startup-notification match, see if we matched
* any other windows in the group.
*/
if (result == NULL)
result = get_app_from_window_group (tracker, window);
/* Our last resort - we create a fake app from the window */
if (result == NULL)
result = _shell_app_new_for_window (window);
return result;
}
