brl/mutter
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

New files

Browse Source 
Tue May  2 17:12:54 2006  Søren Sandmann  <sandmann@redhat.com>

	* src/c-window.[ch]: New files

	* src/c-screen.c: Move WindowInfo struct to new c-window.[ch]
	files. Delete various bits of obsolete, commented-out code.
This commit is contained in:
Søren Sandmann 2006-05-02 21:15:32 +00:00 committed by Søren Sandmann Pedersen
parent 451c990dd5
commit 411fd3db44
7 changed files with 627 additions and 687 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
ChangeLog
View File

@ -1,3 +1,10 @@
Tue May 2 17:12:54 2006 Søren Sandmann <sandmann@redhat.com>
* src/c-window.[ch]: New files
* src/c-screen.c: Move WindowInfo struct to new c-window.[ch]
files. Delete various bits of obsolete, commented-out code.
Fri Apr 28 12:53:23 2006 Søren Sandmann <sandmann@redhat.com>
* src/core.c (get_window): New function.

2
src/Makefile.am
View File

@ -18,6 +18,8 @@ metacity_SOURCES= \
common.h \
c-screen.c \
c-screen.h \
c-window.c \
c-window.h \
compositor.c \
compositor.h \
constraints.c \

233
src/c-screen.c
View File

@ -27,20 +27,11 @@
#include <cm/state.h>
#include <cm/magnifier.h>
#include <cm/square.h>
#include <string.h>
#include "screen.h"
#include "c-screen.h"
typedef struct WindowInfo WindowInfo;
struct WindowInfo
{
Window xwindow;
CmNode *node;
gboolean updates;
WsRectangle size;
};
#include "c-window.h"
struct MetaScreenInfo
{
@ -54,8 +45,6 @@ struct MetaScreenInfo
WsScreen *screen;
MetaScreen *meta_screen;
GHashTable *window_infos_by_xid;
int repaint_id;
int idle_id;
@ -158,24 +147,21 @@ repaint (gpointer data)
return FALSE;
}
static WindowInfo *
find_win_info (MetaScreenInfo *info,
static MetaCompWindow *
find_comp_window (MetaScreenInfo *info,
Window xwindow)
{
WindowInfo *win_info =
g_hash_table_lookup (info->window_infos_by_xid, (gpointer)xwindow);
return win_info;
return meta_comp_window_lookup (xwindow);
}
static CmNode *
find_node (MetaScreenInfo *info,
Window xwindow)
{
WindowInfo *win_info = find_win_info (info, xwindow);
MetaCompWindow *window = meta_comp_window_lookup (xwindow);
if (win_info)
return win_info->node;
if (window)
return meta_comp_window_get_node (window);
return NULL;
}
@ -208,9 +194,6 @@ meta_screen_info_new (WsDisplay *display,
display, screen->number);
scr_info->root_window = ws_screen_get_root_window (scr_info->screen);
scr_info->display = display;
scr_info->window_infos_by_xid =
g_hash_table_new_full (g_direct_hash, g_direct_equal,
NULL, g_free);
scr_info->meta_screen = screen;
all_screen_infos = g_list_prepend (all_screen_infos, scr_info);
@ -440,14 +423,16 @@ meta_screen_info_raise_window (MetaScreenInfo *info,
void
meta_screen_info_set_size (MetaScreenInfo *info,
Window window,
Window xwindow,
gint x,
gint y,
gint width,
gint height)
{
CmDrawableNode *node = CM_DRAWABLE_NODE (find_node (info, window));
WindowInfo *winfo = find_win_info (info, window);
MetaCompWindow *comp_window = meta_comp_window_lookup (xwindow);
if (comp_window)
{
WsRectangle rect;
rect.x = x;
@ -455,37 +440,7 @@ meta_screen_info_set_size (MetaScreenInfo *info,
rect.width = width;
rect.height = height;
if (node)
{
WsRegion *shape;
if (winfo && winfo->updates)
{
WsWindow *window = WS_WINDOW (node->drawable);
WsDisplay *display = WS_RESOURCE (window)->display;
ws_display_begin_error_trap (display);
#if 0
g_print ("meta screen info set: %d %d %d %d\n",
x, y, width, height);
#endif
cm_drawable_node_set_geometry (CM_DRAWABLE_NODE (node), &rect);
shape = ws_window_get_output_shape (window);
cm_drawable_node_set_shape (node, shape);
ws_region_destroy (shape);
if (rect.width != winfo->size.width ||
rect.height != winfo->size.height)
{
cm_drawable_node_update_pixmap (node);
}
winfo->size = rect;
ws_display_end_error_trap (display);
}
meta_comp_window_set_size (comp_window, &rect);
}
}
@ -507,66 +462,22 @@ print_child_titles (WsWindow *window)
}
}
static WindowInfo *
window_info_new (Window xwindow,
CmNode *node)
{
WindowInfo *win_info = g_new0 (WindowInfo, 1);
win_info->xwindow = xwindow;
win_info->node = node;
win_info->updates = TRUE;
return win_info;
}
static gboolean
has_type (WsWindow *window, const char *check_type)
{
gchar **types = ws_window_get_property_atom_list (window, "_NET_WM_WINDOW_TYPE");
int i;
gboolean result;
if (!types)
return FALSE;
result = FALSE;
for (i = 0; types[i] != NULL; ++i)
{
gchar *type = types[i];
g_print ("type: %s\n", type);
if (strcmp (type, check_type) == 0)
{
result = TRUE;
break;
}
}
g_strfreev (types);
return result;
}
void
meta_screen_info_add_window (MetaScreenInfo *info,
Window xwindow)
{
CmNode *node;
WsDrawable *drawable;
WsRectangle geometry;
double alpha = 1.0;
MetaCompWindow *comp_window;
ws_display_begin_error_trap (info->display);
node = find_node (info, xwindow);
#if 0
g_print ("lookup %lx\n", xwindow);
#endif
drawable = WS_DRAWABLE (ws_window_lookup (info->display, xwindow));
comp_window = meta_comp_window_lookup (xwindow);
if (node)
if (comp_window)
goto out;
drawable = WS_DRAWABLE (ws_window_lookup (info->display, xwindow));
if (ws_window_query_input_only (WS_WINDOW (drawable)))
goto out;
@ -579,72 +490,13 @@ meta_screen_info_add_window (MetaScreenInfo *info,
goto out;
}
ws_drawable_query_geometry (drawable, &geometry);
comp_window = meta_comp_window_new (drawable);
node = CM_NODE (cm_drawable_node_new (drawable, &geometry));
cm_stacker_add_child (info->stacker, meta_comp_window_get_node (comp_window));
#if 0
g_print ("alpha: %f\n", alpha);
#endif
cm_drawable_node_set_alpha (node, alpha);
#if 0
print_child_titles (WS_WINDOW (drawable));
#endif
cm_stacker_add_child (info->stacker, node);
g_hash_table_insert (info->window_infos_by_xid,
(gpointer)xwindow,
window_info_new (xwindow, node));
g_object_unref (node);
out:
if (node)
{
#if 0
g_print ("drawable %lx is now ", WS_RESOURCE_XID (drawable));
#endif
if (ws_window_query_mapped (WS_WINDOW (drawable)))
{
#if 0
g_print ("mapped\n");
#endif
cm_drawable_node_unset_patch (node);
#if 0
g_print ("set alpha %f\n", alpha);
#endif
if (has_type (drawable, "_NET_WM_WINDOW_TYPE_DROPDOWN_MENU"))
{
#if 0
g_print ("is menu\n");
#endif
alpha = 0.9;
}
else if (has_type (drawable, "_NET_WM_WINDOW_TYPE_POPUP_MENU"))
{
alpha = 0.9;
}
else
{
#if 0
g_print ("is not menu\n");
#endif
alpha = 1.0;
}
cm_drawable_node_set_alpha (node, alpha);
cm_drawable_node_set_viewable (node, TRUE);
cm_drawable_node_update_pixmap (node);
}
else
{
#if 0
g_print ("unmapped\n");
#endif
cm_drawable_node_set_viewable (node, FALSE);
}
}
if (comp_window)
meta_comp_window_refresh_attrs (comp_window);
ws_display_end_error_trap (info->display);
@ -660,17 +512,14 @@ void
meta_screen_info_remove_window (MetaScreenInfo *info,
Window xwindow)
{
CmNode *node = find_node (info, xwindow);
MetaCompWindow *comp_window = meta_comp_window_lookup (xwindow);
#if 0
g_print ("removing %lx\n", xwindow);
#endif
if (node)
if (comp_window)
{
g_hash_table_remove (info->window_infos_by_xid, (gpointer)xwindow);
CmNode *node = meta_comp_window_get_node (comp_window);
cm_stacker_remove_child (info->stacker, node);
meta_comp_window_free (comp_window);
}
}
@ -679,33 +528,9 @@ meta_screen_info_set_updates (MetaScreenInfo *info,
Window xwindow,
gboolean updates)
{
WindowInfo *win_info = find_win_info (info, xwindow);
CmDrawableNode *node = CM_DRAWABLE_NODE (win_info->node);
MetaCompWindow *comp_window = meta_comp_window_lookup (xwindow);
#if 0
g_print ("setting updates to %s\n", updates? "on" : "off");
#endif
win_info->updates = updates;
if (node)
cm_drawable_node_set_updates (node, updates);
if (updates)
{
WsRectangle rect;
WsRegion *shape;
WsDisplay *display = WS_RESOURCE (node->drawable)->display;
ws_display_begin_error_trap (display);
ws_drawable_query_geometry (node->drawable, &rect);
cm_drawable_node_update_pixmap (node);
cm_drawable_node_set_geometry (node, &rect);
shape = ws_window_get_output_shape (WS_WINDOW (node->drawable));
cm_drawable_node_set_shape (node, shape);
ws_region_destroy (shape);
ws_display_end_error_trap (display);
}
meta_comp_window_set_updates (comp_window, updates);
}

2
src/c-screen.h
View File

@ -47,3 +47,5 @@ void meta_screen_info_set_explode (MetaScreenInfo *info,
gdouble level);
void meta_screen_info_hide_window (MetaScreenInfo *info,
Window xwindow);
void meta_screen_info_unmap (MetaScreenInfo *info,
Window xwindow);

231
src/c-window.c Normal file
View File

@ -0,0 +1,231 @@
/*
* Copyright (C) 2006 Red Hat, Inc.
*
* 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>
#ifdef HAVE_COMPOSITE_EXTENSIONS
#include <X11/Xlib.h>
#include <glib.h>
#include <cm/ws.h>
#include <cm/wsint.h>
#include <cm/node.h>
#include <cm/drawable-node.h>
#include <string.h>
#include "c-window.h"
static GHashTable *windows_by_xid;
struct _MetaCompWindow
{
WsDrawable *drawable;
CmNode *node;
gboolean updates;
WsRectangle size;
};
static void
ensure_hash_table (void)
{
if (!windows_by_xid)
{
windows_by_xid = g_hash_table_new (
g_direct_hash, g_direct_equal);
}
}
MetaCompWindow *
meta_comp_window_new (WsDrawable *drawable)
{
MetaCompWindow *window;
WsRectangle geometry;
ws_drawable_query_geometry (drawable, &geometry);
window = g_new0 (MetaCompWindow, 1);
window->drawable = g_object_ref (drawable);
window->node = CM_NODE (cm_drawable_node_new (drawable, &geometry));
window->updates = TRUE;
ensure_hash_table ();
g_hash_table_insert (windows_by_xid, (gpointer)WS_RESOURCE_XID (window->drawable), window);
return window;
}
MetaCompWindow *
meta_comp_window_lookup (Window xid)
{
MetaCompWindow *window;
ensure_hash_table ();
window = g_hash_table_lookup (windows_by_xid, (gpointer)xid);
return window;
}
void
meta_comp_window_free (MetaCompWindow *window)
{
ensure_hash_table ();
g_hash_table_remove (windows_by_xid, WS_RESOURCE_XID (window->drawable));
g_object_unref (window->drawable);
g_object_unref (window->node);
g_free (window);
}
void
meta_comp_window_set_size (MetaCompWindow *comp_window,
WsRectangle *rect)
{
if (comp_window->updates)
{
WsWindow *window = WS_WINDOW (comp_window->drawable);
WsDisplay *display = WS_RESOURCE (window)->display;
CmDrawableNode *dnode = CM_DRAWABLE_NODE (comp_window->node);
WsRegion *shape;
ws_display_begin_error_trap (display);
cm_drawable_node_set_geometry (dnode, rect);
shape = ws_window_get_output_shape (window);
cm_drawable_node_set_shape (dnode, shape);
ws_region_destroy (shape);
if (rect->width != comp_window->size.width ||
rect->height != comp_window->size.height)
{
cm_drawable_node_update_pixmap (dnode);
}
comp_window->size = *rect;
ws_display_end_error_trap (display);
}
}
static gboolean
has_type (WsWindow *window, const char *check_type)
{
gchar **types = ws_window_get_property_atom_list (window, "_NET_WM_WINDOW_TYPE");
int i;
gboolean result;
if (!types)
return FALSE;
result = FALSE;
for (i = 0; types[i] != NULL; ++i)
{
gchar *type = types[i];
g_print ("type: %s\n", type);
if (strcmp (type, check_type) == 0)
{
result = TRUE;
break;
}
}
g_strfreev (types);
return result;
}
void
meta_comp_window_refresh_attrs (MetaCompWindow *comp_window)
{
/* FIXME: this function should not exist - the real problem is
* probably in meta_screen_info_add_window() where it it called.
*/
double alpha = 1.0;
CmDrawableNode *node = CM_DRAWABLE_NODE (comp_window->node);
if (ws_window_query_mapped (WS_WINDOW (comp_window->drawable)))
{
WsWindow *window = WS_WINDOW (comp_window->drawable);
cm_drawable_node_unset_patch (CM_DRAWABLE_NODE (node));
if (has_type (window, "_NET_WM_WINDOW_TYPE_DROPDOWN_MENU"))
{
alpha = 0.3;
}
else if (has_type (window, "_NET_WM_WINDOW_TYPE_POPUP_MENU"))
{
alpha = 0.9;
}
else
{
alpha = 1.0;
}
cm_drawable_node_set_alpha (node, alpha);
cm_drawable_node_set_viewable (node, TRUE);
cm_drawable_node_update_pixmap (node);
}
else
{
cm_drawable_node_set_viewable (node, FALSE);
}
}
void
meta_comp_window_set_updates (MetaCompWindow *comp_window,
gboolean updates)
{
CmDrawableNode *node = CM_DRAWABLE_NODE (comp_window->node);
comp_window->updates = updates;
cm_drawable_node_set_updates (node, updates);
if (updates)
{
WsRectangle rect;
WsRegion *shape;
WsDisplay *display = WS_RESOURCE (node->drawable)->display;
ws_display_begin_error_trap (display);
ws_drawable_query_geometry (node->drawable, &rect);
cm_drawable_node_update_pixmap (node);
cm_drawable_node_set_geometry (node, &rect);
shape = ws_window_get_output_shape (WS_WINDOW (node->drawable));
cm_drawable_node_set_shape (node, shape);
ws_region_destroy (shape);
ws_display_end_error_trap (display);
}
}
CmNode *
meta_comp_window_get_node (MetaCompWindow *comp_window)
{
return comp_window->node;
}
#endif

33
src/c-window.h Normal file
View File

@ -0,0 +1,33 @@
/*
* Copyright (C) 2006 Red Hat, Inc.
*
* 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 <cm/node.h>
typedef struct _MetaCompWindow MetaCompWindow;
MetaCompWindow *meta_comp_window_new (WsDrawable *drawable);
CmNode *meta_comp_window_get_node (MetaCompWindow *window);
MetaCompWindow *meta_comp_window_lookup (Window xwindow);
void meta_comp_window_free (MetaCompWindow *window);
void meta_comp_window_set_size (MetaCompWindow *window,
WsRectangle *size);
void meta_comp_window_refresh_attrs (MetaCompWindow *comp_window);
void meta_comp_window_set_updates (MetaCompWindow *comp_window,
gboolean updates);

162
src/compositor.c
View File

@ -90,7 +90,7 @@ handle_error (Display *dpy, XErrorEvent *ev, gpointer data)
{
WsDisplay *display = data;
ws_display_process_error (display, ev);
ws_display_process_xerror (display, ev);
}
#endif
@ -181,25 +181,6 @@ meta_compositor_unref (MetaCompositor *compositor)
}
#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, NULL);
}
static void
process_configure_notify (MetaCompositor *compositor,
@ -510,149 +491,8 @@ meta_compositor_process_event (MetaCompositor *compositor,
#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 GTimer *timer;
#if 0
static gboolean
update (gpointer data)
{
MetaScreen *screen = data;
ScreenInfo *scr_info = screen->compositor_data;
WsWindow *gl_window = scr_info->glw;
gdouble angle;
glViewport (0, 0, screen->rect.width, screen->rect.height);
if (!timer)
timer = g_timer_new ();
#if 0
g_print ("rotation: %f\n", 360 * g_timer_elapsed (timer, NULL));
#endif
angle = g_timer_elapsed (timer, NULL) * 90;
#if 0
angle = 180.0;
#endif
cm_rotation_set_rotation (screen->display->compositor->rotation,
angle,
0.0, 1.0, 0.0);
glClearColor (0.0, 0.0, 0.0, 0.0);
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glDisable (GL_TEXTURE_2D);
glDisable (GL_DEPTH_TEST);
ws_window_raise (gl_window);
#if 0
glMatrixMode (GL_MODELVIEW);
glLoadIdentity();
#endif
#if 0
glTranslatef (-1.0, -1.0, 0.0);
#endif
#if 0
glMatrixMode (GL_PROJECTION);
glLoadIdentity();
gluPerspective( 45.0f, 1.0, 0.1f, 10.0f );
glMatrixMode (GL_MODELVIEW);
glLoadIdentity();
glTranslatef (0, 0, -3);
glEnable (GL_DEPTH_TEST);
#endif
#if 0
draw_windows (screen, scr_info->compositor_nodes);
#endif
/* FIXME: we should probably grab the server around the raise/swap
*/
CmState *state = cm_state_new ();
cm_state_disable_depth_buffer_update (state);
cm_node_render (CM_NODE (screen->display->compositor->stacker), state);
cm_state_enable_depth_buffer_update (state);
g_object_unref (state);
#if 0
ws_display_grab (ws_drawable_get_display ((WsDrawable *)gl_window));
#endif
ws_window_gl_swap_buffers (gl_window);
glFinish();
update_frame_counter ();
scr_info->idle_id = 0;
return FALSE;
}
#endif
#if 0
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)
{
/* compositor has been turned off */
return;
}
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 */
#endif
#ifdef HAVE_COMPOSITE_EXTENSIONS
static void
dump_stacking_order (GList *nodes)