static void ntf_tray_get_preferred_width (ClutterActor *actor, gfloat for_height, gfloat *min_width, gfloat *nat_width) { NtfTrayPrivate *priv = NTF_TRAY (actor)->priv; if (min_width) *min_width = CLUSTER_WIDTH; if (nat_width) { if (priv->urgent) { gfloat nat_notif; MetaPlugin *plugin = dawati_netbook_get_plugin_singleton (); MetaScreen *screen = meta_plugin_get_screen (plugin); gint screen_width, screen_height; meta_screen_get_size (screen, &screen_width, &screen_height); clutter_actor_get_preferred_width (priv->notifiers, for_height, NULL, &nat_notif); *nat_width = MIN ((2 * screen_width) / 3, nat_notif); } else *nat_width = CLUSTER_WIDTH; } }
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); } } }
static void ntf_libnotify_update_modal (void) { NtfTray *tray = ntf_overlay_get_tray (TRUE); MetaPlugin *plugin = dawati_netbook_get_plugin_singleton (); if (ntf_tray_get_n_notifications (tray) > 0) { if (!overlay_focused) { MetaScreen *screen = meta_plugin_get_screen (plugin); ClutterActor *stage = meta_get_stage_for_screen (screen); MxFocusManager *manager = mx_focus_manager_get_for_stage (CLUTTER_STAGE (stage)); dawati_netbook_stash_window_focus (plugin, CurrentTime); mx_focus_manager_push_focus (manager, MX_FOCUSABLE (tray)); overlay_focused = TRUE; } } else { if (overlay_focused) { dawati_netbook_unstash_window_focus (plugin, CurrentTime); overlay_focused = FALSE; } } }
void show_tile_preview (MetaPlugin *plugin, MetaWindow *window, MetaRectangle *tile_rect, int tile_monitor_number) { MetaScreen *screen = meta_plugin_get_screen (plugin); ScreenTilePreview *preview = get_screen_tile_preview (screen); ClutterActor *window_actor; if (CLUTTER_ACTOR_IS_VISIBLE (preview->actor) && preview->tile_rect.x == tile_rect->x && preview->tile_rect.y == tile_rect->y && preview->tile_rect.width == tile_rect->width && preview->tile_rect.height == tile_rect->height) return; /* nothing to do */ clutter_actor_set_position (preview->actor, tile_rect->x, tile_rect->y); clutter_actor_set_size (preview->actor, tile_rect->width, tile_rect->height); clutter_actor_show (preview->actor); window_actor = CLUTTER_ACTOR (meta_window_get_compositor_private (window)); clutter_actor_lower (preview->actor, window_actor); preview->tile_rect = *tile_rect; }
static void on_switch_workspace_effect_complete (ClutterTimeline *timeline, gpointer data) { MetaPlugin *plugin = META_PLUGIN (data); MetaDefaultPluginPrivate *priv = META_DEFAULT_PLUGIN (plugin)->priv; MetaScreen *screen = meta_plugin_get_screen (plugin); GList *l = meta_get_window_actors (screen); while (l) { ClutterActor *a = l->data; MetaWindowActor *window_actor = META_WINDOW_ACTOR (a); ActorPrivate *apriv = get_actor_private (window_actor); if (apriv->orig_parent) { clutter_actor_reparent (a, apriv->orig_parent); apriv->orig_parent = NULL; } l = l->next; } clutter_actor_destroy (priv->desktop1); clutter_actor_destroy (priv->desktop2); priv->tml_switch_workspace1 = NULL; priv->tml_switch_workspace2 = NULL; priv->desktop1 = NULL; priv->desktop2 = NULL; meta_plugin_switch_workspace_completed (plugin); }
void meta_end_modal_for_plugin (MetaCompositor *compositor, MetaPlugin *plugin, guint32 timestamp) { MetaDisplay *display = compositor->display; MetaBackend *backend = meta_get_backend (); g_return_if_fail (is_modal (display)); g_signal_emit_by_name (display, "grab-op-end", meta_plugin_get_screen (plugin), display->grab_window, display->grab_op); display->grab_op = META_GRAB_OP_NONE; display->event_route = META_EVENT_ROUTE_NORMAL; display->grab_window = NULL; display->grab_have_pointer = FALSE; display->grab_have_keyboard = FALSE; meta_backend_ungrab_device (backend, META_VIRTUAL_CORE_POINTER_ID, timestamp); meta_backend_ungrab_device (backend, META_VIRTUAL_CORE_KEYBOARD_ID, timestamp); if (meta_is_wayland_compositor ()) meta_display_sync_wayland_input_focus (display); }
static gboolean on_key_press(ClutterActor *actor, ClutterEvent *event, MosesOverview* self) { MosesOverviewPrivate* priv = self->priv; MetaScreen* screen = meta_plugin_get_screen(priv->plugin); g_debug("%s", __func__); guint keysym = clutter_event_get_key_symbol(event); if (priv->ready) { if (keysym == CLUTTER_KEY_Escape) { overview_animated_destroy(self, MOSES_OV_REASON_NORMAL, FALSE); return TRUE; } else if (keysym >= CLUTTER_KEY_1 && keysym <= CLUTTER_KEY_9) { //TODO: what if size of clones is greater than 9 for (int i = 0; i < priv->clones->len; i++) { ClutterActor* clone = g_ptr_array_index(priv->clones, i); int order = GPOINTER_TO_INT(g_object_get_qdata(G_OBJECT(clone), moses_overview_window_clone_order())); if (order == keysym - CLUTTER_KEY_0) { priv->selected_actor = clone; overview_animated_destroy(self, MOSES_OV_REASON_ACTIVATE_WINDOW, TRUE); } } } } return FALSE; }
static void calculate_places(MosesOverview* self) { MosesOverviewPrivate* priv = self->priv; GPtrArray* clones = priv->clones; if (priv->clones->len) { g_ptr_array_sort(clones, window_compare); // get the area used by the expo algorithms together MetaScreen* screen = meta_plugin_get_screen(priv->plugin); MetaRectangle geom; int focused_monitor = meta_screen_get_current_monitor(screen); meta_screen_get_monitor_geometry(screen, focused_monitor, &geom); int HEAD_SIZE = TOP_GAP; g_object_get(priv->ov_head, "height", &HEAD_SIZE, NULL); g_debug("%s ov height: %d", __func__, HEAD_SIZE); MetaRectangle area = {(int)floorf (geom.x + BORDER), (int)floorf (geom.y + TOP_GAP + HEAD_SIZE), (int)floorf (geom.width - BORDER * 2), (int)floorf (geom.height - BOTTOM_GAP - TOP_GAP - HEAD_SIZE)}; natural_placement(self, area); } else { //NOTE: I can not set ready flag here because a conflict of super-e key release g_timeout_add(500, (GSourceFunc)on_ready_timeout, self); } clutter_actor_show(overview_head_get_content(priv->ov_head)); }
static void _capture_desktop(MetaSwitcher* self) { MetaSwitcherPrivate* priv = self->priv; MetaScreen* screen = meta_plugin_get_screen(priv->plugin); ClutterActor* stage = meta_get_stage_for_screen(screen); gfloat tx, ty, w, h; clutter_actor_get_position(priv->top, &tx, &ty); clutter_actor_get_size(priv->top, &w, &h); g_debug("%s: %f, %f, %f, %f", __func__, tx, ty, w, h); if (priv->snapshot) { cairo_surface_destroy(priv->snapshot); priv->snapshot = NULL; } priv->snapshot_offset = 20.0; w += priv->snapshot_offset*3; clutter_stage_ensure_redraw(CLUTTER_STAGE(stage)); guchar* data = g_malloc(w*h*4); cogl_framebuffer_read_pixels(cogl_get_draw_framebuffer(), tx-priv->snapshot_offset, ty, w, h, CLUTTER_CAIRO_FORMAT_ARGB32, data); /*guchar* data = clutter_stage_read_pixels(CLUTTER_STAGE(stage), */ /*tx-priv->snapshot_offset, ty, w, h);*/ priv->snapshot = cairo_image_surface_create_for_data(data, CAIRO_FORMAT_ARGB32, w, h, w*4); g_free(data); }
static void meta_switcher_dispose(GObject *object) { MetaSwitcher *switcher = META_SWITCHER(object); MetaSwitcherPrivate* priv = switcher->priv; if (priv->disposed) return; priv->disposed = TRUE; MetaScreen* screen = meta_plugin_get_screen(priv->plugin); ClutterActor* stage = meta_get_stage_for_screen(screen); clutter_actor_remove_child(stage, priv->top); if (priv->modaled) { meta_plugin_end_modal(priv->plugin, clutter_get_current_event_time()); meta_enable_unredirect_for_screen(screen); if (priv->selected_id < 0 && priv->previous_focused) clutter_stage_set_key_focus(CLUTTER_STAGE(stage), priv->previous_focused); } if (CLUTTER_IS_ACTOR(priv->top)) { g_clear_pointer(&priv->top, clutter_actor_destroy); } else priv->top = NULL; if (priv->autoclose_id) { g_source_remove(priv->autoclose_id); priv->autoclose_id = 0; } GList* ws_list = meta_screen_get_workspaces(screen); g_list_foreach(ws_list, (GFunc)unhook_ws_event, switcher); G_OBJECT_CLASS(meta_switcher_parent_class)->dispose(object); }
void hide_tile_preview (MetaPlugin *plugin) { MetaScreen *screen = meta_plugin_get_screen (plugin); ScreenTilePreview *preview = get_screen_tile_preview (screen); clutter_actor_hide (preview->actor); }
static void overview_animated_destroy(MosesOverview* self, MosesOverviewQuitReason reason, gboolean animate) { MosesOverviewPrivate* priv = self->priv; gboolean just_destroy = !animate; if (reason == MOSES_OV_REASON_ACTIVATE_WINDOW && !priv->selected_actor) { just_destroy = TRUE; } else if (reason == MOSES_OV_REASON_ACTIVATE_WORKSPACE && !priv->selected_workspace) { just_destroy = TRUE; } else if (reason == MOSES_OV_REASON_NORMAL) { just_destroy = TRUE; } if (just_destroy) { clutter_actor_destroy(CLUTTER_ACTOR(self)); return; } gfloat x, y, w, h; ClutterActor* target = NULL; if (reason == MOSES_OV_REASON_ACTIVATE_WINDOW) { target = self->priv->selected_actor; ClutterActor* orig = clutter_clone_get_source(CLUTTER_CLONE(target)); clutter_actor_get_position(orig, &x, &y); clutter_actor_get_size(orig, &w, &h); g_signal_handlers_disconnect_by_func(target, on_effect_complete, self); } else if (reason == MOSES_OV_REASON_ACTIVATE_WORKSPACE) { g_assert(priv->selected_actor == NULL); MetaScreen* screen = meta_plugin_get_screen(priv->plugin); target = overview_head_get_actor_for_workspace(priv->ov_head, priv->selected_workspace); MetaRectangle geom; int focused_monitor = meta_screen_get_current_monitor(screen); meta_screen_get_monitor_geometry(screen, focused_monitor, &geom); x = geom.x, y = geom.y, w = geom.width, h = geom.height; } if (target) { clutter_actor_remove_all_transitions(target); clutter_actor_set_child_above_sibling(clutter_actor_get_parent(target), target, NULL); clutter_actor_save_easing_state(target); clutter_actor_set_easing_mode(target, CLUTTER_LINEAR); clutter_actor_set_easing_duration(target, 150); clutter_actor_set_position(target, x, y); clutter_actor_set_scale(target, w / clutter_actor_get_width(target), h / clutter_actor_get_height(target)); clutter_actor_restore_easing_state(target); g_object_connect(target, "signal::transitions-completed", G_CALLBACK(on_restore_position_effect_complete), self, NULL); } }
static void meta_switcher_present_list(MetaSwitcher* self) { MetaSwitcherPrivate* priv = self->priv; MetaScreen* screen = meta_plugin_get_screen(priv->plugin); MetaDisplay* display = meta_screen_get_display(screen); // windows on all workspaces GList* ls = meta_display_get_tab_list(display, META_TAB_LIST_NORMAL, NULL); if (!ls) return; GList* ws_list = meta_screen_get_workspaces(screen); g_list_foreach(ws_list, (GFunc)hook_ws_event, self); if (!priv->apps) { priv->apps = g_ptr_array_new(); GList* orig = ls; while (ls) { g_ptr_array_add(priv->apps, ls->data); ls = ls->next; } g_list_free(orig); } clutter_actor_set_height(priv->top, APP_ACTOR_HEIGHT + 20); gint x = 0, y = 0; for (int i = 0; i < priv->apps->len; i++) { _add_app(self, g_ptr_array_index(priv->apps, i), &x, &y); } clutter_actor_set_margin_left(g_hash_table_lookup(priv->icons, g_ptr_array_index(priv->apps, 0)), 10); clutter_actor_set_margin_right(g_hash_table_lookup(priv->icons, g_ptr_array_index(priv->apps, priv->apps->len-1)), 10); gint screen_width = 0, screen_height = 0; meta_screen_get_size(screen, &screen_width, &screen_height); /* TODO: @sonald set top width when bigger than screen width */ if (clutter_actor_get_width(priv->top) > screen_width) clutter_actor_set_width(priv->top, screen_width); gfloat w = clutter_actor_get_width(priv->top), h = clutter_actor_get_height(priv->top), tx = (screen_width - w) / 2, ty = (screen_height - h) / 2; #if DEBUG g_message("%s, line %d, %f %f", __func__, __LINE__, w, tx); #endif clutter_actor_set_position(priv->top, tx, ty); ClutterContent* canvas = clutter_canvas_new(); clutter_canvas_set_size(CLUTTER_CANVAS(canvas), w, h); clutter_actor_set_content(priv->top, canvas); g_object_unref(canvas); g_signal_connect(canvas, "draw", G_CALLBACK(on_switcher_background_draw), self); clutter_content_invalidate(canvas); priv->selected_id = 0; }
static void settings_cb (GSettings *settings, gchar *key, gpointer userdata) { MetaPlugin *plugin = META_PLUGIN (userdata); MetaScreen *screen = meta_plugin_get_screen (plugin); /* Force the wallpapers to be re-fetched */ on_monitors_changed (screen, plugin); }
/* * 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 budgie_wm_start(MetaPlugin *plugin) { BudgieWM *self = BUDGIE_WM(plugin); MetaScreen *screen = meta_plugin_get_screen(plugin); ClutterActor* actors[2]; /* Init background */ self->priv->background_group = meta_background_group_new(); clutter_actor_set_reactive(self->priv->background_group, TRUE); clutter_actor_insert_child_below(meta_get_window_group_for_screen(screen), self->priv->background_group, NULL); g_signal_connect(screen, "monitors-changed", G_CALLBACK(on_monitors_changed), plugin); on_monitors_changed(screen, plugin); /* Now we're in action. */ clutter_actor_show(meta_get_window_group_for_screen(screen)); clutter_actor_show(self->priv->background_group); clutter_actor_set_opacity(meta_get_window_group_for_screen(screen), 0); clutter_actor_set_opacity(self->priv->background_group, 0); actors[0] = meta_get_window_group_for_screen(screen); actors[1] = self->priv->background_group; clutter_actor_set_background_color(meta_get_stage_for_screen(screen), clutter_color_get_static(CLUTTER_COLOR_BLACK)); clutter_actor_show(meta_get_stage_for_screen(screen)); for (int i = 0; i < 2; i++) { clutter_actor_save_easing_state(actors[i]); clutter_actor_set_easing_mode(actors[i], CLUTTER_EASE_OUT_QUAD); clutter_actor_set_easing_duration(actors[i], SHOW_TIMEOUT); g_object_set(actors[i], "opacity", 255, NULL); clutter_actor_restore_easing_state(actors[i]); } /* Set up our own keybinding overrides */ meta_keybindings_set_custom_handler(BUDGIE_KEYBINDING_MAIN_MENU, budgie_launch_menu, NULL, NULL); meta_keybindings_set_custom_handler(BUDGIE_KEYBINDING_RUN_DIALOG, budgie_launch_rundialog, NULL, NULL); meta_keybindings_set_custom_handler("switch-windows", (MetaKeyHandlerFunc)switch_windows, self, NULL); meta_keybindings_set_custom_handler("switch-applications", (MetaKeyHandlerFunc)switch_windows, self, NULL); /* Handle keys.. */ budgie_keys_init(meta_screen_get_display(screen)); budgie_menus_init(self); g_signal_connect(meta_screen_get_display(screen), "overlay-key", G_CALLBACK(overlay_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 gboolean show_stage (MetaPlugin *plugin) { MetaScreen *screen; ClutterActor *stage; screen = meta_plugin_get_screen (plugin); stage = meta_get_stage_for_screen (screen); clutter_actor_show (stage); return FALSE; }
/* This is used when reloading plugins to make sure we don't have * a left-over modal grab for this screen. */ LOCAL_SYMBOL void meta_check_end_modal (MetaScreen *screen) { MetaDisplay *display = meta_screen_get_display (screen); MetaCompositor *compositor = display->compositor; if (compositor->modal_plugin && meta_plugin_get_screen (compositor->modal_plugin) == screen) { meta_end_modal_for_plugin (screen, compositor->modal_plugin, CurrentTime); } }
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); }
static void start (MetaPlugin *plugin) { MetaDefaultPlugin *self = META_DEFAULT_PLUGIN (plugin); MetaScreen *screen = meta_plugin_get_screen (plugin); self->priv->background_group = meta_background_group_new (); clutter_actor_insert_child_below (meta_get_window_group_for_screen (screen), self->priv->background_group, NULL); g_signal_connect (screen, "monitors-changed", G_CALLBACK (on_monitors_changed), plugin); on_monitors_changed (screen, plugin); clutter_actor_show (meta_get_stage_for_screen (screen)); }
static void mnb_zones_preview_init (MnbZonesPreview *self) { MnbZonesPreviewPrivate *priv = self->priv = ZONES_PREVIEW_PRIVATE (self); MetaPlugin *plugin = dawati_netbook_get_plugin_singleton (); MetaScreen *screen = meta_plugin_get_screen (plugin); priv->zoom = 1.0; priv->spacing = 0; priv->dest_workspace = -1; priv->workspace_bg = meta_background_actor_new_for_screen (screen); clutter_actor_set_parent (priv->workspace_bg, CLUTTER_ACTOR (self)); g_signal_connect (self, "style-changed", G_CALLBACK (mnb_zones_preview_style_changed_cb), self); }
static gboolean on_key_release(ClutterActor *actor, ClutterEvent *event, MosesOverview* self) { MosesOverviewPrivate* priv = self->priv; MetaScreen* screen = meta_plugin_get_screen(priv->plugin); MetaDisplay* display = meta_screen_get_display(screen); ClutterModifierType state = clutter_event_get_state(event); g_debug("%s", __func__); if (priv->ready) { guint action = meta_display_get_keybinding_action(display, clutter_event_get_key_code(event), state); if (action == elsa_wm_get_action(ELSA_WM_PLUGIN(priv->plugin), "expose-windows")) { overview_animated_destroy(self, MOSES_OV_REASON_NORMAL, FALSE); return TRUE; } } return FALSE; }
static void reposition_switcher(MetaSwitcher* self) { MetaSwitcherPrivate* priv = self->priv; MetaScreen* screen = meta_plugin_get_screen(priv->plugin); gint screen_width = 0, screen_height = 0; meta_screen_get_size(screen, &screen_width, &screen_height); clutter_actor_save_easing_state(priv->top); clutter_actor_set_easing_duration(priv->top, 400); clutter_actor_set_easing_mode(priv->top, CLUTTER_LINEAR); gfloat w = clutter_actor_get_width(priv->top), h = clutter_actor_get_height(priv->top), tx = (screen_width - w)/2, ty = (screen_height - h)/2; clutter_actor_set_position(priv->top, tx, ty); clutter_actor_restore_easing_state(priv->top); }
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 (); }
static gboolean show_stage (MetaPlugin *plugin) { MetaScreen *screen; ClutterActor *stage; screen = meta_plugin_get_screen (plugin); stage = meta_get_stage_for_screen (screen); clutter_actor_show (stage); /* Set up our own keybinding overrides */ meta_keybindings_set_custom_handler(BUDGIE_KEYBINDING_MAIN_MENU, budgie_launch_menu, NULL, NULL); meta_keybindings_set_custom_handler(BUDGIE_KEYBINDING_RUN_DIALOG, budgie_launch_rundialog, NULL, NULL); return FALSE; }
//FIXME: actually key_release is activated even when key press (WTF). does it because I'm hold alt/super? static gboolean on_key_release(ClutterActor *actor, ClutterEvent *event, MetaSwitcher* self) { MetaSwitcherPrivate* priv = self->priv; MetaScreen* screen = meta_plugin_get_screen(priv->plugin); MetaDisplay* display = meta_screen_get_display(screen); ClutterModifierType state = clutter_event_get_state(event); guint keysym = clutter_event_get_key_symbol(event); guint action = meta_display_get_keybinding_action(display, clutter_event_get_key_code(event), state); int id = priv->selected_id; if (action == META_KEYBINDING_ACTION_SWITCH_WINDOWS) { id = (id + 1) % priv->apps->len; } else if (action == META_KEYBINDING_ACTION_SWITCH_WINDOWS_BACKWARD) { id = (priv->apps->len + id - 1) % priv->apps->len; } else if (action == META_KEYBINDING_ACTION_SWITCH_APPLICATIONS) { id = (id + 1) % priv->apps->len; } else if (action == META_KEYBINDING_ACTION_SWITCH_APPLICATIONS_BACKWARD) { id = (priv->apps->len + id - 1) % priv->apps->len; } _set_highlight(self, priv->selected_id, FALSE); _set_highlight(self, id, TRUE); g_debug("%s, key: 0x%x, action: %d, previd: %d, now: %d", __func__, keysym, action, priv->selected_id, id); priv->selected_id = id; switch(keysym) { //FIXME: do not hardcode keysyms, use action instead case CLUTTER_KEY_Super_L: case CLUTTER_KEY_Super_R: case CLUTTER_KEY_Alt_L: case CLUTTER_KEY_Alt_R: { if (priv->selected_id >= 0) { meta_window_activate(g_ptr_array_index(priv->apps, priv->selected_id), clutter_get_current_event_time()); } g_object_unref(self); } default: break; } return FALSE; }
gboolean meta_begin_modal_for_plugin (MetaCompositor *compositor, MetaPlugin *plugin, MetaModalOptions options, guint32 timestamp) { /* To some extent this duplicates code in meta_display_begin_grab_op(), but there * are significant differences in how we handle grabs that make it difficult to * merge the two. */ MetaDisplay *display = compositor->display; if (is_modal (display) || display->grab_op != META_GRAB_OP_NONE) return FALSE; /* XXX: why is this needed? */ XIUngrabDevice (display->xdisplay, META_VIRTUAL_CORE_POINTER_ID, timestamp); XSync (display->xdisplay, False); if (!grab_devices (options, timestamp)) return FALSE; display->grab_op = META_GRAB_OP_COMPOSITOR; display->event_route = META_EVENT_ROUTE_COMPOSITOR_GRAB; display->grab_window = NULL; display->grab_have_pointer = TRUE; display->grab_have_keyboard = TRUE; g_signal_emit_by_name (display, "grab-op-begin", meta_plugin_get_screen (plugin), display->grab_window, display->grab_op); if (meta_is_wayland_compositor ()) { meta_display_sync_wayland_input_focus (display); meta_display_cancel_touch (display); } return TRUE; }
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; }
static ClutterActor* load_icon_for_window(MetaSwitcher* self, MetaWindow* window) { MetaSwitcherPrivate *priv = self->priv; MetaScreen *screen = meta_plugin_get_screen(priv->plugin); ShellWindowTracker* tracker = shell_window_tracker_get_default(); ShellApp* app = shell_window_tracker_get_window_app(tracker, window); gint screen_width, screen_height, app_icon_size = APP_ICON_SIZE; /* TODO: @sonald scale app icon size at first */ meta_screen_get_size(screen, &screen_width, &screen_height); if (priv->apps->len) app_icon_size = (screen_width - priv->apps->len * APP_ICON_PADDING ) / priv->apps->len; if (app_icon_size > APP_ICON_SIZE) app_icon_size = APP_ICON_SIZE; if (app) return shell_app_create_icon_texture(app, app_icon_size); return NULL; }