[metacity] compositor: turn into a GObject
- From: Alberts Muktupāvels <muktupavels src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [metacity] compositor: turn into a GObject
- Date: Sun, 8 Jan 2017 19:54:26 +0000 (UTC)
commit 900184fe2a46632f63e9013f1a43e9b46cafa242
Author: Alberts Muktupāvels <alberts muktupavels gmail com>
Date: Sun Jan 8 21:49:47 2017 +0200
compositor: turn into a GObject
src/compositor/meta-compositor-none.c | 64 +++---
src/compositor/meta-compositor-none.h | 10 +-
src/compositor/meta-compositor-private.h | 11 +-
src/compositor/meta-compositor-xrender.c | 386 ++++++++++++++++--------------
src/compositor/meta-compositor-xrender.h | 34 ++--
src/compositor/meta-compositor.c | 269 ++++++++++++++++++----
src/core/display.c | 4 +-
src/include/meta-compositor.h | 14 +-
8 files changed, 516 insertions(+), 276 deletions(-)
---
diff --git a/src/compositor/meta-compositor-none.c b/src/compositor/meta-compositor-none.c
index 6756faa..c76814d 100644
--- a/src/compositor/meta-compositor-none.c
+++ b/src/compositor/meta-compositor-none.c
@@ -18,19 +18,19 @@
#include "config.h"
#include "meta-compositor-none.h"
-#include "meta-compositor-private.h"
-typedef struct
+struct _MetaCompositorNone
{
- MetaCompositor compositor;
+ MetaCompositor parent;
+};
- MetaDisplay *display;
-} MetaCompositorNone;
+G_DEFINE_TYPE (MetaCompositorNone, meta_compositor_none, META_TYPE_COMPOSITOR)
-static void
-meta_compositor_none_destroy (MetaCompositor *compositor)
+static gboolean
+meta_compositor_none_initable_init (MetaCompositor *compositor,
+ GError **error)
{
- g_free (compositor);
+ return TRUE;
}
static void
@@ -128,33 +128,31 @@ meta_compositor_none_unmaximize_window (MetaCompositor *compositor,
{
}
-static MetaCompositor comp_info = {
- meta_compositor_none_destroy,
- meta_compositor_none_manage_screen,
- meta_compositor_none_unmanage_screen,
- meta_compositor_none_add_window,
- meta_compositor_none_remove_window,
- meta_compositor_none_set_updates,
- meta_compositor_none_process_event,
- meta_compositor_none_get_window_surface,
- meta_compositor_none_set_active_window,
- meta_compositor_none_begin_move,
- meta_compositor_none_update_move,
- meta_compositor_none_end_move,
- meta_compositor_none_free_window,
- meta_compositor_none_maximize_window,
- meta_compositor_none_unmaximize_window,
-};
-
-MetaCompositor *
-meta_compositor_none_new (MetaDisplay *display)
+static void
+meta_compositor_none_class_init (MetaCompositorNoneClass *none_class)
{
- MetaCompositorNone *none;
+ MetaCompositorClass *compositor_class;
- none = g_new (MetaCompositorNone, 1);
+ compositor_class = META_COMPOSITOR_CLASS (none_class);
- none->compositor = comp_info;
- none->display = display;
+ compositor_class->initable_init = meta_compositor_none_initable_init;
+ compositor_class->manage_screen = meta_compositor_none_manage_screen;
+ compositor_class->unmanage_screen = meta_compositor_none_unmanage_screen;
+ compositor_class->add_window = meta_compositor_none_add_window;
+ compositor_class->remove_window = meta_compositor_none_remove_window;
+ compositor_class->set_updates = meta_compositor_none_set_updates;
+ compositor_class->process_event = meta_compositor_none_process_event;
+ compositor_class->get_window_surface = meta_compositor_none_get_window_surface;
+ compositor_class->set_active_window = meta_compositor_none_set_active_window;
+ compositor_class->begin_move = meta_compositor_none_begin_move;
+ compositor_class->update_move = meta_compositor_none_update_move;
+ compositor_class->end_move = meta_compositor_none_end_move;
+ compositor_class->free_window = meta_compositor_none_free_window;
+ compositor_class->maximize_window = meta_compositor_none_maximize_window;
+ compositor_class->unmaximize_window = meta_compositor_none_unmaximize_window;
+}
- return (MetaCompositor *) none;
+static void
+meta_compositor_none_init (MetaCompositorNone *none)
+{
}
diff --git a/src/compositor/meta-compositor-none.h b/src/compositor/meta-compositor-none.h
index c81dceb..2f6478d 100644
--- a/src/compositor/meta-compositor-none.h
+++ b/src/compositor/meta-compositor-none.h
@@ -18,8 +18,14 @@
#ifndef META_COMPOSITOR_NONE_H
#define META_COMPOSITOR_NONE_H
-#include "types.h"
+#include "meta-compositor-private.h"
-MetaCompositor *meta_compositor_none_new (MetaDisplay *display);
+G_BEGIN_DECLS
+
+#define META_TYPE_COMPOSITOR_NONE meta_compositor_none_get_type ()
+G_DECLARE_FINAL_TYPE (MetaCompositorNone, meta_compositor_none,
+ META, COMPOSITOR_NONE, MetaCompositor)
+
+G_END_DECLS
#endif
diff --git a/src/compositor/meta-compositor-private.h b/src/compositor/meta-compositor-private.h
index 8d005d3..a0a4a0d 100644
--- a/src/compositor/meta-compositor-private.h
+++ b/src/compositor/meta-compositor-private.h
@@ -21,9 +21,14 @@
#include "meta-compositor.h"
-struct _MetaCompositor
+G_BEGIN_DECLS
+
+struct _MetaCompositorClass
{
- void (* destroy) (MetaCompositor *compositor);
+ GObjectClass parent_class;
+
+ gboolean (* initable_init) (MetaCompositor *compositor,
+ GError **error);
void (* manage_screen) (MetaCompositor *compositor,
MetaScreen *screen);
@@ -78,4 +83,6 @@ struct _MetaCompositor
MetaWindow *window);
};
+G_END_DECLS
+
#endif
diff --git a/src/compositor/meta-compositor-xrender.c b/src/compositor/meta-compositor-xrender.c
index 5d1bb44..a407638 100644
--- a/src/compositor/meta-compositor-xrender.c
+++ b/src/compositor/meta-compositor-xrender.c
@@ -1,22 +1,22 @@
-/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
-
/*
* Copyright (C) 2007 Iain Holmes
- * Based on xcompmgr - (c) 2003 Keith Packard
- * xfwm4 - (c) 2005-2007 Olivier Fourdan
+ * Copyright (C) 2017 Alberts Muktupāvels
+ *
+ * Based on xcompmgr - (C) 2003 Keith Packard
+ * xfwm4 - (C) 2005-2007 Olivier Fourdan
*
- * 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 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.
+ * 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, see <http://www.gnu.org/licenses/>.
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#define _GNU_SOURCE
@@ -40,7 +40,6 @@
#include "errors.h"
#include "prefs.h"
#include "window.h"
-#include "meta-compositor-private.h"
#include "meta-compositor-xrender.h"
#include "xprops.h"
#include "util.h"
@@ -72,18 +71,16 @@ typedef enum _MetaShadowType
LAST_SHADOW_TYPE
} MetaShadowType;
-typedef struct _MetaCompositorXRender
+struct _MetaCompositorXRender
{
- MetaCompositor compositor;
-
- MetaDisplay *display;
+ MetaCompositor parent;
#ifdef USE_IDLE_REPAINT
guint repaint_id;
#endif
guint show_redraw : 1;
guint debug : 1;
-} MetaCompositorXRender;
+};
typedef struct _conv
{
@@ -200,6 +197,8 @@ typedef struct _MetaCompWindow
#define SHADOW_OPACITY 0.66
+G_DEFINE_TYPE (MetaCompositorXRender, meta_compositor_xrender, META_TYPE_COMPOSITOR)
+
/* Gaussian stuff for creating the shadows */
static double
gaussian (double r,
@@ -251,7 +250,9 @@ dump_xserver_region (MetaCompositorXRender *xrender,
const gchar *location,
XserverRegion region)
{
- Display *xdisplay = meta_display_get_xdisplay (xrender->display);
+ MetaCompositor *compositor = META_COMPOSITOR (xrender);
+ MetaDisplay *display = meta_compositor_get_display (compositor);
+ Display *xdisplay = meta_display_get_xdisplay (display);
int nrects;
XRectangle *rects;
XRectangle bounds;
@@ -1813,7 +1814,9 @@ repair_screen (MetaCompositorXRender *xrender,
static void
repair_display (MetaCompositorXRender *xrender)
{
- MetaScreen *screen = meta_display_get_screen (xrender->display);
+ MetaCompositor *compositor = META_COMPOSITOR (xrender);
+ MetaDisplay *display = meta_compositor_get_display (compositor);
+ MetaScreen *screen = meta_display_get_screen (display);
#ifdef USE_IDLE_REPAINT
if (xrender->repaint_id > 0)
@@ -1830,29 +1833,29 @@ repair_display (MetaCompositorXRender *xrender)
static gboolean
compositor_idle_cb (gpointer data)
{
- MetaCompositorXRender *compositor = (MetaCompositorXRender *) data;
+ MetaCompositorXRender *xrender = META_COMPOSITOR_XRENDER (data);
- compositor->repaint_id = 0;
- repair_display (compositor);
+ xrender->repaint_id = 0;
+ repair_display (xrender);
return FALSE;
}
static void
-add_repair (MetaCompositorXRender *compositor)
+add_repair (MetaCompositorXRender *xrender)
{
- if (compositor->repaint_id > 0)
+ if (xrender->repaint_id > 0)
return;
#if 1
- compositor->repaint_id = g_idle_add_full (G_PRIORITY_HIGH_IDLE,
- compositor_idle_cb, compositor,
- NULL);
+ xrender->repaint_id = g_idle_add_full (G_PRIORITY_HIGH_IDLE,
+ compositor_idle_cb, xrender,
+ NULL);
#else
/* Limit it to 50fps */
- compositor->repaint_id = g_timeout_add_full (G_PRIORITY_HIGH, 20,
- compositor_idle_cb, compositor,
- NULL);
+ xrender->repaint_id = g_timeout_add_full (G_PRIORITY_HIGH, 20,
+ compositor_idle_cb, xrender,
+ NULL);
#endif
}
#endif
@@ -1862,7 +1865,9 @@ add_damage (MetaCompositorXRender *xrender,
MetaScreen *screen,
XserverRegion damage)
{
- Display *xdisplay = meta_display_get_xdisplay (xrender->display);
+ MetaCompositor *compositor = META_COMPOSITOR (xrender);
+ MetaDisplay *display = meta_compositor_get_display (compositor);
+ Display *xdisplay = meta_display_get_xdisplay (display);
MetaCompScreen *info = meta_screen_get_compositor_data (screen);
/* dump_xserver_region (xrender, "add_damage", damage); */
@@ -1884,7 +1889,9 @@ static void
damage_screen (MetaCompositorXRender *xrender,
MetaScreen *screen)
{
- Display *xdisplay = meta_display_get_xdisplay (xrender->display);
+ MetaCompositor *compositor = META_COMPOSITOR (xrender);
+ MetaDisplay *display = meta_compositor_get_display (compositor);
+ Display *xdisplay = meta_display_get_xdisplay (display);
XserverRegion region;
int width, height;
XRectangle r;
@@ -1905,10 +1912,12 @@ repair_win (MetaCompositorXRender *xrender,
MetaCompWindow *cw)
{
MetaScreen *screen = cw->screen;
- Display *xdisplay = meta_display_get_xdisplay (xrender->display);
+ MetaCompositor *compositor = META_COMPOSITOR (xrender);
+ MetaDisplay *display = meta_compositor_get_display (compositor);
+ Display *xdisplay = meta_display_get_xdisplay (display);
XserverRegion parts;
- meta_error_trap_push (xrender->display);
+ meta_error_trap_push (NULL);
if (!cw->damaged)
{
@@ -1924,7 +1933,7 @@ repair_win (MetaCompositorXRender *xrender,
cw->attrs.y + cw->attrs.border_width);
}
- meta_error_trap_pop (xrender->display);
+ meta_error_trap_pop (NULL);
dump_xserver_region (xrender, "repair_win", parts);
add_damage (xrender, screen, parts);
@@ -2135,7 +2144,9 @@ determine_mode (MetaCompositorXRender *xrender,
MetaCompWindow *cw)
{
XRenderPictFormat *format;
- Display *xdisplay = meta_display_get_xdisplay (xrender->display);
+ MetaCompositor *compositor = META_COMPOSITOR (xrender);
+ MetaDisplay *display = meta_compositor_get_display (compositor);
+ Display *xdisplay = meta_display_get_xdisplay (display);
if (cw->alpha_pict)
{
@@ -2350,11 +2361,15 @@ static void
destroy_win (MetaCompositorXRender *xrender,
Window xwindow)
{
+ MetaCompositor *compositor;
+ MetaDisplay *display;
MetaScreen *screen;
MetaCompScreen *info;
MetaCompWindow *cw;
- cw = find_window_in_display (xrender->display, xwindow);
+ compositor = META_COMPOSITOR (xrender);
+ display = meta_compositor_get_display (compositor);
+ cw = find_window_in_display (display, xwindow);
if (cw == NULL)
return;
@@ -2602,11 +2617,12 @@ resize_win (MetaCompositorXRender *xrender,
/* event processors must all be called with an error trap in place */
static void
-process_circulate_notify (MetaCompositorXRender *compositor,
- XCirculateEvent *event)
+process_circulate_notify (MetaCompositorXRender *xrender,
+ XCirculateEvent *event)
{
- MetaCompWindow *cw = find_window_in_display (compositor->display,
- event->window);
+ MetaCompositor *compositor = META_COMPOSITOR (xrender);
+ MetaDisplay *display = meta_compositor_get_display (compositor);
+ MetaCompWindow *cw = find_window_in_display (display, event->window);
MetaCompWindow *top;
MetaCompScreen *info;
MetaScreen *screen;
@@ -2633,31 +2649,32 @@ process_circulate_notify (MetaCompositorXRender *compositor,
}
#ifdef USE_IDLE_REPAINT
- add_repair (compositor);
+ add_repair (xrender);
#endif
}
static void
-process_configure_notify (MetaCompositorXRender *compositor,
- XConfigureEvent *event)
+process_configure_notify (MetaCompositorXRender *xrender,
+ XConfigureEvent *event)
{
- MetaDisplay *display = compositor->display;
+ MetaCompositor *compositor = META_COMPOSITOR (xrender);
+ MetaDisplay *display = meta_compositor_get_display (compositor);
Display *xdisplay = meta_display_get_xdisplay (display);
MetaCompWindow *cw = find_window_in_display (display, event->window);
if (cw)
{
- if (compositor->debug)
+ if (xrender->debug)
{
fprintf (stderr, "configure notify %d %d %d\n", cw->damaged,
cw->shaped, cw->needs_shadow);
- dump_xserver_region (compositor, "\textents", cw->extents);
+ dump_xserver_region (xrender, "\textents", cw->extents);
fprintf (stderr, "\txy (%d %d), wh (%d %d)\n",
event->x, event->y, event->width, event->height);
}
restack_win (cw, event->above);
- resize_win (compositor, cw, event->x, event->y, event->width, event->height,
+ resize_win (xrender, cw, event->x, event->y, event->width, event->height,
event->border_width, event->override_redirect);
}
else
@@ -2677,15 +2694,16 @@ process_configure_notify (MetaCompositorXRender *compositor,
info->root_buffer = None;
}
- damage_screen (compositor, screen);
+ damage_screen (xrender, screen);
}
}
static void
-process_property_notify (MetaCompositorXRender *compositor,
+process_property_notify (MetaCompositorXRender *xrender,
XPropertyEvent *event)
{
- MetaDisplay *display = compositor->display;
+ MetaCompositor *compositor = META_COMPOSITOR (xrender);
+ MetaDisplay *display = meta_compositor_get_display (compositor);
Display *xdisplay = meta_display_get_xdisplay (display);
MetaScreen *screen;
int p;
@@ -2713,9 +2731,9 @@ process_property_notify (MetaCompositorXRender *compositor,
/* Damage the whole screen as we may need to redraw the
background ourselves */
- damage_screen (compositor, screen);
+ damage_screen (xrender, screen);
#ifdef USE_IDLE_REPAINT
- add_repair (compositor);
+ add_repair (xrender);
#endif
return;
@@ -2747,7 +2765,7 @@ process_property_notify (MetaCompositorXRender *compositor,
value = OPAQUE;
cw->opacity = (guint)value;
- determine_mode (compositor, cw->screen, cw);
+ determine_mode (xrender, cw->screen, cw);
cw->needs_shadow = window_has_shadow (cw);
if (cw->shadow)
@@ -2762,7 +2780,7 @@ process_property_notify (MetaCompositorXRender *compositor,
cw->damaged = TRUE;
#ifdef USE_IDLE_REPAINT
- add_repair (compositor);
+ add_repair (xrender);
#endif
return;
@@ -2786,7 +2804,9 @@ expose_area (MetaCompositorXRender *xrender,
XRectangle *rects,
int nrects)
{
- Display *xdisplay = meta_display_get_xdisplay (xrender->display);
+ MetaCompositor *compositor = META_COMPOSITOR (xrender);
+ MetaDisplay *display = meta_compositor_get_display (compositor);
+ Display *xdisplay = meta_display_get_xdisplay (display);
XserverRegion region;
region = XFixesCreateRegion (xdisplay, rects, nrects);
@@ -2796,11 +2816,12 @@ expose_area (MetaCompositorXRender *xrender,
}
static void
-process_expose (MetaCompositorXRender *compositor,
+process_expose (MetaCompositorXRender *xrender,
XExposeEvent *event)
{
- MetaCompWindow *cw = find_window_in_display (compositor->display,
- event->window);
+ MetaCompositor *compositor = META_COMPOSITOR (xrender);
+ MetaDisplay *display = meta_compositor_get_display (compositor);
+ MetaCompWindow *cw = find_window_in_display (display, event->window);
MetaScreen *screen = NULL;
XRectangle rect[1];
int origin_x = 0, origin_y = 0;
@@ -2813,8 +2834,7 @@ process_expose (MetaCompositorXRender *compositor,
}
else
{
- screen = meta_display_screen_for_root (compositor->display,
- event->window);
+ screen = meta_display_screen_for_root (display, event->window);
if (screen == NULL)
return;
}
@@ -2824,13 +2844,15 @@ process_expose (MetaCompositorXRender *compositor,
rect[0].width = event->width;
rect[0].height = event->height;
- expose_area (compositor, screen, rect, 1);
+ expose_area (xrender, screen, rect, 1);
}
static void
-process_unmap (MetaCompositorXRender *compositor,
+process_unmap (MetaCompositorXRender *xrender,
XUnmapEvent *event)
{
+ MetaCompositor *compositor = META_COMPOSITOR (xrender);
+ MetaDisplay *display = meta_compositor_get_display (compositor);
MetaCompWindow *cw;
if (event->from_configure)
@@ -2839,83 +2861,93 @@ process_unmap (MetaCompositorXRender *compositor,
return;
}
- cw = find_window_in_display (compositor->display, event->window);
+ cw = find_window_in_display (display, event->window);
if (cw)
- unmap_win (compositor, cw->screen, event->window);
+ unmap_win (xrender, cw->screen, event->window);
}
static void
-process_map (MetaCompositorXRender *compositor,
+process_map (MetaCompositorXRender *xrender,
XMapEvent *event)
{
- MetaCompWindow *cw = find_window_in_display (compositor->display,
- event->window);
+ MetaCompositor *compositor = META_COMPOSITOR (xrender);
+ MetaDisplay *display = meta_compositor_get_display (compositor);
+ MetaCompWindow *cw = find_window_in_display (display, event->window);
if (cw)
- map_win (compositor->display, cw->screen, event->window);
+ map_win (display, cw->screen, event->window);
}
static void
-process_reparent (MetaCompositorXRender *compositor,
+process_reparent (MetaCompositorXRender *xrender,
XReparentEvent *event,
MetaWindow *window)
{
+ MetaCompositor *compositor = META_COMPOSITOR (xrender);
+ MetaDisplay *display = meta_compositor_get_display (compositor);
MetaScreen *screen;
- screen = meta_display_screen_for_root (compositor->display, event->parent);
+ screen = meta_display_screen_for_root (display, event->parent);
if (screen != NULL)
- add_win (compositor, screen, window, event->window);
+ add_win (xrender, screen, window, event->window);
else
- destroy_win (compositor, event->window);
+ destroy_win (xrender, event->window);
}
static void
-process_create (MetaCompositorXRender *compositor,
+process_create (MetaCompositorXRender *xrender,
XCreateWindowEvent *event,
MetaWindow *window)
{
+ MetaCompositor *compositor = META_COMPOSITOR (xrender);
+ MetaDisplay *display = meta_compositor_get_display (compositor);
MetaScreen *screen;
- /* We are only interested in top level windows, others will
- be caught by normal metacity functions */
- screen = meta_display_screen_for_root (compositor->display, event->parent);
+ /* We are only interested in top level windows, others will be caught
+ * by normal metacity functions.
+ */
+
+ screen = meta_display_screen_for_root (display, event->parent);
if (screen == NULL)
return;
- if (!find_window_in_display (compositor->display, event->window))
- add_win (compositor, screen, window, event->window);
+ if (!find_window_in_display (display, event->window))
+ add_win (xrender, screen, window, event->window);
}
static void
-process_destroy (MetaCompositorXRender *compositor,
+process_destroy (MetaCompositorXRender *xrender,
XDestroyWindowEvent *event)
{
- destroy_win (compositor, event->window);
+ destroy_win (xrender, event->window);
}
static void
-process_damage (MetaCompositorXRender *compositor,
+process_damage (MetaCompositorXRender *xrender,
XDamageNotifyEvent *event)
{
- MetaCompWindow *cw = find_window_in_display (compositor->display,
- event->drawable);
+ MetaCompositor *compositor = META_COMPOSITOR (xrender);
+ MetaDisplay *display = meta_compositor_get_display (compositor);
+ MetaCompWindow *cw = find_window_in_display (display, event->drawable);
+
if (cw == NULL)
return;
- repair_win (compositor, cw);
+ repair_win (xrender, cw);
#ifdef USE_IDLE_REPAINT
if (event->more == FALSE)
- add_repair (compositor);
+ add_repair (xrender);
#endif
}
static void
-process_shape (MetaCompositorXRender *compositor,
+process_shape (MetaCompositorXRender *xrender,
XShapeEvent *event)
{
- MetaCompWindow *cw = find_window_in_display (compositor->display,
- event->window);
+ MetaCompositor *compositor = META_COMPOSITOR (xrender);
+ MetaDisplay *display = meta_compositor_get_display (compositor);
+ MetaCompWindow *cw = find_window_in_display (display, event->window);
if (cw == NULL)
return;
@@ -2925,7 +2957,7 @@ process_shape (MetaCompositorXRender *compositor,
if (!event->shaped && cw->shaped)
cw->shaped = FALSE;
- resize_win (compositor, cw, cw->attrs.x, cw->attrs.y,
+ resize_win (xrender, cw, cw->attrs.x, cw->attrs.y,
event->width + event->x, event->height + event->y,
cw->attrs.border_width, cw->attrs.override_redirect);
@@ -2995,7 +3027,8 @@ show_overlay_window (MetaCompositorXRender *xrender,
MetaScreen *screen,
Window cow)
{
- Display *xdisplay = meta_display_get_xdisplay (xrender->display);
+ MetaDisplay *display = meta_screen_get_display (screen);
+ Display *xdisplay = meta_display_get_xdisplay (display);
XserverRegion region;
region = XFixesCreateRegion (xdisplay, NULL, 0);
@@ -3036,10 +3069,17 @@ get_output_window (MetaScreen *screen)
return output;
}
-static void
-meta_compositor_xrender_destroy (MetaCompositor *compositor)
+static gboolean
+meta_compositor_xrender_initable_init (MetaCompositor *compositor,
+ GError **error)
{
- g_free (compositor);
+#ifdef USE_IDLE_REPAINT
+ meta_verbose ("Using idle repaint\n");
+#endif
+
+ g_timeout_add (2000, (GSourceFunc) timeout_debug, compositor);
+
+ return TRUE;
}
static void
@@ -3047,7 +3087,7 @@ meta_compositor_xrender_manage_screen (MetaCompositor *compositor,
MetaScreen *screen)
{
MetaCompScreen *info;
- MetaCompositorXRender *xrc = (MetaCompositorXRender *) compositor;
+ MetaCompositorXRender *xrender = META_COMPOSITOR_XRENDER (compositor);
MetaDisplay *display = meta_screen_get_display (screen);
Display *xdisplay = meta_display_get_xdisplay (display);
XRenderPictureAttributes pa;
@@ -3122,7 +3162,7 @@ meta_compositor_xrender_manage_screen (MetaCompositor *compositor,
meta_screen_set_cm_selection (screen);
/* Now we're up and running we can show the output if needed */
- show_overlay_window (xrc, screen, info->output);
+ show_overlay_window (xrender, screen, info->output);
meta_prefs_add_listener (update_shadows, info);
}
@@ -3187,12 +3227,12 @@ meta_compositor_xrender_add_window (MetaCompositor *compositor,
Window xwindow,
XWindowAttributes *attrs)
{
- MetaCompositorXRender *xrender = (MetaCompositorXRender *) compositor;
+ MetaCompositorXRender *xrender = META_COMPOSITOR_XRENDER (compositor);
MetaScreen *screen = meta_screen_for_x_screen (attrs->screen);
- meta_error_trap_push (xrender->display);
+ meta_error_trap_push (NULL);
add_win (xrender, screen, window, xwindow);
- meta_error_trap_pop (xrender->display);
+ meta_error_trap_pop (NULL);
}
static void
@@ -3213,67 +3253,74 @@ meta_compositor_xrender_process_event (MetaCompositor *compositor,
XEvent *event,
MetaWindow *window)
{
- MetaCompositorXRender *xrc = (MetaCompositorXRender *) compositor;
+ MetaCompositorXRender *xrender;
+ MetaDisplay *display;
+
+ xrender = META_COMPOSITOR_XRENDER (compositor);
+ display = meta_compositor_get_display (compositor);
+
/*
* This trap is so that none of the compositor functions cause
* X errors. This is really a hack, but I'm afraid I don't understand
* enough about Metacity/X to know how else you are supposed to do it
*/
- meta_error_trap_push (xrc->display);
+ meta_error_trap_push (NULL);
+
switch (event->type)
{
case CirculateNotify:
- process_circulate_notify (xrc, (XCirculateEvent *) event);
+ process_circulate_notify (xrender, (XCirculateEvent *) event);
break;
case ConfigureNotify:
- process_configure_notify (xrc, (XConfigureEvent *) event);
+ process_configure_notify (xrender, (XConfigureEvent *) event);
break;
case PropertyNotify:
- process_property_notify (xrc, (XPropertyEvent *) event);
+ process_property_notify (xrender, (XPropertyEvent *) event);
break;
case Expose:
- process_expose (xrc, (XExposeEvent *) event);
+ process_expose (xrender, (XExposeEvent *) event);
break;
case UnmapNotify:
- process_unmap (xrc, (XUnmapEvent *) event);
+ process_unmap (xrender, (XUnmapEvent *) event);
break;
case MapNotify:
- process_map (xrc, (XMapEvent *) event);
+ process_map (xrender, (XMapEvent *) event);
break;
case ReparentNotify:
- process_reparent (xrc, (XReparentEvent *) event, window);
+ process_reparent (xrender, (XReparentEvent *) event, window);
break;
case CreateNotify:
- process_create (xrc, (XCreateWindowEvent *) event, window);
+ process_create (xrender, (XCreateWindowEvent *) event, window);
break;
case DestroyNotify:
- process_destroy (xrc, (XDestroyWindowEvent *) event);
+ process_destroy (xrender, (XDestroyWindowEvent *) event);
break;
default:
- if (event->type == meta_display_get_damage_event_base (xrc->display) + XDamageNotify)
- process_damage (xrc, (XDamageNotifyEvent *) event);
- else if (event->type == meta_display_get_shape_event_base (xrc->display) + ShapeNotify)
- process_shape (xrc, (XShapeEvent *) event);
+ if (event->type == meta_display_get_damage_event_base (display) + XDamageNotify)
+ process_damage (xrender, (XDamageNotifyEvent *) event);
+ else if (event->type == meta_display_get_shape_event_base (display) + ShapeNotify)
+ process_shape (xrender, (XShapeEvent *) event);
else
{
- meta_error_trap_pop (xrc->display);
+ meta_error_trap_pop (NULL);
return;
}
break;
}
- meta_error_trap_pop (xrc->display);
+ meta_error_trap_pop (NULL);
+
#ifndef USE_IDLE_REPAINT
- repair_display (xrc);
+ repair_display (xrender);
#endif
}
@@ -3285,7 +3332,7 @@ meta_compositor_xrender_get_window_surface (MetaCompositor *compositor,
Window xwindow;
MetaScreen *screen;
MetaCompWindow *cw;
- MetaCompositorXRender *xrc;
+ MetaDisplay *display;
Display *xdisplay;
gboolean shaded;
Pixmap back_pixmap;
@@ -3311,8 +3358,8 @@ meta_compositor_xrender_get_window_surface (MetaCompositor *compositor,
if (cw == NULL)
return NULL;
- xrc = (MetaCompositorXRender *) compositor;
- xdisplay = meta_display_get_xdisplay (xrc->display);
+ display = meta_compositor_get_display (compositor);
+ xdisplay = meta_display_get_xdisplay (display);
shaded = meta_window_is_shaded (window);
back_pixmap = shaded ? cw->shaded.back_pixmap : cw->back_pixmap;
@@ -3413,17 +3460,15 @@ meta_compositor_xrender_set_active_window (MetaCompositor *compositor,
MetaScreen *screen,
MetaWindow *window)
{
- MetaCompositorXRender *xrc = (MetaCompositorXRender *) compositor;
+ MetaCompositorXRender *xrender;
MetaDisplay *display;
Display *xdisplay;
MetaCompWindow *old_focus = NULL, *new_focus = NULL;
MetaCompScreen *info = NULL;
MetaWindow *old_focus_win = NULL;
- if (compositor == NULL)
- return;
-
- display = xrc->display;
+ xrender = META_COMPOSITOR_XRENDER (compositor);
+ display = meta_compositor_get_display (compositor);
xdisplay = meta_display_get_xdisplay (display);
info = meta_screen_get_compositor_data (screen);
@@ -3460,7 +3505,7 @@ meta_compositor_xrender_set_active_window (MetaCompositor *compositor,
/* Tear down old shadows */
old_focus->shadow_type = META_SHADOW_MEDIUM;
- determine_mode (xrc, screen, old_focus);
+ determine_mode (xrender, screen, old_focus);
old_focus->needs_shadow = window_has_shadow (old_focus);
if (old_focus->attrs.map_state == IsViewable)
@@ -3497,8 +3542,8 @@ meta_compositor_xrender_set_active_window (MetaCompositor *compositor,
XFixesCopyRegion (xdisplay, damage, old_focus->extents);
}
- dump_xserver_region (xrc, "resize_win", damage);
- add_damage (xrc, screen, damage);
+ dump_xserver_region (xrender, "resize_win", damage);
+ add_damage (xrender, screen, damage);
if (info != NULL)
{
@@ -3512,7 +3557,7 @@ meta_compositor_xrender_set_active_window (MetaCompositor *compositor,
XserverRegion damage;
new_focus->shadow_type = META_SHADOW_LARGE;
- determine_mode (xrc, screen, new_focus);
+ determine_mode (xrender, screen, new_focus);
new_focus->needs_shadow = window_has_shadow (new_focus);
if (new_focus->mask)
@@ -3547,16 +3592,17 @@ meta_compositor_xrender_set_active_window (MetaCompositor *compositor,
XFixesCopyRegion (xdisplay, damage, new_focus->extents);
}
- dump_xserver_region (xrc, "resize_win", damage);
- add_damage (xrc, screen, damage);
+ dump_xserver_region (xrender, "resize_win", damage);
+ add_damage (xrender, screen, damage);
if (info != NULL)
{
info->clip_changed = TRUE;
}
}
+
#ifdef USE_IDLE_REPAINT
- add_repair (xrc);
+ add_repair (xrender);
#endif
}
@@ -3587,12 +3633,14 @@ static void
meta_compositor_xrender_free_window (MetaCompositor *compositor,
MetaWindow *window)
{
- MetaCompositorXRender *xrc;
+ MetaCompositorXRender *xrender;
+ MetaDisplay *display;
MetaFrame *frame;
Window xwindow;
MetaCompWindow *cw;
- xrc = (MetaCompositorXRender *) compositor;
+ xrender = META_COMPOSITOR_XRENDER (compositor);
+ display = meta_compositor_get_display (compositor);
frame = meta_window_get_frame (window);
if (frame)
@@ -3600,7 +3648,7 @@ meta_compositor_xrender_free_window (MetaCompositor *compositor,
else
xwindow = meta_window_get_xwindow (window);
- cw = find_window_in_display (xrc->display, xwindow);
+ cw = find_window_in_display (display, xwindow);
if (cw == NULL)
return;
@@ -3610,8 +3658,8 @@ meta_compositor_xrender_free_window (MetaCompositor *compositor,
if (cw->extents != None)
{
- dump_xserver_region (xrc, "destroy_win", cw->extents);
- add_damage (xrc, cw->screen, cw->extents);
+ dump_xserver_region (xrender, "destroy_win", cw->extents);
+ add_damage (xrender, cw->screen, cw->extents);
cw->extents = None;
}
@@ -3646,45 +3694,31 @@ meta_compositor_xrender_unmaximize_window (MetaCompositor *compositor,
cw->needs_shadow = window_has_shadow (cw);
}
-static MetaCompositor comp_info = {
- meta_compositor_xrender_destroy,
- meta_compositor_xrender_manage_screen,
- meta_compositor_xrender_unmanage_screen,
- meta_compositor_xrender_add_window,
- meta_compositor_xrender_remove_window,
- meta_compositor_xrender_set_updates,
- meta_compositor_xrender_process_event,
- meta_compositor_xrender_get_window_surface,
- meta_compositor_xrender_set_active_window,
- meta_compositor_xrender_begin_move,
- meta_compositor_xrender_update_move,
- meta_compositor_xrender_end_move,
- meta_compositor_xrender_free_window,
- meta_compositor_xrender_maximize_window,
- meta_compositor_xrender_unmaximize_window,
-};
-
-MetaCompositor *
-meta_compositor_xrender_new (MetaDisplay *display)
+static void
+meta_compositor_xrender_class_init (MetaCompositorXRenderClass *xrender_class)
{
- MetaCompositorXRender *xrc;
- MetaCompositor *compositor;
-
- xrc = g_new (MetaCompositorXRender, 1);
- xrc->compositor = comp_info;
-
- compositor = (MetaCompositor *) xrc;
+ MetaCompositorClass *compositor_class;
- xrc->display = display;
- xrc->show_redraw = FALSE;
- xrc->debug = FALSE;
+ compositor_class = META_COMPOSITOR_CLASS (xrender_class);
-#ifdef USE_IDLE_REPAINT
- meta_verbose ("Using idle repaint\n");
- xrc->repaint_id = 0;
-#endif
-
- g_timeout_add (2000, (GSourceFunc) timeout_debug, xrc);
+ compositor_class->initable_init = meta_compositor_xrender_initable_init;
+ compositor_class->manage_screen = meta_compositor_xrender_manage_screen;
+ compositor_class->unmanage_screen = meta_compositor_xrender_unmanage_screen;
+ compositor_class->add_window = meta_compositor_xrender_add_window;
+ compositor_class->remove_window = meta_compositor_xrender_remove_window;
+ compositor_class->set_updates = meta_compositor_xrender_set_updates;
+ compositor_class->process_event = meta_compositor_xrender_process_event;
+ compositor_class->get_window_surface = meta_compositor_xrender_get_window_surface;
+ compositor_class->set_active_window = meta_compositor_xrender_set_active_window;
+ compositor_class->begin_move = meta_compositor_xrender_begin_move;
+ compositor_class->update_move = meta_compositor_xrender_update_move;
+ compositor_class->end_move = meta_compositor_xrender_end_move;
+ compositor_class->free_window = meta_compositor_xrender_free_window;
+ compositor_class->maximize_window = meta_compositor_xrender_maximize_window;
+ compositor_class->unmaximize_window = meta_compositor_xrender_unmaximize_window;
+}
- return compositor;
+static void
+meta_compositor_xrender_init (MetaCompositorXRender *xrender)
+{
}
diff --git a/src/compositor/meta-compositor-xrender.h b/src/compositor/meta-compositor-xrender.h
index add080c..18ea6d1 100644
--- a/src/compositor/meta-compositor-xrender.h
+++ b/src/compositor/meta-compositor-xrender.h
@@ -1,29 +1,31 @@
-/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
-
/*
- * Copyright (C) 2007 Iain Holmes
- * Based on xcompmgr - (c) 2003 Keith Packard
- * xfwm4 - (c) 2005-2007 Olivier Fourdan
+ * Copyright (C) 2017 Alberts Muktupāvels
*
- * 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 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.
+ * 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, see <http://www.gnu.org/licenses/>.
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef META_COMPOSITOR_XRENDER_H
#define META_COMPOSITOR_XRENDER_H
-#include "types.h"
+#include "meta-compositor-private.h"
+
+G_BEGIN_DECLS
+
+#define META_TYPE_COMPOSITOR_XRENDER meta_compositor_xrender_get_type ()
+G_DECLARE_FINAL_TYPE (MetaCompositorXRender, meta_compositor_xrender,
+ META, COMPOSITOR_XRENDER, MetaCompositor)
-MetaCompositor *meta_compositor_xrender_new (MetaDisplay *display);
+G_END_DECLS
#endif
diff --git a/src/compositor/meta-compositor.c b/src/compositor/meta-compositor.c
index 05d8b33..ee0c19a 100644
--- a/src/compositor/meta-compositor.c
+++ b/src/compositor/meta-compositor.c
@@ -19,50 +19,190 @@
#include "config.h"
#include "meta-compositor-none.h"
-#include "meta-compositor-private.h"
#include "meta-compositor-xrender.h"
+typedef struct
+{
+ MetaDisplay *display;
+} MetaCompositorPrivate;
+
+enum
+{
+ PROP_0,
+
+ PROP_DISPLAY,
+
+ LAST_PROP
+};
+
+static GParamSpec *properties[LAST_PROP] = { NULL };
+
+static void initable_iface_init (GInitableIface *iface);
+
+G_DEFINE_ABSTRACT_TYPE_WITH_CODE (MetaCompositor, meta_compositor, G_TYPE_OBJECT,
+ G_ADD_PRIVATE (MetaCompositor)
+ G_IMPLEMENT_INTERFACE (G_TYPE_INITABLE,
+ initable_iface_init))
+
+static gboolean
+meta_compositor_initable_init (GInitable *initable,
+ GCancellable *cancellable,
+ GError **error)
+{
+ MetaCompositor *compositor;
+ MetaCompositorClass *compositor_class;
+
+ compositor = META_COMPOSITOR (initable);
+ compositor_class = META_COMPOSITOR_GET_CLASS (compositor);
+
+ return compositor_class->initable_init (compositor, error);
+}
+
+static void
+initable_iface_init (GInitableIface *iface)
+{
+ iface->init = meta_compositor_initable_init;
+}
+
+static void
+meta_compositor_get_property (GObject *object,
+ guint property_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ MetaCompositor *compositor;
+ MetaCompositorPrivate *priv;
+
+ compositor = META_COMPOSITOR (object);
+ priv = meta_compositor_get_instance_private (compositor);
+
+ switch (property_id)
+ {
+ case PROP_DISPLAY:
+ g_value_set_pointer (value, priv->display);
+ break;
+
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+ break;
+ }
+}
+
+static void
+meta_compositor_set_property (GObject *object,
+ guint property_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ MetaCompositor *compositor;
+ MetaCompositorPrivate *priv;
+
+ compositor = META_COMPOSITOR (object);
+ priv = meta_compositor_get_instance_private (compositor);
+
+ switch (property_id)
+ {
+ case PROP_DISPLAY:
+ priv->display = g_value_get_pointer (value);
+ break;
+
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+ break;
+ }
+}
+
+static void
+install_properties (GObjectClass *object_class)
+{
+ properties[PROP_DISPLAY] =
+ g_param_spec_pointer ("display", "display", "display",
+ G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE |
+ G_PARAM_STATIC_STRINGS);
+
+ g_object_class_install_properties (object_class, LAST_PROP, properties);
+}
+
+static void
+meta_compositor_class_init (MetaCompositorClass *compositor_class)
+{
+ GObjectClass *object_class;
+
+ object_class = G_OBJECT_CLASS (compositor_class);
+
+ object_class->get_property = meta_compositor_get_property;
+ object_class->set_property = meta_compositor_set_property;
+
+ install_properties (object_class);
+}
+
+static void
+meta_compositor_init (MetaCompositor *compositor)
+{
+}
+
MetaCompositor *
meta_compositor_new (MetaCompositorType type,
MetaDisplay *display)
{
+ GType gtype;
+ MetaCompositor *compositor;
+ GError *error;
+
switch (type)
{
case META_COMPOSITOR_TYPE_NONE:
- return meta_compositor_none_new (display);
+ gtype = META_TYPE_COMPOSITOR_NONE;
+ break;
case META_COMPOSITOR_TYPE_XRENDER:
- return meta_compositor_xrender_new (display);
+ gtype = META_TYPE_COMPOSITOR_XRENDER;
+ break;
default:
g_assert_not_reached ();
break;
}
- return NULL;
-}
+ compositor = g_object_new (gtype, "display", display, NULL);
-void
-meta_compositor_destroy (MetaCompositor *compositor)
-{
- if (compositor && compositor->destroy)
- compositor->destroy (compositor);
+ error = NULL;
+ if (!g_initable_init (G_INITABLE (compositor), NULL, &error))
+ {
+ g_warning ("Failed to create %s: %s", g_type_name (gtype), error->message);
+ g_error_free (error);
+
+ g_object_unref (compositor);
+
+ if (type != META_COMPOSITOR_TYPE_NONE)
+ compositor = meta_compositor_new (META_COMPOSITOR_TYPE_NONE, display);
+ }
+
+ g_assert (compositor != NULL);
+
+ return compositor;
}
void
meta_compositor_manage_screen (MetaCompositor *compositor,
MetaScreen *screen)
{
- if (compositor && compositor->manage_screen)
- compositor->manage_screen (compositor, screen);
+ MetaCompositorClass *compositor_class;
+
+ compositor_class = META_COMPOSITOR_GET_CLASS (compositor);
+
+ compositor_class->manage_screen (compositor, screen);
}
void
meta_compositor_unmanage_screen (MetaCompositor *compositor,
MetaScreen *screen)
{
- if (compositor && compositor->unmanage_screen)
- compositor->unmanage_screen (compositor, screen);
+ MetaCompositorClass *compositor_class;
+
+ compositor_class = META_COMPOSITOR_GET_CLASS (compositor);
+
+ compositor_class->unmanage_screen (compositor, screen);
}
void
@@ -71,16 +211,22 @@ meta_compositor_add_window (MetaCompositor *compositor,
Window xwindow,
XWindowAttributes *attrs)
{
- if (compositor && compositor->add_window)
- compositor->add_window (compositor, window, xwindow, attrs);
+ MetaCompositorClass *compositor_class;
+
+ compositor_class = META_COMPOSITOR_GET_CLASS (compositor);
+
+ compositor_class->add_window (compositor, window, xwindow, attrs);
}
void
meta_compositor_remove_window (MetaCompositor *compositor,
Window xwindow)
{
- if (compositor && compositor->remove_window)
- compositor->remove_window (compositor, xwindow);
+ MetaCompositorClass *compositor_class;
+
+ compositor_class = META_COMPOSITOR_GET_CLASS (compositor);
+
+ compositor_class->remove_window (compositor, xwindow);
}
void
@@ -88,8 +234,11 @@ meta_compositor_set_updates (MetaCompositor *compositor,
MetaWindow *window,
gboolean updates)
{
- if (compositor && compositor->set_updates)
- compositor->set_updates (compositor, window, updates);
+ MetaCompositorClass *compositor_class;
+
+ compositor_class = META_COMPOSITOR_GET_CLASS (compositor);
+
+ compositor_class->set_updates (compositor, window, updates);
}
void
@@ -97,18 +246,22 @@ meta_compositor_process_event (MetaCompositor *compositor,
XEvent *event,
MetaWindow *window)
{
- if (compositor && compositor->process_event)
- compositor->process_event (compositor, event, window);
+ MetaCompositorClass *compositor_class;
+
+ compositor_class = META_COMPOSITOR_GET_CLASS (compositor);
+
+ compositor_class->process_event (compositor, event, window);
}
cairo_surface_t *
meta_compositor_get_window_surface (MetaCompositor *compositor,
MetaWindow *window)
{
- if (compositor && compositor->get_window_surface)
- return compositor->get_window_surface (compositor, window);
- else
- return NULL;
+ MetaCompositorClass *compositor_class;
+
+ compositor_class = META_COMPOSITOR_GET_CLASS (compositor);
+
+ return compositor_class->get_window_surface (compositor, window);
}
void
@@ -116,8 +269,11 @@ meta_compositor_set_active_window (MetaCompositor *compositor,
MetaScreen *screen,
MetaWindow *window)
{
- if (compositor && compositor->set_active_window)
- compositor->set_active_window (compositor, screen, window);
+ MetaCompositorClass *compositor_class;
+
+ compositor_class = META_COMPOSITOR_GET_CLASS (compositor);
+
+ compositor_class->set_active_window (compositor, screen, window);
}
void
@@ -127,8 +283,11 @@ meta_compositor_begin_move (MetaCompositor *compositor,
gint grab_x,
gint grab_y)
{
- if (compositor && compositor->begin_move)
- compositor->begin_move (compositor, window, initial, grab_x, grab_y);
+ MetaCompositorClass *compositor_class;
+
+ compositor_class = META_COMPOSITOR_GET_CLASS (compositor);
+
+ compositor_class->begin_move (compositor, window, initial, grab_x, grab_y);
}
void
@@ -137,37 +296,63 @@ meta_compositor_update_move (MetaCompositor *compositor,
gint x,
gint y)
{
- if (compositor && compositor->update_move)
- compositor->update_move (compositor, window, x, y);
+ MetaCompositorClass *compositor_class;
+
+ compositor_class = META_COMPOSITOR_GET_CLASS (compositor);
+
+ compositor_class->update_move (compositor, window, x, y);
}
void
meta_compositor_end_move (MetaCompositor *compositor,
MetaWindow *window)
{
- if (compositor && compositor->end_move)
- compositor->end_move (compositor, window);
+ MetaCompositorClass *compositor_class;
+
+ compositor_class = META_COMPOSITOR_GET_CLASS (compositor);
+
+ compositor_class->end_move (compositor, window);
}
-void meta_compositor_free_window (MetaCompositor *compositor,
- MetaWindow *window)
+void
+meta_compositor_free_window (MetaCompositor *compositor,
+ MetaWindow *window)
{
- if (compositor && compositor->free_window)
- compositor->free_window (compositor, window);
+ MetaCompositorClass *compositor_class;
+
+ compositor_class = META_COMPOSITOR_GET_CLASS (compositor);
+
+ compositor_class->free_window (compositor, window);
}
void
meta_compositor_maximize_window (MetaCompositor *compositor,
MetaWindow *window)
{
- if (compositor && compositor->maximize_window)
- compositor->maximize_window (compositor, window);
+ MetaCompositorClass *compositor_class;
+
+ compositor_class = META_COMPOSITOR_GET_CLASS (compositor);
+
+ compositor_class->maximize_window (compositor, window);
}
void
meta_compositor_unmaximize_window (MetaCompositor *compositor,
MetaWindow *window)
{
- if (compositor && compositor->unmaximize_window)
- compositor->unmaximize_window (compositor, window);
+ MetaCompositorClass *compositor_class;
+
+ compositor_class = META_COMPOSITOR_GET_CLASS (compositor);
+
+ compositor_class->unmaximize_window (compositor, window);
+}
+
+MetaDisplay *
+meta_compositor_get_display (MetaCompositor *compositor)
+{
+ MetaCompositorPrivate *priv;
+
+ priv = meta_compositor_get_instance_private (compositor);
+
+ return priv->display;
}
diff --git a/src/core/display.c b/src/core/display.c
index 8771536..6cce3c0 100644
--- a/src/core/display.c
+++ b/src/core/display.c
@@ -253,7 +253,7 @@ update_compositor (MetaDisplay *display,
if (display->compositor != NULL)
{
meta_compositor_unmanage_screen (display->compositor, display->screen);
- meta_compositor_destroy (display->compositor);
+ g_object_unref (display->compositor);
}
if (meta_prefs_get_compositing_manager ())
@@ -844,7 +844,7 @@ meta_display_close (MetaDisplay *display,
meta_display_shutdown_keys (display);
- meta_compositor_destroy (display->compositor);
+ g_clear_object (&display->compositor);
g_free (display);
the_display = NULL;
diff --git a/src/include/meta-compositor.h b/src/include/meta-compositor.h
index f3abc19..1df3646 100644
--- a/src/include/meta-compositor.h
+++ b/src/include/meta-compositor.h
@@ -19,12 +19,18 @@
#ifndef META_COMPOSITOR_H
#define META_COMPOSITOR_H
-#include <glib.h>
+#include <glib-object.h>
#include <X11/Xlib.h>
#include "types.h"
#include "boxes.h"
+G_BEGIN_DECLS
+
+#define META_TYPE_COMPOSITOR meta_compositor_get_type ()
+G_DECLARE_DERIVABLE_TYPE (MetaCompositor, meta_compositor,
+ META, COMPOSITOR, GObject)
+
typedef enum
{
META_COMPOSITOR_TYPE_NONE,
@@ -34,8 +40,6 @@ typedef enum
MetaCompositor *meta_compositor_new (MetaCompositorType type,
MetaDisplay *display);
-void meta_compositor_destroy (MetaCompositor *compositor);
-
void meta_compositor_manage_screen (MetaCompositor *compositor,
MetaScreen *screen);
@@ -88,4 +92,8 @@ void meta_compositor_maximize_window (MetaCompositor *composi
void meta_compositor_unmaximize_window (MetaCompositor *compositor,
MetaWindow *window);
+MetaDisplay *meta_compositor_get_display (MetaCompositor *compositor);
+
+G_END_DECLS
+
#endif
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
