void mnb_panel_ensure_size (MnbPanel *panel) { MetaRectangle r; MetaScreen *screen; MetaWorkspace *workspace; MetaPlugin *plugin = dawati_netbook_get_plugin_singleton (); screen = meta_plugin_get_screen (plugin); workspace = meta_screen_get_active_workspace (screen); if (workspace) { gint x, y; gint w, h; meta_workspace_get_work_area_all_monitors (workspace, &r); mnb_panel_get_position (panel, &x, &y); mnb_panel_get_size (panel, &w, &h); if (r.height != h || r.width != w) { mnb_panel_set_maximum_size (panel, r.width, r.height); } } }
/* * Pushes region associated with the given panel actor onto the panel layer of * the stack. */ void mnb_input_manager_push_oop_panel (MetaWindowActor *mcw) { ClutterActor *actor = (ClutterActor*)mcw; ClutterGeometry geom; MnbInputRegion *mir; gint screen_width, screen_height; gint y; MetaScreen *screen; MetaWorkspace *workspace; g_assert (mgr_singleton); screen = meta_plugin_get_screen (mgr_singleton->plugin); workspace = meta_screen_get_active_workspace (screen); meta_plugin_query_screen_size (mgr_singleton->plugin, &screen_width, &screen_height); if (workspace) { MetaRectangle r; meta_workspace_get_work_area_all_monitors (workspace, &r); screen_height = r.y + r.height; } mir = g_object_get_qdata (G_OBJECT (actor), quark_mir); if (mir) mnb_input_manager_remove_region_without_update (mir); clutter_actor_get_geometry (actor, &geom); y = MIN ((geom.y + geom.height), screen_height); mir = mnb_input_manager_push_region (0, y, screen_width, screen_height - y, FALSE, MNB_INPUT_LAYER_PANEL); g_object_set_qdata (G_OBJECT (actor), quark_mir, mir); g_signal_connect (actor, "notify::allocation", G_CALLBACK (panel_allocation_cb), NULL); g_signal_connect (actor, "show", G_CALLBACK (panel_show_cb), GINT_TO_POINTER (MNB_INPUT_LAYER_PANEL)); g_signal_connect (actor, "hide", G_CALLBACK (actor_hide_cb), NULL); g_signal_connect (actor, "destroy", G_CALLBACK (actor_destroy_cb), NULL); }
static void panel_show_cb (ClutterActor *actor, MnbInputLayer layer) { ClutterGeometry geom; MnbInputRegion *mir = g_object_get_qdata (G_OBJECT (actor), quark_mir); Display *xdpy; gint screen_width, screen_height; MetaScreen *screen; MetaWorkspace *workspace; g_assert (mgr_singleton); screen = meta_plugin_get_screen (mgr_singleton->plugin); workspace = meta_screen_get_active_workspace (screen); meta_plugin_query_screen_size (mgr_singleton->plugin, &screen_width, &screen_height); if (workspace) { MetaRectangle r; meta_workspace_get_work_area_all_monitors (workspace, &r); screen_height = r.y + r.height; } xdpy = meta_plugin_get_xdisplay (mgr_singleton->plugin); clutter_actor_get_geometry (actor, &geom); if (!mir) { mir = mnb_input_manager_push_region (0, geom.y + geom.height, screen_width, screen_height, FALSE, layer); g_object_set_qdata (G_OBJECT (actor), quark_mir, mir); } else { XRectangle rect; rect.x = 0; rect.y = geom.y + geom.height; rect.width = screen_width; rect.height = screen_height; XFixesSetRegion (xdpy, mir->region, &rect, 1); mnb_input_manager_apply_stack (); } }
static void moses_overview_setup(MosesOverview* self) { MosesOverviewPrivate* priv = self->priv; MetaScreen* screen = meta_plugin_get_screen(priv->plugin); MetaWorkspace* ws = meta_screen_get_active_workspace(screen); prepare_workspace_content(self, ws); // setup ov head priv->ov_head = overview_head_new(self); ClutterActor* head = overview_head_get_content(priv->ov_head); clutter_actor_add_child(CLUTTER_ACTOR(self), head); clutter_actor_hide(head); g_signal_connect(priv->ov_head, "workspace-activated", G_CALLBACK(on_ov_workspace_activated), self); }
/** * cinnamon_app_get_windows: * @app: * * Get the toplevel, interesting windows which are associated with this * application. The returned list will be sorted first by whether * they're on the active workspace, then by whether they're visible, * and finally by the time the user last interacted with them. * * Returns: (transfer none) (element-type MetaWindow): List of windows */ GSList * cinnamon_app_get_windows (CinnamonApp *app) { if (app->running_state == NULL) return NULL; if (app->running_state->window_sort_stale) { CompareWindowsData data; data.app = app; data.active_workspace = meta_screen_get_active_workspace (cinnamon_global_get_screen (cinnamon_global_get ())); app->running_state->windows = g_slist_sort_with_data (app->running_state->windows, cinnamon_app_compare_windows, &data); app->running_state->window_sort_stale = FALSE; } return app->running_state->windows; }
static void panel_allocation_cb (ClutterActor *actor, GParamSpec *pspec, gpointer data) { ClutterGeometry geom; MnbInputRegion *mir = g_object_get_qdata (G_OBJECT (actor), quark_mir); XRectangle rect; Display *xdpy; gint screen_width, screen_height; MetaScreen *screen; MetaWorkspace *workspace; g_assert (mgr_singleton); if (!mir) return; screen = meta_plugin_get_screen (mgr_singleton->plugin); workspace = meta_screen_get_active_workspace (screen); meta_plugin_query_screen_size (mgr_singleton->plugin, &screen_width, &screen_height); if (workspace) { MetaRectangle r; meta_workspace_get_work_area_all_monitors (workspace, &r); screen_height = r.y + r.height; } xdpy = meta_plugin_get_xdisplay (mgr_singleton->plugin); clutter_actor_get_geometry (actor, &geom); rect.x = 0; rect.y = MIN ((geom.y + geom.height), screen_height); rect.width = screen_width; rect.height = screen_height - rect.y; XFixesSetRegion (xdpy, mir->region, &rect, 1); mnb_input_manager_apply_stack (); }
gboolean meta_switcher_show(MetaSwitcher* self) { MetaSwitcherPrivate* priv = self->priv; int screen_width, screen_height; MetaScreen* screen = meta_plugin_get_screen(priv->plugin); priv->workspace = meta_screen_get_active_workspace(screen); meta_screen_get_size(screen, &screen_width, &screen_height); meta_switcher_present_list(self); if (priv->apps == NULL || priv->apps->len == 0) goto _end; _capture_desktop(self); clutter_content_invalidate(clutter_actor_get_content(priv->top)); ClutterActor* stage = meta_get_stage_for_screen(screen); clutter_actor_insert_child_above(stage, priv->top, NULL); clutter_actor_show(priv->top); if (!meta_plugin_begin_modal(priv->plugin, 0, clutter_get_current_event_time())) { if (!meta_plugin_begin_modal(priv->plugin, META_MODAL_POINTER_ALREADY_GRABBED, clutter_get_current_event_time())) { g_warning("can not be modal"); goto _end; } } meta_disable_unredirect_for_screen(screen); priv->modaled = TRUE; priv->previous_focused = clutter_stage_get_key_focus(CLUTTER_STAGE(stage)); if (priv->previous_focused == stage) priv->previous_focused = NULL; clutter_stage_set_key_focus(CLUTTER_STAGE(stage), priv->top); clutter_actor_grab_key_focus(priv->top); return TRUE; _end: clutter_actor_hide(priv->top); return FALSE; }
/** * cinnamon_app_activate_window: * @app: a #CinnamonApp * @window: (allow-none): Window to be focused * @timestamp: Event timestamp * * Bring all windows for the given app to the foreground, * but ensure that @window is on top. If @window is %NULL, * the window with the most recent user time for the app * will be used. * * This function has no effect if @app is not currently running. */ void cinnamon_app_activate_window (CinnamonApp *app, MetaWindow *window, guint32 timestamp) { GSList *windows; if (cinnamon_app_get_state (app) != CINNAMON_APP_STATE_RUNNING) return; windows = cinnamon_app_get_windows (app); if (window == NULL && windows) window = windows->data; if (!g_slist_find (windows, window)) return; else { GSList *iter; CinnamonGlobal *global = cinnamon_global_get (); MetaScreen *screen = cinnamon_global_get_screen (global); MetaDisplay *display = meta_screen_get_display (screen); MetaWorkspace *active = meta_screen_get_active_workspace (screen); MetaWorkspace *workspace = meta_window_get_workspace (window); guint32 last_user_timestamp = meta_display_get_last_user_time (display); MetaWindow *most_recent_transient; if (meta_display_xserver_time_is_before (display, timestamp, last_user_timestamp)) { meta_window_set_demands_attention (window); return; } /* Now raise all the other windows for the app that are on * the same workspace, in reverse order to preserve the stacking. */ for (iter = windows; iter; iter = iter->next) { MetaWindow *other_window = iter->data; if (other_window != window) meta_window_raise (other_window); } /* If we have a transient that the user's interacted with more recently than * the window, pick that. */ most_recent_transient = find_most_recent_transient_on_same_workspace (display, window); if (most_recent_transient && meta_display_xserver_time_is_before (display, meta_window_get_user_time (window), meta_window_get_user_time (most_recent_transient))) window = most_recent_transient; if (!cinnamon_window_tracker_is_window_interesting (window)) { /* We won't get notify::user-time signals for uninteresting windows, * which means that an app's last_user_time won't get updated. * Update it here instead. */ app->running_state->last_user_time = timestamp; } if (active != workspace) meta_workspace_activate_with_focus (workspace, window, timestamp); else meta_window_activate (window, timestamp); } }
static void moses_overview_dispose(GObject *object) { MosesOverview *overview = MOSES_OVERVIEW(object); MosesOverviewPrivate* priv = overview->priv; if (priv->disposed) return; priv->disposed = TRUE; g_clear_pointer(&priv->ov_head, g_object_unref); MetaScreen* screen = meta_plugin_get_screen(priv->plugin); ClutterActor* stage = meta_get_stage_for_screen(screen); ClutterActor* to_focus = NULL; if (priv->selected_actor) { to_focus = clutter_clone_get_source(CLUTTER_CLONE(priv->selected_actor)); } for (int i = 0; priv->clones && i < priv->clones->len; i++) { ClutterActor* clone = g_ptr_array_index(priv->clones, i); ClutterActor* orig = clutter_clone_get_source(CLUTTER_CLONE(clone)); clutter_actor_show(orig); // FIXME: maybe some actors had not been shown. clutter_actor_destroy(clone); } for (int i = 0; priv->badges && i < priv->badges->len; i++) { clutter_actor_destroy(CLUTTER_ACTOR(g_ptr_array_index(priv->badges, i))); } if (priv->background_actor) { clutter_actor_show(clutter_clone_get_source(CLUTTER_CLONE(priv->background_actor))); g_clear_pointer(&priv->background_actor, clutter_actor_destroy); } if (priv->modaled) { meta_plugin_end_modal(priv->plugin, clutter_get_current_event_time()); meta_enable_unredirect_for_screen(screen); if (priv->selected_workspace) { meta_workspace_activate(priv->selected_workspace, CLUTTER_CURRENT_TIME); MetaDisplay* display = meta_screen_get_display(screen); meta_compositor_switch_workspace(meta_display_get_compositor(display), meta_screen_get_active_workspace(screen), priv->selected_workspace, META_MOTION_DOWN); } else if (to_focus) { clutter_stage_set_key_focus(CLUTTER_STAGE(stage), to_focus); MetaWindowActor* actor = META_WINDOW_ACTOR(to_focus); MetaWindow* win = meta_window_actor_get_meta_window(actor); meta_window_raise(win); meta_window_focus(win, CLUTTER_CURRENT_TIME); } else if (priv->previous_focused) { if (!CLUTTER_IS_STAGE(priv->previous_focused)) { clutter_stage_set_key_focus(CLUTTER_STAGE(stage), priv->previous_focused); } } } G_OBJECT_CLASS(moses_overview_parent_class)->dispose(object); }