static gboolean test_case_wait (TestCase *test, GError **error) { GHashTableIter iter; gpointer key, value; /* First have each client set a XSync counter, and wait until * we receive the resulting event - so we know we've received * everything that the client have sent us. */ g_hash_table_iter_init (&iter, test->clients); while (g_hash_table_iter_next (&iter, &key, &value)) if (!test_client_wait (value, error)) return FALSE; /* Then wait until we've done any outstanding queued up work. * Though we add this as BEFORE_REDRAW, the iteration that runs the * BEFORE_REDRAW idles will proceed on and do the redraw, so we're * waiting until after *all* frame processing. */ meta_later_add (META_LATER_BEFORE_REDRAW, test_case_before_redraw, test, NULL); g_main_loop_run (test->loop); /* Then set an XSync counter ourselves and and wait until * we receive the resulting event - this makes sure that we've * received back any X events we generated. */ async_waiter_set_and_wait (test->waiter); return TRUE; }
void meta_xwayland_handle_wl_surface_id (MetaWindow *window, guint32 surface_id) { MetaWaylandCompositor *compositor = meta_wayland_compositor_get_default (); MetaXWaylandManager *manager = &compositor->xwayland_manager; if (!associate_window_with_surface_id (manager, window, surface_id)) { /* No surface ID yet... it should arrive after the next * iteration through the loop, so queue a later and see * what happens. */ AssociateWindowWithSurfaceOp *op = g_new0 (AssociateWindowWithSurfaceOp, 1); op->manager = manager; op->window = window; op->surface_id = surface_id; op->later_id = meta_later_add (META_LATER_BEFORE_REDRAW, associate_window_with_surface_later, op, NULL); g_signal_connect (op->window, "unmanaged", G_CALLBACK (associate_window_with_surface_window_unmanaged), op); } }
/** * meta_stack_tracker_queue_sync_stack: * @tracker: a #MetaStackTracker * * Queue informing the compositor of the new stacking order before the * next redraw. (See meta_stack_tracker_sync_stack()). This is called * internally when the stack of X windows changes, but also needs be * called directly when we an undecorated window is first shown or * withdrawn since the compositor's stacking order (which contains only * the windows that have a corresponding MetaWindow) will change without * any change to the stacking order of the X windows, if we are creating * or destroying MetaWindows. */ void meta_stack_tracker_queue_sync_stack (MetaStackTracker *tracker) { if (tracker->sync_stack_later == 0) { tracker->sync_stack_later = meta_later_add (META_LATER_SYNC_STACK, stack_tracker_sync_stack_later, tracker, NULL); } }
static void global_stage_notify_height (GObject *gobject, GParamSpec *pspec, gpointer data) { ShellGlobal *global = SHELL_GLOBAL (data); g_object_notify (G_OBJECT (global), "screen-height"); meta_later_add (META_LATER_BEFORE_REDRAW, on_screen_size_changed_cb, global, NULL); }
static void start (MetaPlugin *plugin) { MetaDefaultPlugin *self = META_DEFAULT_PLUGIN (plugin); MetaScreen *screen = meta_plugin_get_screen (plugin); self->priv->background_group = meta_background_group_new (); clutter_actor_insert_child_below (meta_get_window_group_for_screen (screen), self->priv->background_group, NULL); g_signal_connect (screen, "monitors-changed", G_CALLBACK (on_monitors_changed), plugin); on_monitors_changed (screen, plugin); meta_later_add (META_LATER_BEFORE_REDRAW, (GSourceFunc) show_stage, plugin, NULL); }