static void
add_drag_object (ClutterActor *target)
{
ClutterActor *parent;
if (drag == NULL)
{
ClutterAction *action;
drag = clutter_actor_new ();
clutter_actor_set_background_color (drag, CLUTTER_COLOR_LightSkyBlue);
clutter_actor_set_size (drag, HANDLE_SIZE, HANDLE_SIZE);
clutter_actor_set_position (drag,
(TARGET_SIZE - HANDLE_SIZE) / 2.0,
(TARGET_SIZE - HANDLE_SIZE) / 2.0);
clutter_actor_set_reactive (drag, TRUE);
action = clutter_drag_action_new ();
g_signal_connect (action, "drag-begin", G_CALLBACK (on_drag_begin), NULL);
g_signal_connect (action, "drag-end", G_CALLBACK (on_drag_end), NULL);
clutter_actor_add_action (drag, action);
}
parent = clutter_actor_get_parent (drag);
if (parent == target)
{
clutter_actor_save_easing_state (target);
clutter_actor_set_easing_mode (target, CLUTTER_LINEAR);
clutter_actor_set_opacity (target, 255);
clutter_actor_restore_easing_state (target);
return;
}
g_object_ref (drag);
if (parent != NULL && parent != stage)
{
clutter_actor_remove_child (parent, drag);
clutter_actor_save_easing_state (parent);
clutter_actor_set_easing_mode (parent, CLUTTER_LINEAR);
clutter_actor_set_opacity (parent, 64);
clutter_actor_restore_easing_state (parent);
}
clutter_actor_add_child (target, drag);
clutter_actor_save_easing_state (target);
clutter_actor_set_easing_mode (target, CLUTTER_LINEAR);
clutter_actor_set_opacity (target, 255);
clutter_actor_restore_easing_state (target);
g_object_unref (drag);
}
static void
on_drag_end (ClutterDragAction *action,
ClutterActor *actor,
gfloat event_x,
gfloat event_y,
ClutterModifierType modifiers)
{
ClutterActor *handle = clutter_drag_action_get_drag_handle (action);
g_print ("Drag ended at: %.0f, %.0f\n",
event_x, event_y);
clutter_actor_save_easing_state (actor);
clutter_actor_set_easing_mode (actor, CLUTTER_LINEAR);
clutter_actor_set_opacity (actor, 255);
clutter_actor_restore_easing_state (actor);
clutter_actor_save_easing_state (handle);
if (!drop_successful)
{
ClutterActor *parent = clutter_actor_get_parent (actor);
gfloat x_pos, y_pos;
clutter_actor_save_easing_state (parent);
clutter_actor_set_easing_mode (parent, CLUTTER_LINEAR);
clutter_actor_set_opacity (parent, 255);
clutter_actor_restore_easing_state (parent);
clutter_actor_get_transformed_position (actor, &x_pos, &y_pos);
clutter_actor_set_easing_mode (handle, CLUTTER_EASE_OUT_BOUNCE);
clutter_actor_set_position (handle, x_pos, y_pos);
clutter_actor_set_opacity (handle, 0);
clutter_actor_restore_easing_state (handle);
}
else
{
clutter_actor_set_easing_mode (handle, CLUTTER_LINEAR);
clutter_actor_set_opacity (handle, 0);
}
clutter_actor_restore_easing_state (handle);
g_signal_connect (handle, "transitions-completed",
G_CALLBACK (clutter_actor_destroy),
NULL);
}
static void
on_drag_begin (ClutterDragAction *action,
ClutterActor *actor,
gfloat event_x,
gfloat event_y,
ClutterModifierType modifiers)
{
ClutterActor *handle;
gfloat x_pos, y_pos;
clutter_actor_get_position (actor, &x_pos, &y_pos);
handle = clutter_actor_new ();
clutter_actor_set_background_color (handle, CLUTTER_COLOR_DarkSkyBlue);
clutter_actor_set_size (handle, 128, 128);
clutter_actor_set_position (handle, event_x - x_pos, event_y - y_pos);
clutter_actor_add_child (stage, handle);
clutter_drag_action_set_drag_handle (action, handle);
clutter_actor_save_easing_state (actor);
clutter_actor_set_easing_mode (actor, CLUTTER_LINEAR);
clutter_actor_set_opacity (actor, 128);
clutter_actor_restore_easing_state (actor);
drop_successful = FALSE;
}
void
meta_compositor_flash_window (MetaCompositor *compositor,
MetaWindow *window)
{
ClutterActor *window_actor =
CLUTTER_ACTOR (meta_window_get_compositor_private (window));
ClutterActor *flash;
ClutterTransition *transition;
flash = clutter_actor_new ();
clutter_actor_set_background_color (flash, CLUTTER_COLOR_Black);
clutter_actor_set_size (flash, window->rect.width, window->rect.height);
clutter_actor_set_position (flash,
window->custom_frame_extents.left,
window->custom_frame_extents.top);
clutter_actor_set_opacity (flash, 0);
clutter_actor_add_child (window_actor, flash);
clutter_actor_save_easing_state (flash);
clutter_actor_set_easing_mode (flash, CLUTTER_EASE_IN_QUAD);
clutter_actor_set_easing_duration (flash, FLASH_TIME_MS);
clutter_actor_set_opacity (flash, 192);
transition = clutter_actor_get_transition (flash, "opacity");
clutter_timeline_set_auto_reverse (CLUTTER_TIMELINE (transition), TRUE);
clutter_timeline_set_repeat_count (CLUTTER_TIMELINE (transition), 2);
g_signal_connect (transition, "stopped",
G_CALLBACK (window_flash_out_completed), flash);
clutter_actor_restore_easing_state (flash);
}
static void
mx_notebook_update_children (MxNotebook *book)
{
MxNotebookPrivate *priv = book->priv;
GList *l;
for (l = priv->children; l; l = l->next)
{
ClutterActor *child = CLUTTER_ACTOR (l->data);
if (child == priv->current_page)
{
clutter_actor_show (child);
clutter_actor_save_easing_state (child);
clutter_actor_set_easing_mode (child, CLUTTER_LINEAR);
clutter_actor_set_easing_duration (child, 250);
clutter_actor_set_opacity (child, 0xff);
clutter_actor_restore_easing_state (child);
g_signal_connect (child, "transition-stopped::opacity",
G_CALLBACK (mx_notebook_show_complete_cb), book);
}
}
}
void
meta_compositor_flash_screen (MetaCompositor *compositor,
MetaScreen *screen)
{
ClutterActor *stage;
ClutterActor *flash;
ClutterTransition *transition;
gfloat width, height;
stage = meta_get_stage_for_screen (screen);
clutter_actor_get_size (stage, &width, &height);
flash = clutter_actor_new ();
clutter_actor_set_background_color (flash, CLUTTER_COLOR_Black);
clutter_actor_set_size (flash, width, height);
clutter_actor_set_opacity (flash, 0);
clutter_actor_add_child (stage, flash);
clutter_actor_save_easing_state (flash);
clutter_actor_set_easing_mode (flash, CLUTTER_EASE_IN_QUAD);
clutter_actor_set_easing_duration (flash, FLASH_TIME_MS);
clutter_actor_set_opacity (flash, 192);
transition = clutter_actor_get_transition (flash, "opacity");
clutter_timeline_set_auto_reverse (CLUTTER_TIMELINE (transition), TRUE);
clutter_timeline_set_repeat_count (CLUTTER_TIMELINE (transition), 2);
g_signal_connect (transition, "stopped",
G_CALLBACK (flash_out_completed), flash);
clutter_actor_restore_easing_state (flash);
}
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);
}
}
void map(MetaPlugin *plugin, MetaWindowActor *window_actor)
{
ClutterActor *actor = CLUTTER_ACTOR(window_actor);
clutter_actor_remove_all_transitions(actor);
switch (MWT(window_actor)) {
case META_WINDOW_POPUP_MENU:
case META_WINDOW_DROPDOWN_MENU:
case META_WINDOW_NOTIFICATION:
case META_WINDOW_MENU:
/* For menus we'll give em a nice fade in */
g_object_set(actor, "opacity", 0, NULL);
clutter_actor_show(actor);
clutter_actor_save_easing_state(actor);
clutter_actor_set_easing_mode(actor, CLUTTER_EASE_IN_SINE);
clutter_actor_set_easing_duration(actor, FADE_TIMEOUT);
g_signal_connect(actor, "transitions-completed", G_CALLBACK(map_done), plugin);
g_object_set(actor, "opacity", 255, NULL);
clutter_actor_restore_easing_state(actor);
break;
case META_WINDOW_NORMAL:
case META_WINDOW_DIALOG:
case META_WINDOW_MODAL_DIALOG:
g_object_set(actor, "opacity", 0, "scale-x", MAP_SCALE, "scale-y", MAP_SCALE, "pivot-point", &PV_CENTER, NULL);
clutter_actor_show(actor);
/* Initialise animation */
clutter_actor_save_easing_state(actor);
clutter_actor_set_easing_mode(actor, CLUTTER_EASE_IN_SINE);
clutter_actor_set_easing_duration(actor, MAP_TIMEOUT);
g_signal_connect(actor, "transitions-completed", G_CALLBACK(map_done), plugin);
/* Now animate. */
g_object_set(actor, "scale-x", 1.0, "scale-y", 1.0, "opacity", 255, NULL);
clutter_actor_restore_easing_state(actor);
break;
default:
meta_plugin_map_completed(plugin, window_actor);
break;
}
}
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
plate5anim (ClutterTimeline *timeline,
const gchar *marker_name,
guint frame_num,
ClutterActor *lowerInner)
{
clutter_actor_save_easing_state (lowerInner);
clutter_actor_set_easing_duration (lowerInner, 875);
clutter_actor_set_easing_mode (lowerInner, CLUTTER_EASE_OUT_EXPO);
clutter_actor_set_position(lowerInner, 0, 0);
clutter_actor_restore_easing_state (lowerInner);
}
static void
plate4anim (ClutterTimeline *timeline,
const gchar *marker_name,
guint frame_num,
ClutterActor *fixed)
{
clutter_actor_save_easing_state (fixed);
clutter_actor_set_easing_duration (fixed, 1250);
clutter_actor_set_easing_mode (fixed, CLUTTER_EASE_OUT_EXPO);
clutter_actor_set_position(fixed, 0, 0);
clutter_actor_restore_easing_state (fixed);
}
static void
plate1anim (ClutterTimeline *timeline,
const gchar *marker_name,
guint frame_num,
ClutterActor *bg)
{
clutter_actor_set_easing_duration (bg, 750);
clutter_actor_save_easing_state (bg);
clutter_actor_set_easing_mode (bg, CLUTTER_EASE_OUT_CIRC);
clutter_actor_set_x_align (bg, CLUTTER_ACTOR_ALIGN_FILL);
clutter_actor_restore_easing_state (bg);
}
static void
plate3anim (ClutterTimeline *timeline,
const gchar *marker_name,
guint frame_num,
ClutterActor *labelbg)
{
clutter_actor_save_easing_state (labelbg);
clutter_actor_set_easing_duration (labelbg, 583);
clutter_actor_set_easing_mode (labelbg, CLUTTER_EASE_OUT_CUBIC);
clutter_actor_set_width(labelbg, 400);
clutter_actor_restore_easing_state (labelbg);
}
static gboolean
on_box_leave (ClutterActor *box,
ClutterEvent *event,
ClutterActor *emblem)
{
clutter_actor_save_easing_state (emblem);
clutter_actor_set_easing_mode (emblem, CLUTTER_LINEAR);
clutter_actor_set_opacity (emblem, 0);
clutter_actor_restore_easing_state (emblem);
return CLUTTER_EVENT_STOP;
}
static void
mx_tooltip_set_opacity (MxTooltip *tooltip,
guchar opacity)
{
ClutterActor *self = CLUTTER_ACTOR (tooltip);
clutter_actor_save_easing_state (self);
clutter_actor_set_easing_mode (self, CLUTTER_EASE_OUT_QUAD);
clutter_actor_set_easing_duration (self, 150);
clutter_actor_set_opacity (self, opacity);
clutter_actor_restore_easing_state (self);
}
static gboolean
on_box_enter (ClutterActor *box,
ClutterEvent *event,
ClutterActor *emblem)
{
/* we ease the opacity linearly */
clutter_actor_save_easing_state (emblem);
clutter_actor_set_easing_mode (emblem, CLUTTER_LINEAR);
clutter_actor_set_opacity (emblem, 255);
clutter_actor_restore_easing_state (emblem);
return CLUTTER_EVENT_STOP;
}
void destroy(MetaPlugin *plugin, MetaWindowActor *window_actor)
{
ClutterActor *actor = CLUTTER_ACTOR(window_actor);
clutter_actor_remove_all_transitions(actor);
switch (MWT(window_actor)) {
case META_WINDOW_NOTIFICATION:
case META_WINDOW_NORMAL:
case META_WINDOW_DIALOG:
case META_WINDOW_MODAL_DIALOG:
/* Initialise animation */
g_object_set(actor, "pivot-point", &PV_CENTER, NULL);
clutter_actor_save_easing_state(actor);
clutter_actor_set_easing_mode(actor, CLUTTER_EASE_OUT_QUAD);
clutter_actor_set_easing_duration(actor, DESTROY_TIMEOUT);
g_signal_connect(actor, "transitions-completed", G_CALLBACK(destroy_done), plugin);
/* Now animate. */
g_object_set(actor, "scale-x", DESTROY_SCALE, "scale-y", DESTROY_SCALE, "opacity", 0, NULL);
clutter_actor_restore_easing_state(actor);
break;
case META_WINDOW_MENU:
/* Initialise animation */
clutter_actor_save_easing_state(actor);
clutter_actor_set_easing_mode(actor, CLUTTER_EASE_OUT_QUAD);
clutter_actor_set_easing_duration(actor, DESTROY_TIMEOUT);
g_signal_connect(actor, "transitions-completed", G_CALLBACK(destroy_done), plugin);
/* Now animate. */
g_object_set(actor, "opacity", 0, NULL);
clutter_actor_restore_easing_state(actor);
break;
default:
meta_plugin_destroy_completed(plugin, window_actor);
break;
}
}
static void place_window(MosesOverview* self, ClutterActor* actor, MetaRectangle rect)
{
g_debug("%s: %d,%d,%d,%d", __func__, rect.x, rect.y, rect.width, rect.height);
float fscale = rect.width / clutter_actor_get_width(actor);
clutter_actor_save_easing_state(actor);
clutter_actor_set_easing_mode(actor, CLUTTER_EASE_OUT_CUBIC);
clutter_actor_set_easing_duration(actor, PLACEMENT_ANIMATION_DURATION);
clutter_actor_set_scale(actor, fscale, fscale);
clutter_actor_set_position(actor, rect.x, rect.y);
/*clutter_actor_set_size(actor, rect.width, rect.height);*/
clutter_actor_restore_easing_state(actor);
}
static void
mx_menu_close (ClutterActor *menu)
{
ClutterActor *actor = (ClutterActor *) menu;
clutter_actor_save_easing_state (actor);
clutter_actor_set_easing_mode (actor, CLUTTER_LINEAR);
clutter_actor_set_easing_duration (actor, 250);
clutter_actor_set_opacity (actor, 0);
clutter_actor_restore_easing_state (actor);
g_signal_connect (actor, "transition-stopped::opacity",
G_CALLBACK (mx_menu_close_complete), NULL);
clutter_actor_set_reactive ((ClutterActor*) menu, FALSE);
}
static void
on_target_over (ClutterDropAction *action,
ClutterActor *actor,
gpointer _data)
{
gboolean is_over = GPOINTER_TO_UINT (_data);
guint8 final_opacity = is_over ? 128 : 64;
ClutterActor *target;
target = clutter_actor_meta_get_actor (CLUTTER_ACTOR_META (action));
clutter_actor_save_easing_state (target);
clutter_actor_set_easing_mode (target, CLUTTER_LINEAR);
clutter_actor_set_opacity (target, final_opacity);
clutter_actor_restore_easing_state (target);
}
static void on_window_removed(MetaWorkspace *ws, MetaWindow *win, MetaSwitcher* self)
{
g_debug("%s", __func__);
MetaSwitcherPrivate* priv = self->priv;
ClutterActor* win_actor = NULL;
gboolean need_reselect = FALSE;
int id = 0;
for (id = 0; id < priv->apps->len; id++) {
if (g_ptr_array_index(priv->apps, id) == win) {
win_actor = g_hash_table_lookup(priv->icons, win);
need_reselect = (id == priv->selected_id);
}
}
if (win_actor) {
if (need_reselect)
_set_highlight(self, priv->selected_id, FALSE);
g_hash_table_remove(priv->icons, win);
g_ptr_array_remove(priv->apps, win);
if (need_reselect) {
if (id == 0) {
clutter_actor_set_margin_left(
g_hash_table_lookup(priv->icons, g_ptr_array_index(priv->apps, 0)), 10);
} else if (id >= priv->apps->len) {
clutter_actor_set_margin_right(
g_hash_table_lookup(priv->icons, g_ptr_array_index(priv->apps, priv->apps->len-1)), 10);
}
priv->selected_id = (priv->selected_id + 1) % priv->apps->len;
_set_highlight(self, priv->selected_id, TRUE);
}
clutter_actor_save_easing_state(priv->top);
clutter_actor_set_easing_duration(priv->top, 200);
clutter_actor_set_easing_mode(priv->top, CLUTTER_LINEAR);
clutter_actor_remove_child(priv->top, win_actor);
clutter_actor_restore_easing_state(priv->top);
reposition_switcher(self);
}
}
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
timeline_complete (ClutterTimeline *timeline,
ClutterActor *expander)
{
guchar opacity;
MxExpanderPrivate *priv = MX_EXPANDER (expander)->priv;
g_signal_emit (expander, expander_signals[EXPAND_COMPLETE], 0);
/* if the expander is now closed, update the style */
if (!priv->expanded)
{
clutter_actor_set_name (priv->arrow, "mx-expander-arrow-closed");
mx_stylable_set_style_class (MX_STYLABLE (expander), "closed-expander");
clutter_actor_queue_relayout (expander);
}
if (!priv->child)
return;
/* continue only if we are "opening" */
if (!priv->expanded)
return;
/* we can't do an animation if there is already one in progress,
* because we cannot get the actors original opacity */
if (clutter_actor_get_transition (priv->child, "opacity"))
{
clutter_actor_show (priv->child);
return;
}
opacity = clutter_actor_get_opacity (priv->child);
clutter_actor_set_opacity (priv->child, 0);
clutter_actor_show (priv->child);
clutter_actor_save_easing_state (priv->child);
clutter_actor_set_easing_mode (priv->child, CLUTTER_EASE_IN_SINE);
clutter_actor_set_easing_duration (priv->child, 100);
clutter_actor_set_opacity (priv->child, opacity);
clutter_actor_restore_easing_state (priv->child);
}
static void
on_emblem_clicked (ClutterClickAction *action,
ClutterActor *emblem,
ClutterActor *box)
{
/* we add a little bounce to the resizing of the box */
clutter_actor_save_easing_state (box);
clutter_actor_set_easing_mode (box, CLUTTER_EASE_OUT_BOUNCE);
clutter_actor_set_easing_duration (box, 500);
if (!is_expanded)
clutter_actor_set_size (box, 400, 400);
else
clutter_actor_set_size (box, 200, 200);
clutter_actor_restore_easing_state (box);
is_expanded = !is_expanded;
}
//FIXME: ClutterClone seems to have problem rendering children, so badges are stay in grandpar
static void create_window_badge(MosesOverview* self, ClutterActor* parent, int order)
{
ClutterActor* badge = clutter_actor_new();
clutter_actor_insert_child_above(clutter_actor_get_parent(parent), badge, NULL);
gfloat tw, th;
clutter_actor_get_transformed_size(parent, &tw, &th);
gfloat w = 60.0, h = 60.0,
x = (tw - w) / 2.0 + clutter_actor_get_x(parent),
y = (th - h) / 2.0 + clutter_actor_get_y(parent);
clutter_actor_set_position(badge, x, y);
clutter_actor_set_size(badge, w, h);
g_object_set_qdata(G_OBJECT(badge), moses_overview_window_clone_order(), GINT_TO_POINTER(order));
g_object_set_qdata(G_OBJECT(parent), moses_overview_window_clone_order(), GINT_TO_POINTER(order));
ClutterContent* canvas = clutter_canvas_new();
clutter_canvas_set_size(CLUTTER_CANVAS(canvas), w, h);
clutter_actor_set_content(badge, canvas);
g_object_unref(canvas);
g_signal_connect(canvas, "draw", G_CALLBACK(on_badge_draw), badge);
clutter_content_invalidate(canvas);
clutter_actor_set_scale(badge, 0.0, 0.0);
//do animated show
clutter_actor_save_easing_state(badge);
clutter_actor_set_easing_mode(badge, CLUTTER_EASE_OUT_BACK);
clutter_actor_set_easing_duration(badge, 350);
clutter_actor_set_pivot_point(badge, 0.5, 0.5);
clutter_actor_set_scale(badge, 1.0, 1.0);
clutter_actor_restore_easing_state(badge);
g_ptr_array_add(self->priv->badges, badge);
}
static void
mnb_zones_preview_completed_cb (ClutterAnimation *animation,
MnbZonesPreview *preview)
{
MnbZonesPreviewPrivate *priv = preview->priv;
switch (priv->anim_phase)
{
case MNB_ZP_STATIC:
/* Start zooming out */
priv->anim_phase = MNB_ZP_ZOOM_OUT;
mnb_zones_preview_enable_fanciness (preview, TRUE);
clutter_actor_save_easing_state (CLUTTER_ACTOR(preview));
clutter_actor_set_easing_duration (CLUTTER_ACTOR(preview), 220);
clutter_actor_set_easing_mode(CLUTTER_ACTOR(preview), CLUTTER_EASE_IN_SINE);
clutter_actor_set_scale(CLUTTER_ACTOR(preview), 0.3f, 0.3f);
clutter_actor_restore_easing_state (CLUTTER_ACTOR(preview));
break;
case MNB_ZP_ZOOM_OUT:
/* Start panning */
{
guint duration = 175 * abs (priv->dest_workspace - priv->workspace);
if (duration)
{
priv->anim_phase = MNB_ZP_PAN;
clutter_actor_save_easing_state (CLUTTER_ACTOR(preview));
clutter_actor_set_easing_duration (CLUTTER_ACTOR(preview), duration);
clutter_actor_set_easing_mode(CLUTTER_ACTOR(preview), CLUTTER_LINEAR);
clutter_actor_set_scale(CLUTTER_ACTOR(preview), (gdouble)priv->dest_workspace, (gdouble)priv->dest_workspace);
clutter_actor_restore_easing_state (CLUTTER_ACTOR(preview));
break;
}
/* If duration == 0, fall through here to the next phase*/
}
case MNB_ZP_PAN:
/* Start zooming in */
mnb_zones_preview_enable_fanciness (preview, FALSE);
priv->anim_phase = MNB_ZP_ZOOM_IN;
clutter_actor_save_easing_state (CLUTTER_ACTOR(preview));
clutter_actor_set_easing_duration (CLUTTER_ACTOR(preview), 250);
clutter_actor_set_easing_mode(CLUTTER_ACTOR(preview), CLUTTER_EASE_OUT_CUBIC);
clutter_actor_set_scale(CLUTTER_ACTOR(preview), 1.0f, 1.0f);
clutter_actor_restore_easing_state (CLUTTER_ACTOR(preview));
break;
case MNB_ZP_ZOOM_IN:
/* Complete the animation */
priv->anim_phase = MNB_ZP_STATIC;
g_signal_emit (preview, signals[SWITCH_COMPLETED], 0);
return;
default:
g_warning (G_STRLOC ": This shouldn't happen");
return;
}
animation = clutter_actor_get_animation (CLUTTER_ACTOR (preview));
g_signal_connect_after (animation, "completed",
G_CALLBACK (mnb_zones_preview_completed_cb), preview);
}
static void
clutter_bin_layout_allocate (ClutterLayoutManager *manager,
ClutterContainer *container,
const ClutterActorBox *allocation,
ClutterAllocationFlags flags)
{
gfloat allocation_x, allocation_y;
gfloat available_w, available_h;
ClutterActor *actor, *child;
ClutterActorIter iter;
gboolean use_animations;
ClutterAnimationMode easing_mode;
guint easing_duration, easing_delay;
clutter_actor_box_get_origin (allocation, &allocation_x, &allocation_y);
clutter_actor_box_get_size (allocation, &available_w, &available_h);
actor = CLUTTER_ACTOR (container);
use_animations = clutter_layout_manager_get_easing_state (manager,
&easing_mode,
&easing_duration,
&easing_delay);
clutter_actor_iter_init (&iter, actor);
while (clutter_actor_iter_next (&iter, &child))
{
ClutterLayoutMeta *meta;
ClutterBinLayer *layer;
ClutterActorBox child_alloc = { 0, };
gdouble x_align, y_align;
gboolean x_fill, y_fill;
meta = clutter_layout_manager_get_child_meta (manager,
container,
child);
layer = CLUTTER_BIN_LAYER (meta);
if (layer->x_align == CLUTTER_BIN_ALIGNMENT_FIXED)
child_alloc.x1 = clutter_actor_get_x (child);
else
child_alloc.x1 = allocation_x;
if (layer->y_align == CLUTTER_BIN_ALIGNMENT_FIXED)
child_alloc.y1 = clutter_actor_get_y (child);
else
child_alloc.y1 = allocation_y;
child_alloc.x2 = available_w;
child_alloc.y2 = available_h;
if (clutter_actor_needs_expand (child, CLUTTER_ORIENTATION_HORIZONTAL))
{
ClutterActorAlign align;
align = _clutter_actor_get_effective_x_align (child);
x_fill = align == CLUTTER_ACTOR_ALIGN_FILL;
x_align = get_actor_align_factor (align);
}
else
{
x_fill = (layer->x_align == CLUTTER_BIN_ALIGNMENT_FILL);
x_align = get_bin_alignment_factor (layer->x_align);
}
if (clutter_actor_needs_expand (child, CLUTTER_ORIENTATION_VERTICAL))
{
ClutterActorAlign align;
align = clutter_actor_get_y_align (child);
y_fill = align == CLUTTER_ACTOR_ALIGN_FILL;
y_align = get_actor_align_factor (align);
}
else
{
y_fill = (layer->y_align == CLUTTER_BIN_ALIGNMENT_FILL);
y_align = get_bin_alignment_factor (layer->y_align);
}
if (use_animations)
{
clutter_actor_save_easing_state (child);
clutter_actor_set_easing_mode (child, easing_mode);
clutter_actor_set_easing_duration (child, easing_duration);
clutter_actor_set_easing_delay (child, easing_delay);
}
clutter_actor_allocate_align_fill (child, &child_alloc,
x_align, y_align,
x_fill, y_fill,
flags);
if (use_animations)
clutter_actor_restore_easing_state (child);
}
}
void
ntf_tray_add_notification (NtfTray *tray, NtfNotification *ntf)
{
NtfTrayPrivate *priv;
ClutterActor *ntfa;
ClutterAnimation *anim;
MetaPlugin *plugin;
g_return_if_fail (NTF_IS_TRAY (tray) && NTF_IS_NOTIFICATION (ntf));
priv = tray->priv;
ntfa = CLUTTER_ACTOR (ntf);
plugin = meego_netbook_get_plugin_singleton ();
if (meego_netbook_compositor_disabled (plugin))
{
mnb_notification_gtk_show ();
}
g_signal_connect (ntf, "closed",
G_CALLBACK (ntf_tray_notification_closed_cb),
tray);
clutter_actor_add_child (CLUTTER_ACTOR (priv->notifiers), ntfa);
clutter_actor_set_width (ntfa, CLUSTER_WIDTH);
priv->n_notifiers++;
if (priv->n_notifiers == 1)
{
/* May have been previously hidden */
clutter_actor_show (CLUTTER_ACTOR (tray));
/* show just the single notification */
priv->active_notifier = ntfa;
clutter_actor_set_opacity (ntfa, 0);
clutter_actor_save_easing_state (ntfa);
clutter_actor_set_easing_duration (ntfa, FADE_DURATION);
clutter_actor_set_easing_mode(ntfa, CLUTTER_EASE_IN_SINE);
clutter_actor_set_y(ntfa, 0xff);
clutter_actor_restore_easing_state (ntfa);
}
else if (priv->n_notifiers == 2)
{
/* slide the control into view */
mx_label_set_text (MX_LABEL(priv->control_text),
_("1 pending message"));
clutter_actor_show (priv->control);
clutter_actor_set_opacity (priv->control, 0);
clutter_actor_set_y (priv->control,
clutter_actor_get_height (priv->active_notifier)
- clutter_actor_get_height (priv->control) - 30);
anim = clutter_actor_animate (priv->control,
CLUTTER_EASE_IN_SINE,
FADE_DURATION,
"opacity", 0xff,
"y", clutter_actor_get_height
(priv->active_notifier)- 30,
NULL);
}
else
{
/* simply update the control */
gchar *msg;
msg = g_strdup_printf (_("%i pending messages"), priv->n_notifiers-1);
mx_label_set_text (MX_LABEL (priv->control_text), msg);
g_free (msg);
}
}
static void
ntf_tray_notification_closed_cb (NtfNotification *ntf, NtfTray *tray)
{
NtfTrayPrivate *priv = tray->priv;
ClutterActor *ntfa = CLUTTER_ACTOR (ntf);
ClutterAnimation *anim;
priv->n_notifiers--;
if (priv->n_notifiers < 0)
{
g_warning ("Bug in notifier accounting, attempting to fix");
priv->n_notifiers = 0;
}
/* fade out closed notifier */
if (ntfa == priv->active_notifier)
{
anim = clutter_actor_animate (CLUTTER_ACTOR (ntfa),
CLUTTER_EASE_IN_SINE,
FADE_DURATION,
"opacity", 0,
NULL);
g_signal_connect_after (anim,
"completed",
G_CALLBACK
(ntf_tray_hide_ntf_completed_cb),
tray);
}
else
{
clutter_actor_destroy (ntfa);
}
/* Fade in newer notifier from below stack */
if (ntfa == priv->active_notifier && priv->n_notifiers > 0)
{
gint prev_height, new_height;
prev_height = clutter_actor_get_height (ntfa);
priv->active_notifier =
clutter_actor_get_child_at_index (CLUTTER_ACTOR (priv->notifiers),
1); /* Next, not 0 */
if (priv->active_notifier)
{
clutter_actor_set_opacity (priv->active_notifier, 0);
clutter_actor_show (CLUTTER_ACTOR (priv->active_notifier));
clutter_actor_save_easing_state (priv->active_notifier);
clutter_actor_set_easing_duration (priv->active_notifier, FADE_DURATION);
clutter_actor_set_easing_mode(priv->active_notifier, CLUTTER_EASE_IN_SINE);
clutter_actor_set_opacity(priv->active_notifier, 0xff);
clutter_actor_restore_easing_state (priv->active_notifier);
new_height = clutter_actor_get_height (priv->active_notifier);
if (prev_height != new_height && priv->n_notifiers > 1)
{
gfloat new_y;
new_y = clutter_actor_get_y (priv->control)
- (prev_height - new_height);
clutter_actor_save_easing_state (priv->control);
clutter_actor_set_easing_duration (priv->control, FADE_DURATION);
clutter_actor_set_easing_mode(priv->control, CLUTTER_EASE_IN_SINE);
clutter_actor_set_y(priv->control, new_y);
clutter_actor_restore_easing_state (priv->control);
}
}
}
if (priv->n_notifiers == 0)
{
priv->active_notifier = NULL;
mnb_notification_gtk_hide ();
}
else if (priv->n_notifiers == 1)
{
/* slide the control out of view */
ClutterAnimation *anim;
anim = clutter_actor_animate (priv->control,
CLUTTER_EASE_IN_SINE,
FADE_DURATION,
"opacity", 0x0,
"y",
clutter_actor_get_height (priv->active_notifier)
- clutter_actor_get_height (priv->control),
NULL);
g_signal_connect_after (anim,
"completed",
G_CALLBACK
(ntf_tray_control_hide_completed_cb),
tray);
}
else
{
/* Just Update control text */
gchar *msg;
msg = g_strdup_printf (_("%i pending messages"), priv->n_notifiers);
mx_label_set_text (MX_LABEL (priv->control_text), msg);
g_free (msg);
}
}
static void
bjb_editor_toolbar_init (BjbEditorToolbar *self)
{
BjbEditorToolbarPrivate *priv;
GtkWidget *bin;
GtkWidget *image;
GdkPixbuf *pixbuf;
GtkStyleContext *context;
GdkRGBA transparent = {0.0, 0.0, 0.0, 0.0};
GdkRGBA black = {0.0, 0.0, 0.0, 0.6};
gchar *icons_path, *full_path;
GError *error = NULL;
self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, BJB_TYPE_EDITOR_TOOLBAR, BjbEditorToolbarPrivate);
priv = self->priv;
priv->accel = gtk_accel_group_new ();
priv->widget = gtk_box_new (GTK_ORIENTATION_HORIZONTAL,0);
context = gtk_widget_get_style_context (priv->widget);
gtk_style_context_add_class (context, "osd");
gtk_style_context_add_class (context, "toolbar");
priv->actor = gtk_clutter_actor_new_with_contents (priv->widget);
clutter_actor_set_opacity (priv->actor, 0);
g_object_set (priv->actor, "show-on-set-parent", FALSE, NULL);
clutter_actor_set_easing_mode (priv->actor, CLUTTER_EASE_IN_QUAD);
clutter_actor_set_easing_duration (priv->actor, 300.0);
bin = gtk_clutter_actor_get_widget (GTK_CLUTTER_ACTOR (priv->actor));
gtk_widget_override_background_color (bin,
GTK_STATE_FLAG_NORMAL,
&transparent);
priv->box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
priv->group = gtk_tool_item_new ();
gtk_container_add (GTK_CONTAINER (priv->group), priv->box);
gtk_container_add (GTK_CONTAINER (priv->widget), GTK_WIDGET(priv->group));
gtk_widget_show_all (GTK_WIDGET (priv->group));
/* Cut */
priv->toolbar_cut = gtk_button_new_with_label ("Cut");
gtk_container_add (GTK_CONTAINER (priv->box), priv->toolbar_cut);
gtk_widget_override_background_color (priv->toolbar_cut,
GTK_STATE_FLAG_NORMAL,
&black);
/* Copy */
priv->toolbar_copy = gtk_button_new_with_label ("Copy");
gtk_container_add (GTK_CONTAINER (priv->box), priv->toolbar_copy);
gtk_widget_override_background_color (priv->toolbar_copy,
GTK_STATE_FLAG_NORMAL,
&black);
/* 'n paste */
priv->toolbar_paste = gtk_button_new_with_label ("Paste");
gtk_container_add (GTK_CONTAINER (priv->box), priv->toolbar_paste);
gtk_widget_override_background_color (priv->toolbar_paste,
GTK_STATE_FLAG_NORMAL,
&black);
/* GtkWidget *toolbar_bold */
priv->toolbar_bold = gtk_button_new ();
image = gtk_image_new_from_icon_name ("gtk-bold", GTK_ICON_SIZE_INVALID);
gtk_image_set_pixel_size (GTK_IMAGE (image), 24);
gtk_container_add (GTK_CONTAINER (priv->toolbar_bold), image);
gtk_widget_set_tooltip_text (GTK_WIDGET (priv->toolbar_bold), _("Bold"));
gtk_container_add (GTK_CONTAINER (priv->box), priv->toolbar_bold);
gtk_widget_override_background_color (priv->toolbar_bold,
GTK_STATE_FLAG_NORMAL,
&black);
/* GtkWidget *toolbar_italic; */
priv->toolbar_italic = gtk_button_new ();
image = gtk_image_new_from_icon_name ("gtk-italic", GTK_ICON_SIZE_INVALID);
gtk_image_set_pixel_size (GTK_IMAGE (image), 24);
gtk_container_add (GTK_CONTAINER (priv->toolbar_italic), image);
gtk_widget_set_tooltip_text (GTK_WIDGET (priv->toolbar_italic), _("Italic"));
gtk_container_add (GTK_CONTAINER (priv->box), priv->toolbar_italic);
gtk_widget_override_background_color (priv->toolbar_italic,
GTK_STATE_FLAG_NORMAL,
&black);
/* GtkWidget *toolbar_strike; */
priv->toolbar_strike = gtk_button_new ();
image = gtk_image_new_from_icon_name ("gtk-strikethrough", GTK_ICON_SIZE_INVALID);
gtk_image_set_pixel_size (GTK_IMAGE (image), 24);
gtk_container_add (GTK_CONTAINER (priv->toolbar_strike), image);
gtk_widget_set_tooltip_text (GTK_WIDGET (priv->toolbar_strike), _("Strike"));
gtk_container_add (GTK_CONTAINER (priv->box), priv->toolbar_strike);
gtk_widget_override_background_color (priv->toolbar_strike,
GTK_STATE_FLAG_NORMAL,
&black);
/* GtkWidget *toolbar_link; */
priv->toolbar_link = gtk_button_new ();
icons_path = (gchar*) bijiben_get_bijiben_dir ();
full_path = g_build_filename (icons_path,
"bijiben",
"icons",
"hicolor",
"scalable",
"actions",
"link.svg",
NULL);
pixbuf = gdk_pixbuf_new_from_file (full_path, &error);
g_free (full_path);
if (error)
g_warning ("error loading link icon : %s",error->message);
image = gtk_image_new_from_pixbuf (pixbuf);
gtk_image_set_pixel_size (GTK_IMAGE (image), 24);
gtk_container_add (GTK_CONTAINER (priv->toolbar_link), image);
gtk_widget_set_tooltip_text (GTK_WIDGET (priv->toolbar_link), _("Link"));
gtk_container_add (GTK_CONTAINER (priv->box), priv->toolbar_link);
gtk_widget_override_background_color (priv->toolbar_link,
GTK_STATE_FLAG_NORMAL,
&black);
priv->glued = FALSE;
gtk_widget_show_all (GTK_WIDGET(priv->group));
clutter_actor_show (priv->actor);
}
