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