brl/mutter
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
ca539199b2
mutter/src/compositor.c
Søren Sandmann ca539199b2 Add unused wobbly unminimize animation by Kristian 
Wed Feb 15 14:47:50 2006  Søren Sandmann  <sandmann@redhat.com>

	* src/compositor.c (meta_compositor_unminimize): Add unused wobbly
	unminimize animation by Kristian

	* src/compositor.c (meta_compositor_minimize): Add wobbly minimize
	animation by Kristian.

	* src/compositor.c: Add support for turning updates on and off.

	* src/window.c (meta_window_move_resize_internal): Use
	sync counter to make composited resizing tear free
2006-02-15 19:50:12 +00:00

1984 lines
45 KiB
C
Raw Blame History

/*
* Copyright (C) 2003, 2004, 2005, 2006 Red Hat, Inc.
* Copyright (C) 2003 Keith Packard
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
* 02111-1307, USA.
*/
#include <config.h>
#include "compositor.h"
#include "screen.h"
#include "errors.h"
#include "window.h"
#include "frame.h"
#include "workspace.h"
#include <math.h>
#include <stdlib.h>
#ifdef HAVE_COMPOSITE_EXTENSIONS
#include <cm/node.h>
#include <cm/drawable-node.h>
#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glx.h>
#include <cm/ws.h>
#include <cm/wsint.h>
#include <X11/extensions/shape.h>
#include <X11/extensions/Xcomposite.h>
#include <X11/extensions/Xdamage.h>
#include <X11/extensions/Xfixes.h>
#include <X11/extensions/Xrender.h>
#endif /* HAVE_COMPOSITE_EXTENSIONS */
#define FRAME_INTERVAL_MILLISECONDS ((int)(1000.0/40.0))
#ifdef HAVE_COMPOSITE_EXTENSIONS
/* Screen specific information */
typedef struct
{
/* top of stack is first in list */
GList *compositor_nodes;
WsWindow *glw;
int idle_id;
} ScreenInfo;
struct MetaCompositor
{
MetaDisplay *meta_display;
WsDisplay *display;
GHashTable *window_hash;
guint repair_idle;
guint enabled : 1;
guint have_composite : 1;
guint have_damage : 1;
guint have_fixes : 1;
guint have_name_window_pixmap : 1;
guint debug_updates : 1;
GList *ignored_damage;
};
#endif /* HAVE_COMPOSITE_EXTENSIONS */
#ifdef HAVE_COMPOSITE_EXTENSIONS
static void
free_window_hash_value (void *v)
{
CmDrawableNode *drawable_node = v;
g_object_unref (G_OBJECT (drawable_node));
}
#endif /* HAVE_COMPOSITE_EXTENSIONS */
MetaCompositor*
meta_compositor_new (MetaDisplay *display)
{
#ifdef HAVE_COMPOSITE_EXTENSIONS
MetaCompositor *compositor;
compositor = g_new0 (MetaCompositor, 1);
compositor->display = ws_display_new (NULL);
ws_display_set_synchronize (compositor->display,
getenv ("METACITY_SYNC") != NULL);
ws_display_init_test (compositor->display);
ws_display_set_ignore_grabs (compositor->display, TRUE);
compositor->meta_display = display;
compositor->window_hash = g_hash_table_new_full (
meta_unsigned_long_hash,
meta_unsigned_long_equal,
NULL,
free_window_hash_value);
compositor->enabled = TRUE;
return compositor;
#else /* HAVE_COMPOSITE_EXTENSIONS */
return NULL;
#endif /* HAVE_COMPOSITE_EXTENSIONS */
}
void
meta_compositor_set_debug_updates (MetaCompositor *compositor,
gboolean debug_updates)
{
#ifdef HAVE_COMPOSITE_EXTENSIONS
compositor->debug_updates = !!debug_updates;
#endif /* HAVE_COMPOSITE_EXTENSIONS */
}
#ifdef HAVE_COMPOSITE_EXTENSIONS
static void
remove_repair_idle (MetaCompositor *compositor)
{
if (compositor->repair_idle)
{
meta_topic (META_DEBUG_COMPOSITOR, "Damage idle removed\n");
g_source_remove (compositor->repair_idle);
compositor->repair_idle = 0;
}
}
#endif /* HAVE_COMPOSITE_EXTENSIONS */
void
meta_compositor_unref (MetaCompositor *compositor)
{
#ifdef HAVE_COMPOSITE_EXTENSIONS
/* There isn't really a refcount at the moment since
* there's no ref()
*/
remove_repair_idle (compositor);
if (compositor->window_hash)
g_hash_table_destroy (compositor->window_hash);
g_free (compositor);
#endif /* HAVE_COMPOSITE_EXTENSIONS */
}
#ifdef HAVE_COMPOSITE_EXTENSIONS
static void
draw_windows (MetaScreen *screen,
GList *list)
{
CmNode *node;
if (!list)
return;
node = list->data;
draw_windows (screen, list->next);
#if 0
g_print ("rendering: %p\n", node);
#endif
cm_node_render (node);
}
static MetaScreen *
node_get_screen (Display *dpy,
CmDrawableNode *node)
{
/* FIXME: we should probably have a reverse mapping
* from nodes to screens
*/
Screen *screen = XDefaultScreenOfDisplay (dpy);
return meta_screen_for_x_screen (screen);
}
static void
handle_restacking (MetaCompositor *compositor,
CmDrawableNode *node,
CmDrawableNode *above)
{
GList *window_link, *above_link;
MetaScreen *screen;
ScreenInfo *scr_info;
screen = node_get_screen (compositor->meta_display->xdisplay, node);
scr_info = screen->compositor_data;
window_link = g_list_find (scr_info->compositor_nodes, node);
above_link = g_list_find (scr_info->compositor_nodes, above);
if (!window_link || !above_link)
return;
if (window_link == above_link)
{
/* This can happen if the topmost window is raised above
* the GL window
*/
return;
}
#if 0
g_print ("restacking\n");
#endif
if (window_link->next != above_link)
{
ScreenInfo *scr_info = screen->compositor_data;
scr_info->compositor_nodes =
g_list_delete_link (scr_info->compositor_nodes, window_link);
scr_info->compositor_nodes =
g_list_insert_before (scr_info->compositor_nodes, above_link, node);
}
}
static void
process_configure_notify (MetaCompositor *compositor,
XConfigureEvent *event)
{
WsWindow *above_window;
CmDrawableNode *node = g_hash_table_lookup (compositor->window_hash,
&event->window);
CmDrawableNode *above_node;
MetaScreen *screen;
ScreenInfo *scr_info;
#if 0
g_print ("processing configure\n");
#endif
if (!node)
return;
#if 0
g_print ("we do now have a node\n");
#endif
screen = node_get_screen (compositor->meta_display->xdisplay, node);
scr_info = screen->compositor_data;
above_window = ws_window_lookup (WS_RESOURCE (node->drawable)->display,
event->above);
if (above_window == scr_info->glw)
{
above_node = scr_info->compositor_nodes->data;
}
else
{
above_node = g_hash_table_lookup (compositor->window_hash,
&event->above);
}
handle_restacking (compositor, node, above_node);
}
#endif /* HAVE_COMPOSITE_EXTENSIONS */
#ifdef HAVE_COMPOSITE_EXTENSIONS
static void
process_expose (MetaCompositor *compositor,
XExposeEvent *event)
{
/* FIXME: queue repaint */
}
#endif /* HAVE_COMPOSITE_EXTENSIONS */
#ifdef HAVE_COMPOSITE_EXTENSIONS
static void queue_repaint (CmDrawableNode *node, gpointer data);
typedef struct
{
CmDrawableNode *node;
GTimer *timer;
} FadeInfo;
#define FADE_TIME 0.3
static gboolean
fade_in (gpointer data)
{
FadeInfo *info = data;
gdouble elapsed = g_timer_elapsed (info->timer, NULL);
gdouble alpha;
if (elapsed > FADE_TIME)
alpha = 1.0;
else
alpha = elapsed / FADE_TIME;
cm_drawable_node_set_alpha (info->node, alpha);
if (elapsed >= FADE_TIME)
{
g_object_unref (info->node);
return FALSE;
}
else
{
return TRUE;
}
}
static gboolean
fade_out (gpointer data)
{
FadeInfo *info = data;
gdouble elapsed = g_timer_elapsed (info->timer, NULL);
gdouble alpha;
if (elapsed > FADE_TIME)
alpha = 0.0;
else
alpha = 1 - (elapsed / FADE_TIME);
cm_drawable_node_set_alpha (info->node, alpha);
#if 0
g_print ("fade out: %f\n", alpha);
#endif
if (elapsed >= FADE_TIME)
{
cm_drawable_node_set_viewable (info->node, FALSE);
g_object_unref (info->node);
return FALSE;
}
else
{
return TRUE;
}
}
#endif
#ifdef HAVE_COMPOSITE_EXTENSIONS
static void
process_map (MetaCompositor *compositor,
XMapEvent *event)
{
CmDrawableNode *node;
MetaScreen *screen;
/* FIXME: do we sometimes get mapnotifies for windows that are
* not (direct) children of the root?
*/
/* See if window was mapped as child of root */
screen = meta_display_screen_for_root (compositor->meta_display,
event->event);
if (screen == NULL)
{
meta_topic (META_DEBUG_COMPOSITOR,
"MapNotify received on non-root 0x%lx for 0x%lx\n",
event->event, event->window);
return; /* MapNotify wasn't for a child of the root */
}
#if 0
g_print ("processing map for %lx\n", event->window);
#endif
node = g_hash_table_lookup (compositor->window_hash,
&event->window);
if (node == NULL)
{
XWindowAttributes attrs;
meta_error_trap_push_with_return (compositor->meta_display);
XGetWindowAttributes (compositor->meta_display->xdisplay,
event->window, &attrs);
if (meta_error_trap_pop_with_return (compositor->meta_display, TRUE) != Success)
{
meta_topic (META_DEBUG_COMPOSITOR, "Failed to get attributes for window 0x%lx\n",
event->window);
}
else
{
meta_compositor_add_window (compositor,
event->window, &attrs);
}
}
else
{
cm_drawable_node_update_pixmap (node);
cm_drawable_node_set_alpha (node, 1.0);
FadeInfo *info = g_new (FadeInfo, 1);
info->node = g_object_ref (node);
info->timer = g_timer_new ();
cm_drawable_node_set_viewable (node, TRUE);
}
queue_repaint (node, screen);
}
#endif /* HAVE_COMPOSITE_EXTENSIONS */
#ifdef HAVE_COMPOSITE_EXTENSIONS
static void
process_unmap (MetaCompositor *compositor,
XUnmapEvent *event)
{
CmDrawableNode *node;
MetaScreen *screen;
/* See if window was unmapped as child of root */
screen = meta_display_screen_for_root (compositor->meta_display,
event->event);
if (screen == NULL)
{
meta_topic (META_DEBUG_COMPOSITOR,
"UnmapNotify received on non-root 0x%lx for 0x%lx\n",
event->event, event->window);
return; /* UnmapNotify wasn't for a child of the root */
}
#if 0
g_print ("processing unmap on %lx\n", event->window);
#endif
node = g_hash_table_lookup (compositor->window_hash,
&event->window);
if (node != NULL)
{
FadeInfo *info = g_new (FadeInfo, 1);
info->node = g_object_ref (node);
info->timer = g_timer_new ();
g_idle_add (fade_out, info);
}
queue_repaint (node, screen);
}
#endif /* HAVE_COMPOSITE_EXTENSIONS */
#ifdef HAVE_COMPOSITE_EXTENSIONS
static void
process_create (MetaCompositor *compositor,
XCreateWindowEvent *event)
{
MetaScreen *screen;
XWindowAttributes attrs;
screen = meta_display_screen_for_root (compositor->meta_display,
event->parent);
if (screen == NULL)
{
meta_topic (META_DEBUG_COMPOSITOR,
"CreateNotify received on non-root 0x%lx for 0x%lx\n",
event->parent, event->window);
return;
}
meta_error_trap_push_with_return (compositor->meta_display);
XGetWindowAttributes (compositor->meta_display->xdisplay,
event->window, &attrs);
if (meta_error_trap_pop_with_return (compositor->meta_display, TRUE) != Success)
{
meta_topic (META_DEBUG_COMPOSITOR, "Failed to get attributes for window 0x%lx\n",
event->window);
}
else
{
#if 0
g_print (//META_DEBUG_COMPOSITOR,
"Create window 0x%lx, adding\n", event->window);
#endif
meta_compositor_add_window (compositor,
event->window, &attrs);
}
}
#endif /* HAVE_COMPOSITE_EXTENSIONS */
#ifdef HAVE_COMPOSITE_EXTENSIONS
static void
process_destroy (MetaCompositor *compositor,
XDestroyWindowEvent *event)
{
MetaScreen *screen;
screen = meta_display_screen_for_root (compositor->meta_display,
event->event);
if (screen == NULL)
{
meta_topic (META_DEBUG_COMPOSITOR,
"DestroyNotify received on non-root 0x%lx for 0x%lx\n",
event->event, event->window);
return;
}
meta_topic (META_DEBUG_COMPOSITOR,
"Destroy window 0x%lx\n", event->window);
meta_compositor_remove_window (compositor, event->window);
}
#endif /* HAVE_COMPOSITE_EXTENSIONS */
#ifdef HAVE_COMPOSITE_EXTENSIONS
static void
process_reparent (MetaCompositor *compositor,
XReparentEvent *event)
{
/* Reparent from one screen to another doesn't happen now, but
* it's been suggested as a future extension
*/
MetaScreen *event_screen;
MetaScreen *parent_screen;
CmDrawableNode *node;
XWindowAttributes attrs;
event_screen = meta_display_screen_for_root (compositor->meta_display,
event->event);
if (event_screen == NULL)
{
meta_topic (META_DEBUG_COMPOSITOR,
"ReparentNotify received on non-root 0x%lx for 0x%lx\n",
event->event, event->window);
return;
}
#if 0
g_print (//META_DEBUG_COMPOSITOR,
"Reparent window 0x%lx new parent 0x%lx received on 0x%lx\n",
event->window, event->parent, event->event);
#endif
parent_screen = meta_display_screen_for_root (compositor->meta_display,
event->parent);
if (parent_screen == NULL)
{
meta_topic (META_DEBUG_COMPOSITOR,
"ReparentNotify 0x%lx to a non-screen or unmanaged screen 0x%lx\n",
event->window, event->parent);
meta_compositor_remove_window (compositor, event->window);
return;
}
node = g_hash_table_lookup (compositor->window_hash,
&event->window);
meta_error_trap_push_with_return (compositor->meta_display);
XGetWindowAttributes (compositor->meta_display->xdisplay,
event->window, &attrs);
if (meta_error_trap_pop_with_return (compositor->meta_display, TRUE) != Success)
{
meta_topic (META_DEBUG_COMPOSITOR, "Failed to get attributes for window 0x%lx\n",
event->window);
}
else
{
meta_topic (META_DEBUG_COMPOSITOR,
"Reparent window 0x%lx into screen 0x%lx, adding\n",
event->window, event->parent);
meta_compositor_add_window (compositor,
event->window, &attrs);
}
}
#endif /* HAVE_COMPOSITE_EXTENSIONS */
void
meta_compositor_process_event (MetaCompositor *compositor,
XEvent *event,
MetaWindow *window)
{
#ifdef HAVE_COMPOSITE_EXTENSIONS
if (!compositor->enabled)
return; /* no extension */
/* FIXME support CirculateNotify */
if (event->type == ConfigureNotify)
{
process_configure_notify (compositor,
(XConfigureEvent*) event);
}
else if (event->type == Expose)
{
process_expose (compositor,
(XExposeEvent*) event);
}
else if (event->type == UnmapNotify)
{
process_unmap (compositor,
(XUnmapEvent*) event);
}
else if (event->type == MapNotify)
{
process_map (compositor,
(XMapEvent*) event);
}
else if (event->type == ReparentNotify)
{
process_reparent (compositor,
(XReparentEvent*) event);
}
else if (event->type == CreateNotify)
{
process_create (compositor,
(XCreateWindowEvent*) event);
}
else if (event->type == DestroyNotify)
{
process_destroy (compositor,
(XDestroyWindowEvent*) event);
}
#endif /* HAVE_COMPOSITE_EXTENSIONS */
}
#ifdef HAVE_COMPOSITE_EXTENSIONS
static void
wavy (double time,
double in_x, double in_y,
double *out_x, double *out_y,
gpointer data)
{
static int m;
time = time * 5;
double dx = 0.0025 * sin (time + 35 * in_y);
double dy = 0.0025 * cos (time + 35 * in_x);
*out_x = in_x + dx;
*out_y = in_y + dy;
m++;
}
static void
update_frame_counter (void)
{
#define BUFSIZE 128
static GTimer *timer;
static double buffer [BUFSIZE];
static int next = 0;
if (!timer)
timer = g_timer_new ();
buffer[next++] = g_timer_elapsed (timer, NULL);
if (next == BUFSIZE)
{
int i;
double total;
next = 0;
total = 0.0;
for (i = 1; i < BUFSIZE; ++i)
total += buffer[i] - buffer[i - 1];
g_print ("frames per second: %f\n", 1 / (total / (BUFSIZE - 1)));
}
}
static gboolean
update (gpointer data)
{
MetaScreen *screen = data;
ScreenInfo *scr_info = screen->compositor_data;
WsWindow *gl_window = scr_info->glw;
glViewport (0, 0, screen->rect.width, screen->rect.height);
#if 0
glColor4f (1.0, 1.0, 1.0, 1.0);
glBegin (GL_QUADS);
glVertex2f (0.0, 0.0);
glVertex2f (1600.0, 0.0);
glVertex2f (1600.0, 1200.0);
glVertex2f (0.0, 1200.0);
glEnd ();
#endif
#if 0
#endif
#if 0
glClear (GL_DEPTH_BUFFER_BIT);
#endif
#if 0
glColor4f (1.0, 0.0, 0.0, 1.0);
glDisable (GL_TEXTURE_2D);
glDisable (GL_DEPTH_TEST);
glBegin (GL_QUADS);
glVertex2f (0.2, 0.2);
glVertex2f (0.2, 0.4);
glVertex2f (0.4, 0.4);
glVertex2f (0.4, 0.2);
glEnd ();
#endif
#if 0
glClearColor (0.0, 0.0, 0.0, 0.0);
glClear (GL_COLOR_BUFFER_BIT);
#endif
#if 0
glEnable (GL_TEXTURE_2D);
#endif
glDisable (GL_TEXTURE_2D);
glDisable (GL_DEPTH_TEST);
ws_window_raise (gl_window);
draw_windows (screen, scr_info->compositor_nodes);
/* FIXME: we should probably grab the server around the raise/swap
*/
#if 0
ws_display_grab (ws_drawable_get_display ((WsDrawable *)gl_window));
#endif
ws_window_gl_swap_buffers (gl_window);
glFinish();
update_frame_counter ();
#if 0
ws_display_ungrab (ws_drawable_get_display ((WsDrawable *)gl_window));
#endif
scr_info->idle_id = 0;
return FALSE;
}
static void
queue_repaint (CmDrawableNode *node, gpointer data)
{
MetaScreen *screen = data;
ScreenInfo *scr_info = screen->compositor_data;
#if 0
g_print ("metacity queueing repaint for %p\n", node);
#endif
if (!scr_info->idle_id)
{
scr_info->idle_id = g_idle_add (update, screen);
#if 0
g_print ("done\n");
#endif
}
else
{
#if 0
g_print ("one was queued already\n");
#endif
}
}
#endif /* HAVE_COMPOSITE_EXTENSIONS */
#ifdef HAVE_COMPOSITE_EXTENSIONS
static void
dump_stacking_order (GList *nodes)
{
GList *list;
for (list = nodes; list != NULL; list = list->next)
{
CmDrawableNode *node = list->data;
g_print ("%lx, ", WS_RESOURCE_XID (node->drawable));
}
g_print ("\n");
}
#endif
/* This is called when metacity does its XQueryTree() on startup
* and when a new window is mapped.
*/
void
meta_compositor_add_window (MetaCompositor *compositor,
Window xwindow,
XWindowAttributes *attrs)
{
#ifdef HAVE_COMPOSITE_EXTENSIONS
CmDrawableNode *node;
MetaScreen *screen;
WsDrawable *drawable;
ScreenInfo *scr_info;
if (!compositor->enabled)
return; /* no extension */
screen = meta_screen_for_x_screen (attrs->screen);
g_assert (screen != NULL);
node = g_hash_table_lookup (compositor->window_hash,
&xwindow);
g_print ("adding %lx\n", xwindow);
if (node != NULL)
{
g_print ("window %lx already added\n", xwindow);
meta_topic (META_DEBUG_COMPOSITOR,
"Window 0x%lx already added\n", xwindow);
return;
}
ws_display_begin_error_trap (compositor->display);
drawable = (WsDrawable *)ws_window_lookup (compositor->display, xwindow);
scr_info = screen->compositor_data;
ws_display_end_error_trap (compositor->display);
if (!drawable)
return;
g_assert (scr_info);
ws_display_begin_error_trap (compositor->display);
if (ws_window_query_input_only ((WsWindow *)drawable) ||
drawable == (WsDrawable *)scr_info->glw)
{
ws_display_end_error_trap (compositor->display);
return;
}
ws_display_end_error_trap (compositor->display);
node = cm_drawable_node_new (drawable);
cm_drawable_node_set_damage_func (node, queue_repaint, screen);
#if 0
drawable_node_set_deformation_func (node, wavy, NULL);
#endif
/* FIXME: we should probably just store xid's directly */
g_hash_table_insert (compositor->window_hash,
&(WS_RESOURCE (node->drawable)->xid), node);
/* assume cwindow is at the top of the stack as it was either just
* created or just reparented to the root window
*/
scr_info->compositor_nodes = g_list_prepend (scr_info->compositor_nodes,
node);
dump_stacking_order (scr_info->compositor_nodes);
#endif /* HAVE_COMPOSITE_EXTENSIONS */
}
void
meta_compositor_remove_window (MetaCompositor *compositor,
Window xwindow)
{
#ifdef HAVE_COMPOSITE_EXTENSIONS
CmDrawableNode *node;
MetaScreen *screen;
ScreenInfo *scr_info;
if (!compositor->enabled)
return; /* no extension */
node = g_hash_table_lookup (compositor->window_hash,
&xwindow);
if (node == NULL)
{
meta_topic (META_DEBUG_COMPOSITOR,
"Window 0x%lx already removed\n", xwindow);
return;
}
screen = node_get_screen (compositor->meta_display->xdisplay, node);
scr_info = screen->compositor_data;
scr_info->compositor_nodes = g_list_remove (scr_info->compositor_nodes,
node);
/* Frees node as side effect */
g_hash_table_remove (compositor->window_hash,
&xwindow);
#endif /* HAVE_COMPOSITE_EXTENSIONS */
}
void
meta_compositor_manage_screen (MetaCompositor *compositor,
MetaScreen *screen)
{
#ifdef HAVE_COMPOSITE_EXTENSIONS
ScreenInfo *scr_info = g_new0 (ScreenInfo, 1);
WsScreen *ws_screen =
ws_display_get_screen_from_number (compositor->display, screen->number);
WsWindow *root = ws_screen_get_root_window (ws_screen);
WsRegion *region;
Window current_cm_sn_owner;
WsWindow *new_cm_sn_owner;
Display *xdisplay;
Atom cm_sn_atom;
char buf[128];
scr_info->glw = ws_window_new_gl (root);
scr_info->compositor_nodes = NULL;
scr_info->idle_id = 0;
g_print ("setting compositor_data for screen %p to %p\n", screen, scr_info);
screen->compositor_data = scr_info;
ws_display_init_composite (compositor->display);
ws_display_init_damage (compositor->display);
ws_display_init_fixes (compositor->display);
ws_window_redirect_subwindows (root);
ws_window_set_override_redirect (scr_info->glw, TRUE);
ws_window_unredirect (scr_info->glw);
region = ws_region_new (compositor->display);
ws_window_set_input_shape (scr_info->glw, region);
g_object_unref (G_OBJECT (region));
xdisplay = WS_RESOURCE_XDISPLAY (ws_screen);
snprintf(buf, sizeof(buf), "CM_S%d", screen->number);
cm_sn_atom = XInternAtom (xdisplay, buf, False);
current_cm_sn_owner = XGetSelectionOwner (xdisplay, cm_sn_atom);
if (current_cm_sn_owner != None)
{
meta_warning (_("Screen %d on display \"%s\" already has a compositing manager\n"),
screen->number, ",madgh");
}
new_cm_sn_owner = ws_screen_get_root_window (ws_screen);
XSetSelectionOwner (xdisplay, cm_sn_atom, WS_RESOURCE_XID (new_cm_sn_owner),
CurrentTime);
ws_window_map (scr_info->glw);
ws_display_sync (compositor->display);
#if 0
children = ws_window_list_children (root);
#endif
#endif
}
void
meta_compositor_unmanage_screen (MetaCompositor *compositor,
MetaScreen *screen)
{
#ifdef HAVE_COMPOSITE_EXTENSIONS
ScreenInfo *scr_info = screen->compositor_data;
if (!compositor->enabled)
return; /* no extension */
while (scr_info->compositor_nodes != NULL)
{
CmDrawableNode *node = scr_info->compositor_nodes->data;
meta_compositor_remove_window (compositor,
WS_RESOURCE (node->drawable)->xid);
}
/* FIXME: free scr_info */
#endif /* HAVE_COMPOSITE_EXTENSIONS */
}
#ifdef HAVE_COMPOSITE_EXTENSIONS
static CmDrawableNode *
window_to_node (MetaCompositor *compositor,
MetaWindow *window)
{
Window xwindow;
CmDrawableNode *node;
if (window->frame)
xwindow = window->frame->xwindow;
else
xwindow = window->xwindow;
node = g_hash_table_lookup (compositor->window_hash,
&xwindow);
return node;
}
#endif
typedef struct
{
double x;
double y;
double width;
double height;
} DoubleRect;
#if 0
static gdouble
interpolate (gdouble t, gdouble begin, gdouble end, double power)
{
return (begin + (end - begin) * pow (t, power));
}
#endif
#if 0
static gboolean
stop_minimize (gpointer data)
{
MiniInfo *info = data;
g_source_remove (info->repaint_id);
cm_drawable_node_set_deformation_func (info->node, NULL, NULL);
if (info->finished_func)
info->finished_func (info->finished_data);
g_free (info);
return FALSE;
}
#endif
#if 0
static void
minimize_deformation (gdouble time,
double in_x,
double in_y,
double *out_x,
double *out_y,
gpointer data)
{
#define MINIMIZE_TIME 0.5
MiniInfo *info = data;
gdouble elapsed;
gdouble pos;
if (info->start_time == -1)
info->start_time = time;
elapsed = time - info->start_time;
pos = elapsed / MINIMIZE_TIME;
*out_x = interpolate (pos, in_x, info->target.x + info->target.width * ((in_x - info->start.x) / info->start.width), 10 * in_y);
*out_y = interpolate (pos, in_y, info->target.y + info->target.height * ((in_y - info->start.y) / info->start.height), 1.0);
if (elapsed > MINIMIZE_TIME)
{
g_assert (info->node);
if (!info->idle_id)
info->idle_id = g_idle_add (stop_minimize, info);
}
}
#endif
static gdouble
interpolate (gdouble t, gdouble begin, gdouble end, double power)
{
return (begin + (end - begin) * pow (t, power));
}
static void
interpolate_rectangle (gdouble t,
WsRectangle * from,
WsRectangle * to,
WsRectangle * result)
{
if (!result)
return;
result->x = interpolate (t, from->x, to->x, 1);
result->y = interpolate (t, from->y, to->y, 1);
result->width = interpolate (t, from->width, to->width, 1);
result->height = interpolate (t, from->height, to->height, 1);
}
#define MINIMIZE_STYLE 3
#ifndef HAVE_COMPOSITE_EXTENSIONS
#undef MINIMIZE_STYLE
#define MINIMIZE_STYLE 0
#endif
#if MINIMIZE_STYLE == 0
void
meta_compositor_minimize (MetaCompositor *compositor,
MetaWindow *window,
int x,
int y,
int width,
int height,
MetaMinimizeFinishedFunc finished,
gpointer data)
{
}
#elif MINIMIZE_STYLE == 1
typedef struct
{
CmDrawableNode *node;
GTimer *timer;
MetaCompositor *compositor;
ScreenInfo *scr_info;
MetaMinimizeFinishedFunc finished_func;
gpointer finished_data;
gdouble aspect_ratio;
WsRectangle current_geometry;
WsRectangle target_geometry;
gdouble current_alpha;
gdouble target_alpha;
int button_x;
int button_y;
int button_width;
int button_height;
/* FIXME: maybe would be simpler if all of this was an array */
gboolean phase_1_started;
gboolean phase_2_started;
gboolean phase_3_started;
gboolean phase_4_started;
gboolean phase_5_started;
} MiniInfo;
static void
set_geometry (MiniInfo *info, gdouble elapsed)
{
WsRectangle rect;
interpolate_rectangle (elapsed, &info->current_geometry, &info->target_geometry, &rect);
g_print ("y: %d %d (%f => %d)\n", info->current_geometry.y, info->target_geometry.y,
elapsed, rect.y);
g_print ("setting: %d %d %d %d\n", rect.x, rect.y, rect.width, rect.height);
cm_drawable_node_set_geometry (info->node,
rect.x, rect.y,
rect.width, rect.height);
}
static int
center (gdouble what, gdouble in)
{
return (in - what) / 2.0 + 0.5;
}
static void
run_phase_1 (MiniInfo *info, gdouble elapsed)
{
if (!info->phase_1_started)
{
GList *next;
g_print ("starting phase 1\n");
info->phase_1_started = TRUE;
info->current_geometry.x = info->node->real_x;
info->current_geometry.y = info->node->real_y;
info->current_geometry.width = info->node->real_width;
info->current_geometry.height = info->node->real_height;
info->target_geometry.height = info->button_height;
info->target_geometry.width = info->button_height * info->aspect_ratio;
info->target_geometry.x = info->button_x + center (info->target_geometry.width, info->button_width);
info->target_geometry.y = info->node->real_y + center (info->button_height, info->node->real_height);
handle_restacking (info->compositor, info->node,
info->scr_info->compositor_nodes->data);
}
set_geometry (info, elapsed);
}
static void
run_phase_2 (MiniInfo *info, gdouble elapsed)
{
#define WOBBLE_FACTOR 3
if (!info->phase_2_started)
{
WsRectangle cur = info->target_geometry;
g_print ("starting phase 2\n");
info->phase_2_started = TRUE;
info->current_geometry = cur;
info->target_geometry.x = cur.x + center (WOBBLE_FACTOR * cur.width, cur.width);
info->target_geometry.y = cur.y + center (WOBBLE_FACTOR * cur.height, cur.height);
info->target_geometry.width = cur.width * WOBBLE_FACTOR;
info->target_geometry.height = cur.height * WOBBLE_FACTOR;
}
set_geometry (info, elapsed);
}
static void
run_phase_3 (MiniInfo *info, gdouble elapsed)
{
if (!info->phase_3_started)
{
WsRectangle cur = info->target_geometry;
g_print ("starting phase 3\n");
info->phase_3_started = TRUE;
info->current_geometry = cur;
info->target_geometry.height = info->button_height;
info->target_geometry.width = info->button_height * info->aspect_ratio;
info->target_geometry.x = info->button_x + center (info->target_geometry.width, info->button_width);
info->target_geometry.y = info->node->real_y + center (info->button_height, info->node->real_height);
}
set_geometry (info, elapsed);
}
static void
run_phase_4 (MiniInfo *info, gdouble elapsed)
{
if (!info->phase_4_started)
{
WsRectangle cur = info->target_geometry;
g_print ("starting phase 4\n");
info->phase_4_started = TRUE;
info->current_geometry = cur;
info->target_geometry.height = info->button_height;
info->target_geometry.width = info->button_height * info->aspect_ratio;
info->target_geometry.x = cur.x;
g_print ("button y: %d\n", info->button_y);
info->target_geometry.y = info->button_y;
}
set_geometry (info, elapsed);
}
static void
run_phase_5 (MiniInfo *info, gdouble elapsed)
{
if (!info->phase_5_started)
{
WsRectangle cur = info->target_geometry;
g_print ("starting phase 5\n");
info->phase_5_started = TRUE;
info->current_geometry = cur;
info->target_geometry.x = info->button_x;
info->target_geometry.y = info->button_y;
info->target_geometry.width = info->button_width;
info->target_geometry.height = info->button_height;
}
set_geometry (info, elapsed);
cm_drawable_node_set_alpha (info->node, 1 - elapsed);
}
static gboolean
run_animation_01 (gpointer data)
{
MiniInfo *info = data;
gdouble elapsed;
elapsed = g_timer_elapsed (info->timer, NULL);
#define PHASE_0 0.0
#define PHASE_1 0.225 /* scale to size of button */
#define PHASE_2 0.325 /* scale up a little */
#define PHASE_3 0.425 /* scale back a little */
#define PHASE_4 0.650 /* move to button */
#define PHASE_5 1.0 /* fade out */
if (elapsed < PHASE_1)
{
/* phase one */
run_phase_1 (info, (elapsed - PHASE_0)/(PHASE_1 - PHASE_0));
}
else if (elapsed < PHASE_2)
{
/* phase two */
run_phase_2 (info, (elapsed - PHASE_1)/(PHASE_2 - PHASE_1));
}
else if (elapsed < PHASE_3)
{
/* phase three */
run_phase_3 (info, (elapsed - PHASE_2)/(PHASE_3 - PHASE_2));
}
else if (elapsed < PHASE_4)
{
/* phase four */
run_phase_4 (info, (elapsed - PHASE_3)/(PHASE_4 - PHASE_3));
}
else if (elapsed < PHASE_5)
{
/* phase five */
run_phase_5 (info, (elapsed - PHASE_4)/(PHASE_5 - PHASE_4));
}
else
{
cm_drawable_node_set_viewable (info->node, FALSE);
cm_drawable_node_unset_geometry (info->node);
cm_drawable_node_set_alpha (info->node, 1.0);
if (info->finished_func)
info->finished_func (info->finished_data);
return FALSE;
}
return TRUE;
}
void
meta_compositor_minimize (MetaCompositor *compositor,
MetaWindow *window,
int x,
int y,
int width,
int height,
MetaMinimizeFinishedFunc finished,
gpointer data)
{
MiniInfo *info = g_new (MiniInfo, 1);
CmDrawableNode *node = window_to_node (compositor, window);
WsRectangle start;
MetaScreen *screen = window->screen;
info->node = node;
info->timer = g_timer_new ();
info->finished_func = finished;
info->finished_data = data;
info->phase_1_started = FALSE;
info->phase_2_started = FALSE;
info->phase_3_started = FALSE;
info->phase_4_started = FALSE;
info->phase_5_started = FALSE;
info->button_x = x;
info->button_y = y;
info->button_width = width;
info->button_height = height;
info->compositor = compositor;
info->scr_info = screen->compositor_data;
#if 0
cm_drawable_node_set_deformation_func (node, minimize_deformation, info);
#endif
info->aspect_ratio = 1.3;
g_idle_add (run_animation_01, info);
}
void
meta_compositor_unminimize (MetaCompositor *compositor,
MetaWindow *window,
int x,
int y,
int width,
int height,
MetaMinimizeFinishedFunc finished,
gpointer data)
{
finished(data);
}
#elif MINIMIZE_STYLE == 2
#if 0
static gboolean
do_minimize_animation (gpointer data)
{
MiniInfo *info = data;
double elapsed;
gboolean done = FALSE;
#define FADE_TIME 0.5
elapsed = g_timer_elapsed (info->timer, NULL);
elapsed = elapsed / FADE_TIME;
if (elapsed >= 1.0)
{
elapsed = 1.0;
done = TRUE;
}
g_print ("%f\n", elapsed);
cm_drawable_node_set_geometry (info->node,
info->node->real_x + interpolate (elapsed, 0, info->node->real_width / 2, 1),
info->node->real_y + interpolate (elapsed, 0, info->node->real_height / 2, 1),
interpolate (elapsed, info->node->real_width, 0, 1),
interpolate (elapsed, info->node->real_height, 0, 1));
if (done)
return FALSE;
#if 0
g_print ("inter: %f %f %f\n", 0, 735, interpolate (0.0, 735.0, 0.5, 1.0));
g_print ("inter x .5: %f (%d %d)\n", info->node->real_x + interpolate (0, info->node->real_width / 2, .5, 1), 0, info->node->real_width);
#endif
cm_drawable_node_set_alpha (info->node, 1 - elapsed);
if (done)
{
}
else
{
return TRUE;
}
#if 0
queue_repaint (info->node,
node_get_screen (info->window->display->xdisplay,
info->node));
#endif
}
#endif
#elif MINIMIZE_STYLE == 3
typedef struct XYPair Point;
typedef struct XYPair Vector;
typedef struct Spring Spring;
typedef struct Object Object;
typedef struct Model Model;
struct XYPair {
double x, y;
};
#define GRID_WIDTH 4
#define GRID_HEIGHT 4
#define MODEL_MAX_OBJECTS (GRID_WIDTH * GRID_HEIGHT)
#define MODEL_MAX_SPRINGS (MODEL_MAX_OBJECTS * 2)
#define DEFAULT_SPRING_K 5.0
#define DEFAULT_FRICTION 1.4
struct Spring {
Object *a;
Object *b;
/* Spring position at rest, from a to b:
offset = b.position - a.position
*/
Vector offset;
};
struct Object {
Vector force;
Point position;
Vector velocity;
double mass;
double theta;
int immobile;
};
struct Model {
int num_objects;
Object objects[MODEL_MAX_OBJECTS];
int num_springs;
Spring springs[MODEL_MAX_SPRINGS];
Object *anchor_object;
Vector anchor_offset;
double friction;/* Friction constant */
double k;/* Spring constant */
double last_time;
double steps;
};
typedef struct
{
CmDrawableNode *node;
GTimer *timer;
gboolean expand;
MetaCompositor *compositor;
ScreenInfo *scr_info;
MetaRectangle rect;
MetaAnimationFinishedFunc finished_func;
gpointer finished_data;
Model model;
int button_x;
int button_y;
int button_width;
int button_height;
} MiniInfo;
static void
object_init (Object *object,
double position_x, double position_y,
double velocity_x, double velocity_y, double mass)
{
object->position.x = position_x;
object->position.y = position_y;
object->velocity.x = velocity_x;
object->velocity.y = velocity_y;
object->mass = mass;
object->force.x = 0;
object->force.y = 0;
object->immobile = 0;
}
static void
spring_init (Spring *spring,
Object *object_a, Object *object_b,
double offset_x, double offset_y)
{
spring->a = object_a;
spring->b = object_b;
spring->offset.x = offset_x;
spring->offset.y = offset_y;
}
static void
model_add_spring (Model *model,
Object *object_a, Object *object_b,
double offset_x, double offset_y)
{
Spring *spring;
g_assert (model->num_springs < MODEL_MAX_SPRINGS);
spring = &model->springs[model->num_springs];
model->num_springs++;
spring_init (spring, object_a, object_b, offset_x, offset_y);
}
static void
model_init_grid (Model *model, MetaRectangle *rect, gboolean expand)
{
int x, y, i, v_x, v_y;
int hpad, vpad;
model->num_objects = MODEL_MAX_OBJECTS;
model->num_springs = 0;
i = 0;
if (expand) {
hpad = rect->width / 3;
vpad = rect->height / 3;
}
else {
hpad = rect->width / 6;
vpad = rect->height / 6;
}
for (y = 0; y < GRID_HEIGHT; y++)
for (x = 0; x < GRID_WIDTH; x++) {
v_x = random() % 40 - 20;
v_y = random() % 40 - 20;
if (expand)
object_init (&model->objects[i],
rect->x + x * rect->width / 6 + rect->width / 4,
rect->y + y * rect->height / 6 + rect->height / 4,
v_x, v_y, 20);
else
object_init (&model->objects[i],
rect->x + x * rect->width / 3,
rect->y + y * rect->height / 3,
v_x, v_y, 20);
if (x > 0)
model_add_spring (model,
&model->objects[i - 1],
&model->objects[i],
hpad, 0);
if (y > 0)
model_add_spring (model,
&model->objects[i - GRID_WIDTH],
&model->objects[i],
0, vpad);
i++;
}
}
static void
model_init (Model *model, MetaRectangle *rect, gboolean expand)
{
model->anchor_object = NULL;
model->k = DEFAULT_SPRING_K;
model->friction = DEFAULT_FRICTION;
model_init_grid (model, rect, expand);
model->steps = 0;
model->last_time = 0;
}
static void
object_apply_force (Object *object, double fx, double fy)
{
object->force.x += fx;
object->force.y += fy;
}
/* The model here can be understood as a rigid body of the spring's
* rest shape, centered on the vector between the two object
* positions. This rigid body is then connected by linear-force
* springs to each object. This model does degnerate into a simple
* spring for linear displacements, and does something reasonable for
* rotation.
*
* There are other possibilities for handling the rotation of the
* spring, and it might be interesting to explore something which has
* better length-preserving properties. For example, with the current
* model, an initial 180 degree rotation of the spring results in the
* spring collapsing down to 0 size before expanding back to it's
* natural size again.
*/
static void
spring_exert_forces (Spring *spring, double k)
{
Vector da, db;
Vector a, b;
a = spring->a->position;
b = spring->b->position;
/* A nice vector diagram would likely help here, but my ASCII-art
* skills aren't up to the task. Here's how to make your own
* diagram:
*
* Draw a and b, and the vector AB from a to b
* Find the center of AB
* Draw spring->offset so that its center point is on the center of AB
* Draw da from a to the initial point of spring->offset
* Draw db from b to the final point of spring->offset
*
* The math below should be easy to verify from the diagram.
*/
da.x = 0.5 * (b.x - a.x - spring->offset.x);
da.y = 0.5 * (b.y - a.y - spring->offset.y);
db.x = 0.5 * (a.x - b.x + spring->offset.x);
db.y = 0.5 * (a.y - b.y + spring->offset.y);
object_apply_force (spring->a, k *da.x, k * da.y);
object_apply_force (spring->b, k * db.x, k * db.y);
}
static void
model_step_object (Model *model, Object *object)
{
Vector acceleration;
object->theta += 0.05;
/* Slow down due to friction. */
object->force.x -= model->friction * object->velocity.x;
object->force.y -= model->friction * object->velocity.y;
acceleration.x = object->force.x / object->mass;
acceleration.y = object->force.y / object->mass;
if (object->immobile) {
object->velocity.x = 0;
object->velocity.y = 0;
} else {
object->velocity.x += acceleration.x;
object->velocity.y += acceleration.y;
object->position.x += object->velocity.x;
object->position.y += object->velocity.y;
}
object->force.x = 0.0;
object->force.y = 0.0;
}
static void
model_step (Model *model)
{
int i;
for (i = 0; i < model->num_springs; i++)
spring_exert_forces (&model->springs[i], model->k);
for (i = 0; i < model->num_objects; i++)
model_step_object (model, &model->objects[i]);
}
#define WOBBLE_TIME 1.0
static gboolean
run_animation (gpointer data)
{
MiniInfo *info = data;
gdouble t, blend;
CmPoint points[4][4];
int i, j, steps, target_x, target_y;
t = g_timer_elapsed (info->timer, NULL);
info->model.steps += (t - info->model.last_time) / 0.03;
info->model.last_time = t;
steps = floor(info->model.steps);
info->model.steps -= steps;
for (i = 0; i < steps; i++)
model_step (&info->model);
if (info->expand)
blend = t / WOBBLE_TIME;
else
blend = 0;
for (i = 0; i < 4; i++)
for (j = 0; j < 4; j++) {
target_x = info->node->real_x + i * info->node->real_width / 3;
target_y = info->node->real_y + j * info->node->real_height / 3;
points[j][i].x =
(1 - blend) * info->model.objects[j * 4 + i].position.x +
blend * target_x;
points[j][i].y =
(1 - blend) * info->model.objects[j * 4 + i].position.y +
blend * target_y;
}
cm_drawable_node_set_patch (info->node, points);
if (info->expand)
cm_drawable_node_set_alpha (info->node, t / WOBBLE_TIME);
else
cm_drawable_node_set_alpha (info->node, 1.0 - t / WOBBLE_TIME);
if (t > WOBBLE_TIME) {
cm_drawable_node_set_viewable (info->node, info->expand);
cm_drawable_node_unset_geometry (info->node);
cm_drawable_node_set_alpha (info->node, 1.0);
if (info->finished_func)
info->finished_func (info->finished_data);
return FALSE;
}
else {
return TRUE;
}
}
void
meta_compositor_minimize (MetaCompositor *compositor,
MetaWindow *window,
int x,
int y,
int width,
int height,
MetaAnimationFinishedFunc finished,
gpointer data)
{
MiniInfo *info = g_new (MiniInfo, 1);
CmDrawableNode *node = window_to_node (compositor, window);
MetaScreen *screen = window->screen;
info->node = node;
info->timer = g_timer_new ();
info->finished_func = finished;
info->finished_data = data;
info->rect = window->user_rect;
model_init (&info->model, &info->rect, FALSE);
info->expand = FALSE;
info->button_x = x;
info->button_y = y;
info->button_width = width;
info->button_height = height;
info->compositor = compositor;
info->scr_info = screen->compositor_data;
g_idle_add (run_animation, info);
}
void
meta_compositor_unminimize (MetaCompositor *compositor,
MetaWindow *window,
int x,
int y,
int width,
int height,
MetaAnimationFinishedFunc finished,
gpointer data)
{
MiniInfo *info = g_new (MiniInfo, 1);
CmDrawableNode *node = window_to_node (compositor, window);
MetaScreen *screen = window->screen;
info->node = node;
info->timer = g_timer_new ();
info->finished_func = finished;
info->finished_data = data;
info->rect = window->user_rect;
model_init (&info->model, &info->rect, TRUE);
info->expand = TRUE;
info->button_x = x;
info->button_y = y;
info->button_width = width;
info->button_height = height;
info->compositor = compositor;
info->scr_info = screen->compositor_data;
g_idle_add (run_animation, info);
}
void
meta_compositor_set_updates (MetaCompositor *compositor,
MetaWindow *window,
gboolean updates)
{
CmDrawableNode *node = window_to_node (compositor, window);
if (node)
{
g_print ("turning updates %s\n", updates? "on" : "off");
cm_drawable_node_set_updates (node, updates);
update (window->screen);
}
}
#endif
#ifdef HAVE_COMPOSITE_EXTENSIONS
#define BALLOON_TIME 2
typedef struct
{
CmDrawableNode *node;
MetaAnimationFinishedFunc finished;
gpointer finished_data;
GTimer *timer;
} BalloonInfo;
static gboolean
blow_up (gpointer data)
{
BalloonInfo *info = data;
gdouble elapsed = g_timer_elapsed (info->timer, NULL) / BALLOON_TIME;
CmPoint points[4][4];
int i, j;
if (elapsed > BALLOON_TIME)
{
cm_drawable_node_set_viewable (info->node, FALSE);
return FALSE;
}
for (i = 0; i < 4; ++i)
{
for (j = 0; j < 4; ++j)
{
points[i][j].x = info->node->real_x + j;
points[i][j].y = info->node->real_y + i;
}
}
cm_drawable_node_set_patch (info->node, points);
return TRUE;
}
void
meta_compositor_delete_window (MetaCompositor *compositor,
MetaWindow *window,
MetaAnimationFinishedFunc finished,
gpointer data)
{
CmDrawableNode *node;
BalloonInfo *info = g_new (BalloonInfo, 1);
node = window_to_node (compositor, window);
if (!node)
{
finished (data);
return;
}
info->finished = finished;
info->finished_data = data;
info->timer = g_timer_new ();
g_idle_add (blow_up, info);
}
#endif
Reference in New Issue View Git Blame Copy Permalink