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; }