From 68f261e8e22d94236866b92d7d21d55c68de41da Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Armin=20Krezovi=C4=87?= Date: Sat, 26 Aug 2017 21:10:38 +0200 Subject: Move rest of non-X11 specific objects from MetaScreen This moves following objects from MetaScreen to MetaDisplay - workareas_later and in_fullscreen_later signals and functions - startup_sequences signals and functions - tile_preview functions https://bugzilla.gnome.org/show_bug.cgi?id=759538 --- src/core/display-private.h | 19 ++ src/core/display.c | 485 +++++++++++++++++++++++++++++++++++++++++++- src/core/keybindings.c | 4 +- src/core/screen-private.h | 19 -- src/core/screen.c | 489 +-------------------------------------------- src/core/stack.c | 2 +- src/core/window.c | 49 +++-- src/core/workspace.c | 2 +- src/meta/display.h | 2 + src/meta/screen.h | 2 - src/x11/window-props.c | 2 +- src/x11/window-x11.c | 2 +- 12 files changed, 534 insertions(+), 543 deletions(-) diff --git a/src/core/display-private.h b/src/core/display-private.h index 14fee983a..4240f21c7 100644 --- a/src/core/display-private.h +++ b/src/core/display-private.h @@ -237,6 +237,14 @@ struct _MetaDisplay MetaStack *stack; MetaStackTracker *stack_tracker; + + guint tile_preview_timeout_id; + guint preview_tile_mode : 2; + + GSList *startup_sequences; + + guint work_area_later; + guint check_fullscreen_later; }; struct _MetaDisplayClass @@ -412,4 +420,15 @@ void meta_display_foreach_window (MetaDisplay *display, void meta_display_restacked (MetaDisplay *display); + +void meta_display_update_tile_preview (MetaDisplay *display, + gboolean delay); +void meta_display_hide_tile_preview (MetaDisplay *display); + +gboolean meta_display_apply_startup_properties (MetaDisplay *display, + MetaWindow *window); + +void meta_display_queue_workarea_recalc (MetaDisplay *display); +void meta_display_queue_check_fullscreen (MetaDisplay *display); + #endif diff --git a/src/core/display.c b/src/core/display.c index 491f36e6a..88881baae 100644 --- a/src/core/display.c +++ b/src/core/display.c @@ -136,8 +136,13 @@ enum SHOW_PAD_OSD, SHOW_OSD, PAD_MODE_SWITCH, + WINDOW_ENTERED_MONITOR, + WINDOW_LEFT_MONITOR, + IN_FULLSCREEN_CHANGED, + STARTUP_SEQUENCE_CHANGED, MONITORS_CHANGED, RESTACKED, + WORKAREAS_CHANGED, LAST_SIGNAL }; @@ -423,6 +428,38 @@ meta_display_class_init (MetaDisplayClass *klass) G_TYPE_NONE, 3, CLUTTER_TYPE_INPUT_DEVICE, G_TYPE_UINT, G_TYPE_UINT); + display_signals[WINDOW_ENTERED_MONITOR] = + g_signal_new ("window-entered-monitor", + G_TYPE_FROM_CLASS (klass), + G_SIGNAL_RUN_LAST, + 0, NULL, NULL, NULL, + G_TYPE_NONE, 2, + G_TYPE_INT, + META_TYPE_WINDOW); + + display_signals[WINDOW_LEFT_MONITOR] = + g_signal_new ("window-left-monitor", + G_TYPE_FROM_CLASS (klass), + G_SIGNAL_RUN_LAST, + 0, NULL, NULL, NULL, + G_TYPE_NONE, 2, + G_TYPE_INT, + META_TYPE_WINDOW); + + display_signals[IN_FULLSCREEN_CHANGED] = + g_signal_new ("in-fullscreen-changed", + G_TYPE_FROM_CLASS (klass), + G_SIGNAL_RUN_LAST, + 0, NULL, NULL, NULL, + G_TYPE_NONE, 0); + + display_signals[STARTUP_SEQUENCE_CHANGED] = + g_signal_new ("startup-sequence-changed", + G_TYPE_FROM_CLASS (klass), + G_SIGNAL_RUN_LAST, + 0, NULL, NULL, NULL, + G_TYPE_NONE, 1, G_TYPE_POINTER); + display_signals[MONITORS_CHANGED] = g_signal_new ("monitors-changed", G_TYPE_FROM_CLASS (klass), @@ -437,6 +474,13 @@ meta_display_class_init (MetaDisplayClass *klass) 0, NULL, NULL, NULL, G_TYPE_NONE, 0); + display_signals[WORKAREAS_CHANGED] = + g_signal_new ("workareas-changed", + G_TYPE_FROM_CLASS (klass), + G_SIGNAL_RUN_LAST, + 0, NULL, NULL, NULL, + G_TYPE_NONE, 0); + g_object_class_install_property (object_class, PROP_FOCUS_WINDOW, g_param_spec_object ("focus-window", @@ -579,13 +623,10 @@ on_startup_notification_changed (MetaStartupNotification *sn, gpointer sequence, MetaDisplay *display) { - if (!display->screen) - return; - - g_slist_free (display->screen->startup_sequences); - display->screen->startup_sequences = + g_slist_free (display->startup_sequences); + display->startup_sequences = meta_startup_notification_get_sequences (display->startup_notification); - g_signal_emit_by_name (display->screen, "startup-sequence-changed", sequence); + g_signal_emit_by_name (display, "startup-sequence-changed", sequence); } /** @@ -626,6 +667,9 @@ meta_display_open (void) display->rect.x = display->rect.y = 0; display->current_cursor = -1; /* invalid/unset */ + display->tile_preview_timeout_id = 0; + display->check_fullscreen_later = 0; + display->work_area_later = 0; display->mouse_mode = TRUE; /* Only relevant for mouse or sloppy focus */ display->allow_terminal_deactivation = TRUE; /* Only relevant for when a @@ -895,6 +939,15 @@ meta_display_close (MetaDisplay *display, g_source_remove (display->focus_timeout_id); display->focus_timeout_id = 0; + if (display->tile_preview_timeout_id) + g_source_remove (display->tile_preview_timeout_id); + display->tile_preview_timeout_id = 0; + + if (display->work_area_later != 0) + meta_later_remove (display->work_area_later); + if (display->check_fullscreen_later != 0) + meta_later_remove (display->check_fullscreen_later); + /* Stop caring about events */ meta_display_free_events (display); @@ -2955,6 +3008,8 @@ on_monitors_changed_internal (MetaMonitorManager *monitor_manager, meta_display_foreach_window (display, META_LIST_DEFAULT, meta_display_resize_func, 0); + meta_display_queue_check_fullscreen (display); + backend = meta_get_backend (); cursor_renderer = meta_backend_get_cursor_renderer (backend); meta_cursor_renderer_force_update (cursor_renderer); @@ -2972,3 +3027,421 @@ meta_display_restacked (MetaDisplay *display) { g_signal_emit (display, display_signals[RESTACKED], 0); } + +static gboolean +meta_display_update_tile_preview_timeout (gpointer data) +{ + MetaDisplay *display = data; + MetaWindow *window = display->grab_window; + gboolean needs_preview = FALSE; + + display->tile_preview_timeout_id = 0; + + if (window) + { + switch (display->preview_tile_mode) + { + case META_TILE_LEFT: + case META_TILE_RIGHT: + if (!META_WINDOW_TILED_SIDE_BY_SIDE (window)) + needs_preview = TRUE; + break; + + case META_TILE_MAXIMIZED: + if (!META_WINDOW_MAXIMIZED (window)) + needs_preview = TRUE; + break; + + default: + needs_preview = FALSE; + break; + } + } + + if (needs_preview) + { + MetaRectangle tile_rect; + int monitor; + + monitor = meta_window_get_current_tile_monitor_number (window); + meta_window_get_tile_area (window, display->preview_tile_mode, + &tile_rect); + meta_compositor_show_tile_preview (display->compositor, + window, &tile_rect, monitor); + } + else + meta_compositor_hide_tile_preview (display->compositor); + + return FALSE; +} + +#define TILE_PREVIEW_TIMEOUT_MS 200 + +void +meta_display_update_tile_preview (MetaDisplay *display, + gboolean delay) +{ + if (delay) + { + if (display->tile_preview_timeout_id > 0) + return; + + display->tile_preview_timeout_id = + g_timeout_add (TILE_PREVIEW_TIMEOUT_MS, + meta_display_update_tile_preview_timeout, + display); + g_source_set_name_by_id (display->tile_preview_timeout_id, + "[mutter] meta_display_update_tile_preview_timeout"); + } + else + { + if (display->tile_preview_timeout_id > 0) + g_source_remove (display->tile_preview_timeout_id); + + meta_display_update_tile_preview_timeout ((gpointer)display); + } +} + +void +meta_display_hide_tile_preview (MetaDisplay *display) +{ + if (display->tile_preview_timeout_id > 0) + g_source_remove (display->tile_preview_timeout_id); + + display->preview_tile_mode = META_TILE_NONE; + meta_compositor_hide_tile_preview (display->compositor); +} + +/** + * meta_display_get_startup_sequences: (skip) + * @display: + * + * Return value: (transfer none): Currently active #SnStartupSequence items + */ +GSList * +meta_display_get_startup_sequences (MetaDisplay *display) +{ + return display->startup_sequences; +} + +/* Sets the initial_timestamp and initial_workspace properties + * of a window according to information given us by the + * startup-notification library. + * + * Returns TRUE if startup properties have been applied, and + * FALSE if they have not (for example, if they had already + * been applied.) + */ +gboolean +meta_display_apply_startup_properties (MetaDisplay *display, + MetaWindow *window) +{ +#ifdef HAVE_STARTUP_NOTIFICATION + const char *startup_id; + GSList *l; + SnStartupSequence *sequence; + + /* Does the window have a startup ID stored? */ + startup_id = meta_window_get_startup_id (window); + + meta_topic (META_DEBUG_STARTUP, + "Applying startup props to %s id \"%s\"\n", + window->desc, + startup_id ? startup_id : "(none)"); + + sequence = NULL; + if (!startup_id) + { + /* No startup ID stored for the window. Let's ask the + * startup-notification library whether there's anything + * stored for the resource name or resource class hints. + */ + for (l = display->startup_sequences; l; l = l->next) + { + const char *wmclass; + SnStartupSequence *seq = l->data; + + wmclass = sn_startup_sequence_get_wmclass (seq); + + if (wmclass != NULL && + ((window->res_class && + strcmp (wmclass, window->res_class) == 0) || + (window->res_name && + strcmp (wmclass, window->res_name) == 0))) + { + sequence = seq; + + g_assert (window->startup_id == NULL); + window->startup_id = g_strdup (sn_startup_sequence_get_id (sequence)); + startup_id = window->startup_id; + + meta_topic (META_DEBUG_STARTUP, + "Ending legacy sequence %s due to window %s\n", + sn_startup_sequence_get_id (sequence), + window->desc); + + sn_startup_sequence_complete (sequence); + break; + } + } + } + + /* Still no startup ID? Bail. */ + if (!startup_id) + return FALSE; + + /* We might get this far and not know the sequence ID (if the window + * already had a startup ID stored), so let's look for one if we don't + * already know it. + */ + if (sequence == NULL) + { + for (l = display->startup_sequences; l != NULL; l = l->next) + { + SnStartupSequence *seq = l->data; + const char *id; + + id = sn_startup_sequence_get_id (seq); + + if (strcmp (id, startup_id) == 0) + { + sequence = seq; + break; + } + } + } + + if (sequence != NULL) + { + gboolean changed_something = FALSE; + + meta_topic (META_DEBUG_STARTUP, + "Found startup sequence for window %s ID \"%s\"\n", + window->desc, startup_id); + + if (!window->initial_workspace_set) + { + int space = sn_startup_sequence_get_workspace (sequence); + if (space >= 0) + { + meta_topic (META_DEBUG_STARTUP, + "Setting initial window workspace to %d based on startup info\n", + space); + + window->initial_workspace_set = TRUE; + window->initial_workspace = space; + changed_something = TRUE; + } + } + + if (!window->initial_timestamp_set) + { + guint32 timestamp = sn_startup_sequence_get_timestamp (sequence); + meta_topic (META_DEBUG_STARTUP, + "Setting initial window timestamp to %u based on startup info\n", + timestamp); + + window->initial_timestamp_set = TRUE; + window->initial_timestamp = timestamp; + changed_something = TRUE; + } + + return changed_something; + } + else + { + meta_topic (META_DEBUG_STARTUP, + "Did not find startup sequence for window %s ID \"%s\"\n", + window->desc, startup_id); + } + +#endif /* HAVE_STARTUP_NOTIFICATION */ + + return FALSE; +} + +static void +set_work_area_hint (MetaDisplay *display) +{ + MetaX11Display *x11_display = display->x11_display; + MetaScreen *screen = display->screen; + int num_workspaces; + GList *l; + unsigned long *data, *tmp; + MetaRectangle area; + + num_workspaces = meta_screen_get_n_workspaces (screen); + data = g_new (unsigned long, num_workspaces * 4); + tmp = data; + + for (l = screen->workspaces; l; l = l->next) + { + MetaWorkspace *workspace = l->data; + + meta_workspace_get_work_area_all_monitors (workspace, &area); + tmp[0] = area.x; + tmp[1] = area.y; + tmp[2] = area.width; + tmp[3] = area.height; + + tmp += 4; + } + + meta_error_trap_push (x11_display); + XChangeProperty (x11_display->xdisplay, + x11_display->xroot, + x11_display->atom__NET_WORKAREA, + XA_CARDINAL, 32, PropModeReplace, + (guchar*) data, num_workspaces*4); + meta_error_trap_pop (x11_display); + + g_free (data); + + g_signal_emit (display, display_signals[WORKAREAS_CHANGED], 0); +} + +static gboolean +set_work_area_later_func (MetaDisplay *display) +{ + meta_topic (META_DEBUG_WORKAREA, + "Running work area hint computation function\n"); + + display->work_area_later = 0; + + set_work_area_hint (display); + + return FALSE; +} + +void +meta_display_queue_workarea_recalc (MetaDisplay *display) +{ + /* Recompute work area later before redrawing */ + if (display->work_area_later == 0) + { + meta_topic (META_DEBUG_WORKAREA, + "Adding work area hint computation function\n"); + display->work_area_later = + meta_later_add (META_LATER_BEFORE_REDRAW, + (GSourceFunc) set_work_area_later_func, + display, + NULL); + } +} + +static gboolean +check_fullscreen_func (gpointer data) +{ + MetaDisplay *display = data; + MetaBackend *backend = meta_get_backend (); + MetaMonitorManager *monitor_manager = + meta_backend_get_monitor_manager (backend); + GList *logical_monitors, *l; + MetaWindow *window; + GSList *fullscreen_monitors = NULL; + GSList *obscured_monitors = NULL; + gboolean in_fullscreen_changed = FALSE; + + display->check_fullscreen_later = 0; + + logical_monitors = + meta_monitor_manager_get_logical_monitors (monitor_manager); + + /* We consider a monitor in fullscreen if it contains a fullscreen window; + * however we make an exception for maximized windows above the fullscreen + * one, as in that case window+chrome fully obscure the fullscreen window. + */ + for (window = meta_stack_get_top (display->stack); + window; + window = meta_stack_get_below (display->stack, window, FALSE)) + { + gboolean covers_monitors = FALSE; + + if (window->hidden) + continue; + + if (window->fullscreen) + { + covers_monitors = TRUE; + } + else if (window->override_redirect) + { + /* We want to handle the case where an application is creating an + * override-redirect window the size of the screen (monitor) and treat + * it similarly to a fullscreen window, though it doesn't have fullscreen + * window management behavior. (Being O-R, it's not managed at all.) + */ + if (meta_window_is_monitor_sized (window)) + covers_monitors = TRUE; + } + else if (window->maximized_horizontally && + window->maximized_vertically) + { + MetaLogicalMonitor *logical_monitor; + + logical_monitor = meta_window_get_main_logical_monitor (window); + if (!g_slist_find (obscured_monitors, logical_monitor)) + obscured_monitors = g_slist_prepend (obscured_monitors, + logical_monitor); + } + + if (covers_monitors) + { + MetaRectangle window_rect; + + meta_window_get_frame_rect (window, &window_rect); + + for (l = logical_monitors; l; l = l->next) + { + MetaLogicalMonitor *logical_monitor = l->data; + + if (meta_rectangle_overlap (&window_rect, + &logical_monitor->rect) && + !g_slist_find (fullscreen_monitors, logical_monitor) && + !g_slist_find (obscured_monitors, logical_monitor)) + fullscreen_monitors = g_slist_prepend (fullscreen_monitors, + logical_monitor); + } + } + } + + g_slist_free (obscured_monitors); + + for (l = logical_monitors; l; l = l->next) + { + MetaLogicalMonitor *logical_monitor = l->data; + gboolean in_fullscreen; + + in_fullscreen = g_slist_find (fullscreen_monitors, + logical_monitor) != NULL; + if (in_fullscreen != logical_monitor->in_fullscreen) + { + logical_monitor->in_fullscreen = in_fullscreen; + in_fullscreen_changed = TRUE; + } + } + + g_slist_free (fullscreen_monitors); + + if (in_fullscreen_changed) + { + /* DOCK window stacking depends on the monitor's fullscreen + status so we need to trigger a re-layering. */ + MetaWindow *window = meta_stack_get_top (display->stack); + if (window) + meta_stack_update_layer (display->stack, window); + + g_signal_emit (display, display_signals[IN_FULLSCREEN_CHANGED], 0, NULL); + } + + return FALSE; +} + +void +meta_display_queue_check_fullscreen (MetaDisplay *display) +{ + if (!display->check_fullscreen_later) + display->check_fullscreen_later = meta_later_add (META_LATER_CHECK_FULLSCREEN, + check_fullscreen_func, + display, NULL); +} diff --git a/src/core/keybindings.c b/src/core/keybindings.c index cfcf5fa55..614a7a9a0 100644 --- a/src/core/keybindings.c +++ b/src/core/keybindings.c @@ -2241,8 +2241,8 @@ process_mouse_move_resize_grab (MetaDisplay *display, MetaTileMode tile_mode; /* Hide the tiling preview if necessary */ - if (screen->preview_tile_mode != META_TILE_NONE) - meta_screen_hide_tile_preview (screen); + if (display->preview_tile_mode != META_TILE_NONE) + meta_display_hide_tile_preview (display); /* Restore the original tile mode */ tile_mode = display->grab_tile_mode; diff --git a/src/core/screen-private.h b/src/core/screen-private.h index 1239d5a58..486bdcd41 100644 --- a/src/core/screen-private.h +++ b/src/core/screen-private.h @@ -47,20 +47,12 @@ struct _MetaScreen MetaDisplay *display; MetaUI *ui; - guint tile_preview_timeout_id; - guint preview_tile_mode : 2; - MetaWorkspace *active_workspace; GList *workspaces; gboolean has_xinerama_indices; - GSList *startup_sequences; - - guint work_area_later; - guint check_fullscreen_later; - int rows_of_workspaces; int columns_of_workspaces; MetaScreenCorner starting_corner; @@ -75,8 +67,6 @@ struct _MetaScreen struct _MetaScreenClass { GObjectClass parent_class; - - void (*workareas_changed) (MetaScreen *); }; MetaScreen* meta_screen_new (MetaDisplay *display, @@ -86,17 +76,11 @@ void meta_screen_free (MetaScreen *scree void meta_screen_init_workspaces (MetaScreen *screen); void meta_screen_manage_all_windows (MetaScreen *screen); -void meta_screen_update_tile_preview (MetaScreen *screen, - gboolean delay); -void meta_screen_hide_tile_preview (MetaScreen *screen); - MetaWindow* meta_screen_get_mouse_window (MetaScreen *screen, MetaWindow *not_this_one); void meta_screen_update_workspace_layout (MetaScreen *screen); void meta_screen_update_workspace_names (MetaScreen *screen); -void meta_screen_queue_workarea_recalc (MetaScreen *screen); -void meta_screen_queue_check_fullscreen (MetaScreen *screen); typedef struct MetaWorkspaceLayout MetaWorkspaceLayout; @@ -127,9 +111,6 @@ void meta_screen_unshow_desktop (MetaScreen *screen); /* Update whether the destkop is being shown for the current active_workspace */ void meta_screen_update_showing_desktop_hint (MetaScreen *screen); -gboolean meta_screen_apply_startup_properties (MetaScreen *screen, - MetaWindow *window); - void meta_screen_workspace_switched (MetaScreen *screen, int from, int to, diff --git a/src/core/screen.c b/src/core/screen.c index 78f275f67..9c16dc14e 100644 --- a/src/core/screen.c +++ b/src/core/screen.c @@ -79,11 +79,6 @@ enum WORKSPACE_ADDED, WORKSPACE_REMOVED, WORKSPACE_SWITCHED, - WINDOW_ENTERED_MONITOR, - WINDOW_LEFT_MONITOR, - STARTUP_SEQUENCE_CHANGED, - WORKAREAS_CHANGED, - IN_FULLSCREEN_CHANGED, LAST_SIGNAL }; @@ -190,50 +185,6 @@ meta_screen_class_init (MetaScreenClass *klass) G_TYPE_INT, META_TYPE_MOTION_DIRECTION); - screen_signals[WINDOW_ENTERED_MONITOR] = - g_signal_new ("window-entered-monitor", - G_TYPE_FROM_CLASS (klass), - G_SIGNAL_RUN_LAST, - 0, - NULL, NULL, NULL, - G_TYPE_NONE, 2, - G_TYPE_INT, - META_TYPE_WINDOW); - - screen_signals[WINDOW_LEFT_MONITOR] = - g_signal_new ("window-left-monitor", - G_TYPE_FROM_CLASS (klass), - G_SIGNAL_RUN_LAST, - 0, - NULL, NULL, NULL, - G_TYPE_NONE, 2, - G_TYPE_INT, - META_TYPE_WINDOW); - - screen_signals[STARTUP_SEQUENCE_CHANGED] = - g_signal_new ("startup-sequence-changed", - G_TYPE_FROM_CLASS (klass), - G_SIGNAL_RUN_LAST, - 0, - NULL, NULL, NULL, - G_TYPE_NONE, 1, G_TYPE_POINTER); - - screen_signals[WORKAREAS_CHANGED] = - g_signal_new ("workareas-changed", - G_TYPE_FROM_CLASS (object_class), - G_SIGNAL_RUN_LAST, - G_STRUCT_OFFSET (MetaScreenClass, workareas_changed), - NULL, NULL, NULL, - G_TYPE_NONE, 0); - - screen_signals[IN_FULLSCREEN_CHANGED] = - g_signal_new ("in-fullscreen-changed", - G_TYPE_FROM_CLASS (object_class), - G_SIGNAL_RUN_LAST, - 0, - NULL, NULL, NULL, - G_TYPE_NONE, 0); - g_object_class_install_property (object_class, PROP_N_WORKSPACES, pspec); @@ -401,9 +352,6 @@ meta_screen_new (MetaDisplay *display, screen->display = display; - screen->work_area_later = 0; - screen->check_fullscreen_later = 0; - screen->active_workspace = NULL; screen->workspaces = NULL; screen->rows_of_workspaces = 1; @@ -425,8 +373,6 @@ meta_screen_new (MetaDisplay *display, screen->ui = meta_ui_new (xdisplay); - screen->tile_preview_timeout_id = 0; - meta_prefs_add_listener (prefs_changed_callback, screen); meta_verbose ("Added screen %d ('%s') root 0x%lx\n", @@ -484,14 +430,6 @@ meta_screen_free (MetaScreen *screen, meta_ui_free (screen->ui); - if (screen->work_area_later != 0) - meta_later_remove (screen->work_area_later); - if (screen->check_fullscreen_later != 0) - meta_later_remove (screen->check_fullscreen_later); - - if (screen->tile_preview_timeout_id) - g_source_remove (screen->tile_preview_timeout_id); - g_object_unref (screen); } @@ -545,7 +483,7 @@ meta_screen_get_workspace_by_index (MetaScreen *screen, static void set_number_of_spaces_hint (MetaScreen *screen, - int n_spaces) + int n_spaces) { MetaX11Display *x11_display = screen->display->x11_display; unsigned long data[1]; @@ -623,7 +561,7 @@ meta_screen_remove_workspace (MetaScreen *screen, MetaWorkspace *workspace, meta_workspace_index_changed (w); } - meta_screen_queue_workarea_recalc (screen); + meta_display_queue_workarea_recalc (screen->display); g_signal_emit (screen, screen_signals[WORKSPACE_REMOVED], 0, index); g_object_notify (G_OBJECT (screen), "n-workspaces"); @@ -665,7 +603,7 @@ meta_screen_append_new_workspace (MetaScreen *screen, gboolean activate, if (!meta_prefs_get_dynamic_workspaces ()) meta_prefs_set_num_workspaces (new_num); - meta_screen_queue_workarea_recalc (screen); + meta_display_queue_workarea_recalc (screen->display); g_signal_emit (screen, screen_signals[WORKSPACE_ADDED], 0, meta_workspace_index (w)); @@ -775,7 +713,7 @@ update_num_workspaces (MetaScreen *screen, set_number_of_spaces_hint (screen, new_num); - meta_screen_queue_workarea_recalc (screen); + meta_display_queue_workarea_recalc (display); for (i = old_num; i < new_num; i++) g_signal_emit (screen, screen_signals[WORKSPACE_ADDED], 0, i); @@ -783,90 +721,6 @@ update_num_workspaces (MetaScreen *screen, g_object_notify (G_OBJECT (screen), "n-workspaces"); } -static gboolean -meta_screen_update_tile_preview_timeout (gpointer data) -{ - MetaScreen *screen = data; - MetaWindow *window = screen->display->grab_window; - gboolean needs_preview = FALSE; - - screen->tile_preview_timeout_id = 0; - - if (window) - { - switch (screen->preview_tile_mode) - { - case META_TILE_LEFT: - case META_TILE_RIGHT: - if (!META_WINDOW_TILED_SIDE_BY_SIDE (window)) - needs_preview = TRUE; - break; - - case META_TILE_MAXIMIZED: - if (!META_WINDOW_MAXIMIZED (window)) - needs_preview = TRUE; - break; - - default: - needs_preview = FALSE; - break; - } - } - - if (needs_preview) - { - MetaRectangle tile_rect; - int monitor; - - monitor = meta_window_get_current_tile_monitor_number (window); - meta_window_get_tile_area (window, screen->preview_tile_mode, &tile_rect); - meta_compositor_show_tile_preview (screen->display->compositor, - window, &tile_rect, monitor); - } - else - meta_compositor_hide_tile_preview (screen->display->compositor); - - return FALSE; -} - -#define TILE_PREVIEW_TIMEOUT_MS 200 - -void -meta_screen_update_tile_preview (MetaScreen *screen, - gboolean delay) -{ - if (delay) - { - if (screen->tile_preview_timeout_id > 0) - return; - - screen->tile_preview_timeout_id = - g_timeout_add (TILE_PREVIEW_TIMEOUT_MS, - meta_screen_update_tile_preview_timeout, - screen); - g_source_set_name_by_id (screen->tile_preview_timeout_id, - "[mutter] meta_screen_update_tile_preview_timeout"); - } - else - { - if (screen->tile_preview_timeout_id > 0) - g_source_remove (screen->tile_preview_timeout_id); - - meta_screen_update_tile_preview_timeout ((gpointer)screen); - } -} - -void -meta_screen_hide_tile_preview (MetaScreen *screen) -{ - if (screen->tile_preview_timeout_id > 0) - g_source_remove (screen->tile_preview_timeout_id); - screen->tile_preview_timeout_id = 0; - - screen->preview_tile_mode = META_TILE_NONE; - meta_compositor_hide_tile_preview (screen->display->compositor); -} - MetaWindow* meta_screen_get_mouse_window (MetaScreen *screen, MetaWindow *not_this_one) @@ -1248,74 +1102,6 @@ meta_screen_update_workspace_names (MetaScreen *screen) g_strfreev (names); } -static void -set_work_area_hint (MetaScreen *screen) -{ - MetaX11Display *x11_display = screen->display->x11_display; - int num_workspaces; - GList *l; - unsigned long *data, *tmp; - MetaRectangle area; - - num_workspaces = meta_screen_get_n_workspaces (screen); - data = g_new (unsigned long, num_workspaces * 4); - tmp = data; - - for (l = screen->workspaces; l != NULL; l = l->next) - { - MetaWorkspace *workspace = l->data; - - meta_workspace_get_work_area_all_monitors (workspace, &area); - tmp[0] = area.x; - tmp[1] = area.y; - tmp[2] = area.width; - tmp[3] = area.height; - - tmp += 4; - } - - meta_error_trap_push (x11_display); - XChangeProperty (x11_display->xdisplay, - x11_display->xroot, - x11_display->atom__NET_WORKAREA, - XA_CARDINAL, 32, PropModeReplace, - (guchar*) data, num_workspaces*4); - g_free (data); - meta_error_trap_pop (x11_display); - - g_signal_emit (screen, screen_signals[WORKAREAS_CHANGED], 0); -} - -static gboolean -set_work_area_later_func (MetaScreen *screen) -{ - meta_topic (META_DEBUG_WORKAREA, - "Running work area hint computation function\n"); - - screen->work_area_later = 0; - - set_work_area_hint (screen); - - return FALSE; -} - -void -meta_screen_queue_workarea_recalc (MetaScreen *screen) -{ - /* Recompute work area later before redrawing */ - if (screen->work_area_later == 0) - { - meta_topic (META_DEBUG_WORKAREA, - "Adding work area hint computation function\n"); - screen->work_area_later = - meta_later_add (META_LATER_BEFORE_REDRAW, - (GSourceFunc) set_work_area_later_func, - screen, - NULL); - } -} - - #ifdef WITH_VERBOSE_MODE static const char * meta_screen_corner_to_string (MetaScreenCorner corner) @@ -1615,8 +1401,6 @@ void meta_screen_on_monitors_changed (MetaScreen *screen) { reload_logical_monitors (screen); - - meta_screen_queue_check_fullscreen (screen); } void @@ -1714,154 +1498,6 @@ meta_screen_unshow_desktop (MetaScreen *screen) meta_screen_update_showing_desktop_hint (screen); } -/** - * meta_screen_get_startup_sequences: (skip) - * @screen: - * - * Return value: (transfer none): Currently active #SnStartupSequence items - */ -GSList * -meta_screen_get_startup_sequences (MetaScreen *screen) -{ - return screen->startup_sequences; -} - -/* Sets the initial_timestamp and initial_workspace properties - * of a window according to information given us by the - * startup-notification library. - * - * Returns TRUE if startup properties have been applied, and - * FALSE if they have not (for example, if they had already - * been applied.) - */ -gboolean -meta_screen_apply_startup_properties (MetaScreen *screen, - MetaWindow *window) -{ -#ifdef HAVE_STARTUP_NOTIFICATION - const char *startup_id; - GSList *l; - SnStartupSequence *sequence; - - /* Does the window have a startup ID stored? */ - startup_id = meta_window_get_startup_id (window); - - meta_topic (META_DEBUG_STARTUP, - "Applying startup props to %s id \"%s\"\n", - window->desc, - startup_id ? startup_id : "(none)"); - - sequence = NULL; - if (startup_id == NULL) - { - /* No startup ID stored for the window. Let's ask the - * startup-notification library whether there's anything - * stored for the resource name or resource class hints. - */ - for (l = screen->startup_sequences; l != NULL; l = l->next) - { - const char *wmclass; - SnStartupSequence *seq = l->data; - - wmclass = sn_startup_sequence_get_wmclass (seq); - - if (wmclass != NULL && - ((window->res_class && - strcmp (wmclass, window->res_class) == 0) || - (window->res_name && - strcmp (wmclass, window->res_name) == 0))) - { - sequence = seq; - - g_assert (window->startup_id == NULL); - window->startup_id = g_strdup (sn_startup_sequence_get_id (sequence)); - startup_id = window->startup_id; - - meta_topic (META_DEBUG_STARTUP, - "Ending legacy sequence %s due to window %s\n", - sn_startup_sequence_get_id (sequence), - window->desc); - - sn_startup_sequence_complete (sequence); - break; - } - } - } - - /* Still no startup ID? Bail. */ - if (startup_id == NULL) - return FALSE; - - /* We might get this far and not know the sequence ID (if the window - * already had a startup ID stored), so let's look for one if we don't - * already know it. - */ - if (sequence == NULL) - { - for (l = screen->startup_sequences; l != NULL; l = l->next) - { - SnStartupSequence *seq = l->data; - const char *id; - - id = sn_startup_sequence_get_id (seq); - - if (strcmp (id, startup_id) == 0) - { - sequence = seq; - break; - } - } - } - - if (sequence != NULL) - { - gboolean changed_something = FALSE; - - meta_topic (META_DEBUG_STARTUP, - "Found startup sequence for window %s ID \"%s\"\n", - window->desc, startup_id); - - if (!window->initial_workspace_set) - { - int space = sn_startup_sequence_get_workspace (sequence); - if (space >= 0) - { - meta_topic (META_DEBUG_STARTUP, - "Setting initial window workspace to %d based on startup info\n", - space); - - window->initial_workspace_set = TRUE; - window->initial_workspace = space; - changed_something = TRUE; - } - } - - if (!window->initial_timestamp_set) - { - guint32 timestamp = sn_startup_sequence_get_timestamp (sequence); - meta_topic (META_DEBUG_STARTUP, - "Setting initial window timestamp to %u based on startup info\n", - timestamp); - - window->initial_timestamp_set = TRUE; - window->initial_timestamp = timestamp; - changed_something = TRUE; - } - - return changed_something; - } - else - { - meta_topic (META_DEBUG_STARTUP, - "Did not find startup sequence for window %s ID \"%s\"\n", - window->desc, startup_id); - } - -#endif /* HAVE_STARTUP_NOTIFICATION */ - - return FALSE; -} - /** * meta_screen_get_display: * @screen: A #MetaScreen @@ -1959,123 +1595,6 @@ meta_screen_set_active_workspace_hint (MetaScreen *screen) meta_error_trap_pop (x11_display); } -static gboolean -check_fullscreen_func (gpointer data) -{ - MetaScreen *screen = data; - MetaBackend *backend = meta_get_backend (); - MetaMonitorManager *monitor_manager = - meta_backend_get_monitor_manager (backend); - GList *logical_monitors, *l; - MetaWindow *window; - GSList *fullscreen_monitors = NULL; - GSList *obscured_monitors = NULL; - gboolean in_fullscreen_changed = FALSE; - - screen->check_fullscreen_later = 0; - - logical_monitors = - meta_monitor_manager_get_logical_monitors (monitor_manager); - - /* We consider a monitor in fullscreen if it contains a fullscreen window; - * however we make an exception for maximized windows above the fullscreen - * one, as in that case window+chrome fully obscure the fullscreen window. - */ - for (window = meta_stack_get_top (screen->display->stack); - window; - window = meta_stack_get_below (screen->display->stack, window, FALSE)) - { - gboolean covers_monitors = FALSE; - - if (window->screen != screen || window->hidden) - continue; - - if (window->fullscreen) - { - covers_monitors = TRUE; - } - else if (window->override_redirect) - { - /* We want to handle the case where an application is creating an - * override-redirect window the size of the screen (monitor) and treat - * it similarly to a fullscreen window, though it doesn't have fullscreen - * window management behavior. (Being O-R, it's not managed at all.) - */ - if (meta_window_is_monitor_sized (window)) - covers_monitors = TRUE; - } - else if (window->maximized_horizontally && - window->maximized_vertically) - { - MetaLogicalMonitor *logical_monitor; - - logical_monitor = meta_window_get_main_logical_monitor (window); - if (!g_slist_find (obscured_monitors, logical_monitor)) - obscured_monitors = g_slist_prepend (obscured_monitors, - logical_monitor); - } - - if (covers_monitors) - { - MetaRectangle window_rect; - - meta_window_get_frame_rect (window, &window_rect); - - for (l = logical_monitors; l; l = l->next) - { - MetaLogicalMonitor *logical_monitor = l->data; - - if (meta_rectangle_overlap (&window_rect, - &logical_monitor->rect) && - !g_slist_find (fullscreen_monitors, logical_monitor) && - !g_slist_find (obscured_monitors, logical_monitor)) - fullscreen_monitors = g_slist_prepend (fullscreen_monitors, - logical_monitor); - } - } - } - - g_slist_free (obscured_monitors); - - for (l = logical_monitors; l; l = l->next) - { - MetaLogicalMonitor *logical_monitor = l->data; - gboolean in_fullscreen; - - in_fullscreen = g_slist_find (fullscreen_monitors, - logical_monitor) != NULL; - if (in_fullscreen != logical_monitor->in_fullscreen) - { - logical_monitor->in_fullscreen = in_fullscreen; - in_fullscreen_changed = TRUE; - } - } - - g_slist_free (fullscreen_monitors); - - if (in_fullscreen_changed) - { - /* DOCK window stacking depends on the monitor's fullscreen - status so we need to trigger a re-layering. */ - MetaWindow *window = meta_stack_get_top (screen->display->stack); - if (window) - meta_stack_update_layer (screen->display->stack, window); - - g_signal_emit (screen, screen_signals[IN_FULLSCREEN_CHANGED], 0, NULL); - } - - return FALSE; -} - -void -meta_screen_queue_check_fullscreen (MetaScreen *screen) -{ - if (!screen->check_fullscreen_later) - screen->check_fullscreen_later = meta_later_add (META_LATER_CHECK_FULLSCREEN, - check_fullscreen_func, - screen, NULL); -} - /** * meta_screen_get_monitor_in_fullscreen: * @screen: a #MetaScreen diff --git a/src/core/stack.c b/src/core/stack.c index fc3b2ecfc..a9cd9aa32 100644 --- a/src/core/stack.c +++ b/src/core/stack.c @@ -945,7 +945,7 @@ stack_do_resort (MetaStack *stack) stack->sorted = g_list_sort (stack->sorted, (GCompareFunc) compare_window_position); - meta_screen_queue_check_fullscreen (stack->display->screen); + meta_display_queue_check_fullscreen (stack->display); stack->need_resort = FALSE; } diff --git a/src/core/window.c b/src/core/window.c index cda6aa887..5f038633e 100644 --- a/src/core/window.c +++ b/src/core/window.c @@ -900,10 +900,10 @@ meta_window_main_monitor_changed (MetaWindow *window, META_WINDOW_GET_CLASS (window)->main_monitor_changed (window, old); if (old) - g_signal_emit_by_name (window->screen, "window-left-monitor", + g_signal_emit_by_name (window->display, "window-left-monitor", old->number, window); if (window->monitor) - g_signal_emit_by_name (window->screen, "window-entered-monitor", + g_signal_emit_by_name (window->display, "window-entered-monitor", window->monitor->number, window); } @@ -1171,7 +1171,7 @@ _meta_window_shared_new (MetaDisplay *display, /* Apply any window attributes such as initial workspace * based on startup notification */ - meta_screen_apply_startup_properties (window->screen, window); + meta_display_apply_startup_properties (window->display, window); /* Try to get a "launch timestamp" for the window. If the window is * a transient, we'd like to be able to get a last-usage timestamp @@ -1551,7 +1551,7 @@ meta_window_unmanage (MetaWindow *window, META_WINDOW_GET_CLASS (window)->unmanage (window); meta_prefs_remove_listener (prefs_changed_callback, window); - meta_screen_queue_check_fullscreen (window->screen); + meta_display_queue_check_fullscreen (window->display); g_signal_emit (window, window_signals[UNMANAGED], 0); @@ -2533,7 +2533,7 @@ meta_window_show (MetaWindow *window) } if (did_show) - meta_screen_queue_check_fullscreen (window->screen); + meta_display_queue_check_fullscreen (window->display); #ifdef HAVE_WAYLAND if (did_show && window->client_type == META_WINDOW_CLIENT_TYPE_WAYLAND) @@ -2640,7 +2640,7 @@ meta_window_hide (MetaWindow *window) } if (did_hide) - meta_screen_queue_check_fullscreen (window->screen); + meta_display_queue_check_fullscreen (window->display); } static gboolean @@ -2792,7 +2792,7 @@ meta_window_maximize_internal (MetaWindow *window, set_net_wm_state (window); if (window->monitor->in_fullscreen) - meta_screen_queue_check_fullscreen (window->screen); + meta_display_queue_check_fullscreen (window->display); g_object_freeze_notify (G_OBJECT (window)); g_object_notify_by_pspec (G_OBJECT (window), obj_props[PROP_MAXIMIZED_HORIZONTALLY]); @@ -3121,7 +3121,7 @@ meta_window_tile (MetaWindow *window, directions = META_MAXIMIZE_VERTICAL; meta_window_maximize_internal (window, directions, NULL); - meta_screen_update_tile_preview (window->screen, FALSE); + meta_display_update_tile_preview (window->display, FALSE); /* Setup the edge constraints */ update_edge_constraints (window); @@ -3348,7 +3348,7 @@ meta_window_unmaximize (MetaWindow *window, meta_window_recalc_features (window); set_net_wm_state (window); if (!window->monitor->in_fullscreen) - meta_screen_queue_check_fullscreen (window->screen); + meta_display_queue_check_fullscreen (window->display); } g_object_freeze_notify (G_OBJECT (window)); @@ -3421,7 +3421,7 @@ meta_window_make_fullscreen_internal (MetaWindow *window) set_net_wm_state (window); /* For the auto-minimize feature, if we fail to get focus */ - meta_screen_queue_check_fullscreen (window->screen); + meta_display_queue_check_fullscreen (window->display); g_object_notify_by_pspec (G_OBJECT (window), obj_props[PROP_FULLSCREEN]); } @@ -3495,7 +3495,7 @@ meta_window_unmake_fullscreen (MetaWindow *window) NorthWestGravity, target_rect); - meta_screen_queue_check_fullscreen (window->screen); + meta_display_queue_check_fullscreen (window->display); g_object_notify_by_pspec (G_OBJECT (window), obj_props[PROP_FULLSCREEN]); } @@ -4165,7 +4165,7 @@ meta_window_move_to_monitor (MetaWindow *window, window->preferred_output_winsys_id = window->monitor->winsys_id; if (window->fullscreen || window->override_redirect) - meta_screen_queue_check_fullscreen (window->screen); + meta_display_queue_check_fullscreen (window->display); } static void @@ -5914,7 +5914,7 @@ update_move_maybe_tile (MetaWindow *window, MetaMonitorManager *monitor_manager = meta_backend_get_monitor_manager (backend); MetaLogicalMonitor *logical_monitor; - MetaScreen *screen = window->screen; + MetaDisplay *display = window->display; MetaRectangle work_area; /* For side-by-side tiling we are interested in the inside vertical @@ -5944,18 +5944,18 @@ update_move_maybe_tile (MetaWindow *window, */ if (meta_window_can_tile_side_by_side (window) && x >= logical_monitor->rect.x && x < (work_area.x + shake_threshold)) - screen->preview_tile_mode = META_TILE_LEFT; + display->preview_tile_mode = META_TILE_LEFT; else if (meta_window_can_tile_side_by_side (window) && x >= work_area.x + work_area.width - shake_threshold && x < (logical_monitor->rect.x + logical_monitor->rect.width)) - screen->preview_tile_mode = META_TILE_RIGHT; + display->preview_tile_mode = META_TILE_RIGHT; else if (meta_window_can_tile_maximized (window) && y >= logical_monitor->rect.y && y <= work_area.y) - screen->preview_tile_mode = META_TILE_MAXIMIZED; + display->preview_tile_mode = META_TILE_MAXIMIZED; else - screen->preview_tile_mode = META_TILE_NONE; + display->preview_tile_mode = META_TILE_NONE; - if (screen->preview_tile_mode != META_TILE_NONE) + if (display->preview_tile_mode != META_TILE_NONE) window->tile_monitor_number = logical_monitor->number; } @@ -5970,7 +5970,6 @@ update_move (MetaWindow *window, MetaRectangle old; int shake_threshold; MetaDisplay *display = window->display; - MetaScreen *screen = window->screen; display->grab_latest_motion_x = x; display->grab_latest_motion_y = y; @@ -6008,7 +6007,7 @@ update_move (MetaWindow *window, { /* We don't want to tile while snapping. Also, clear any previous tile request. */ - screen->preview_tile_mode = META_TILE_NONE; + display->preview_tile_mode = META_TILE_NONE; window->tile_monitor_number = -1; } else if (meta_prefs_get_edge_tiling () && @@ -6124,8 +6123,8 @@ update_move (MetaWindow *window, * trigger it unwittingly, e.g. when shaking loose the window or moving * it to another monitor. */ - meta_screen_update_tile_preview (screen, - screen->preview_tile_mode != META_TILE_NONE); + meta_display_update_tile_preview (window->display, + window->tile_mode != META_TILE_NONE); meta_window_get_frame_rect (window, &old); @@ -6339,8 +6338,8 @@ end_grab_op (MetaWindow *window, { if (meta_grab_op_is_moving (window->display->grab_op)) { - if (window->screen->preview_tile_mode != META_TILE_NONE) - meta_window_tile (window, window->screen->preview_tile_mode); + if (window->display->preview_tile_mode != META_TILE_NONE) + meta_window_tile (window, window->display->preview_tile_mode); else update_move (window, modifiers & CLUTTER_SHIFT_MASK, @@ -6355,7 +6354,7 @@ end_grab_op (MetaWindow *window, maybe_maximize_tiled_window (window); } } - window->screen->preview_tile_mode = META_TILE_NONE; + window->display->preview_tile_mode = META_TILE_NONE; meta_display_end_grab_op (window->display, clutter_event_get_time (event)); } diff --git a/src/core/workspace.c b/src/core/workspace.c index c9cb1579c..6dc807413 100644 --- a/src/core/workspace.c +++ b/src/core/workspace.c @@ -768,7 +768,7 @@ meta_workspace_invalidate_work_area (MetaWorkspace *workspace) g_list_free (windows); - meta_screen_queue_workarea_recalc (workspace->screen); + meta_display_queue_workarea_recalc (workspace->screen->display); } static MetaStrut * diff --git a/src/meta/display.h b/src/meta/display.h index f172bc904..389b87ac6 100644 --- a/src/meta/display.h +++ b/src/meta/display.h @@ -173,4 +173,6 @@ void meta_display_get_size (MetaDisplay *display, void meta_display_set_cursor (MetaDisplay *display, MetaCursor cursor); +GSList *meta_display_get_startup_sequences (MetaDisplay *display); + #endif diff --git a/src/meta/screen.h b/src/meta/screen.h index 37a85b8c3..bf4a66f51 100644 --- a/src/meta/screen.h +++ b/src/meta/screen.h @@ -38,8 +38,6 @@ GType meta_screen_get_type (void); MetaDisplay *meta_screen_get_display (MetaScreen *screen); -GSList *meta_screen_get_startup_sequences (MetaScreen *screen); - GList *meta_screen_get_workspaces (MetaScreen *screen); int meta_screen_get_n_workspaces (MetaScreen *screen); diff --git a/src/x11/window-props.c b/src/x11/window-props.c index b16c34984..1461f999b 100644 --- a/src/x11/window-props.c +++ b/src/x11/window-props.c @@ -1043,7 +1043,7 @@ reload_net_startup_id (MetaWindow *window, window->initial_timestamp_set = 0; window->initial_workspace_set = 0; - if (meta_screen_apply_startup_properties (window->screen, window)) + if (meta_display_apply_startup_properties (window->display, window)) { if (window->initial_timestamp_set) diff --git a/src/x11/window-x11.c b/src/x11/window-x11.c index 7dc998d8e..3e4e4a5c4 100644 --- a/src/x11/window-x11.c +++ b/src/x11/window-x11.c @@ -3341,7 +3341,7 @@ meta_window_x11_configure_notify (MetaWindow *window, * on its geometry. */ if (window->override_redirect) - meta_screen_queue_check_fullscreen (window->screen); + meta_display_queue_check_fullscreen (window->display); if (!event->override_redirect && !event->send_event) meta_warning ("Unhandled change of windows override redirect status\n"); -- cgit v1.2.1