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