自学教程：C++ CLUTTER_NOTE函数代码示例

static ClutterStageWindow *clutter_backend_egl_create_stage (ClutterBackend  *backend,                                  ClutterStage    *wrapper,                                  GError         **error){  ClutterBackendX11 *backend_x11 = CLUTTER_BACKEND_X11 (backend);  ClutterStageX11 *stage_x11;  ClutterStageWindow *stage;  CLUTTER_NOTE (BACKEND, "Creating stage of type '%s'",                g_type_name (CLUTTER_STAGE_TYPE));    stage = g_object_new (CLUTTER_TYPE_STAGE_EGL, NULL);    /* copy backend data into the stage */  stage_x11 = CLUTTER_STAGE_X11 (stage);  stage_x11->wrapper = wrapper;    CLUTTER_NOTE (MISC, "EGLX stage created (display:%p, screen:%d, root:%u)",                backend_x11->xdpy,                backend_x11->xscreen_num,                (unsigned int) backend_x11->xwin_root);    return stage;}

static ClutterFeatureFlagsclutter_backend_real_get_features (ClutterBackend *backend){  ClutterFeatureFlags flags = 0;  if (cogl_clutter_winsys_has_feature (COGL_WINSYS_FEATURE_MULTIPLE_ONSCREEN))    {      CLUTTER_NOTE (BACKEND, "Cogl supports multiple onscreen framebuffers");      flags |= CLUTTER_FEATURE_STAGE_MULTIPLE;    }  else    {      CLUTTER_NOTE (BACKEND, "Cogl only supports one onscreen framebuffer");      flags |= CLUTTER_FEATURE_STAGE_STATIC;    }  if (cogl_clutter_winsys_has_feature (COGL_WINSYS_FEATURE_SWAP_THROTTLE))    {      CLUTTER_NOTE (BACKEND, "Cogl supports swap buffers throttling");      flags |= CLUTTER_FEATURE_SYNC_TO_VBLANK;    }  else    CLUTTER_NOTE (BACKEND, "Cogl doesn't support swap buffers throttling");  if (cogl_clutter_winsys_has_feature (COGL_WINSYS_FEATURE_SWAP_BUFFERS_EVENT))    {      CLUTTER_NOTE (BACKEND, "Cogl supports swap buffers complete events");      flags |= CLUTTER_FEATURE_SWAP_EVENTS;    }  return flags;}

static voidwait_for_vblank (ClutterBackendGLX *backend_glx){  if (backend_glx->vblank_type == CLUTTER_VBLANK_NONE)    return;  if (backend_glx->wait_video_sync)    {      unsigned int retraceCount;      CLUTTER_NOTE (BACKEND, "Waiting for vblank (wait_video_sync)");      backend_glx->get_video_sync (&retraceCount);      backend_glx->wait_video_sync (2,                                    (retraceCount + 1) % 2,                                    &retraceCount);    }  else    {#ifdef HAVE_DRM      drm_wait_vblank_t blank;      CLUTTER_NOTE (BACKEND, "Waiting for vblank (drm)");      blank.request.type     = _DRM_VBLANK_RELATIVE;      blank.request.sequence = 1;      blank.request.signal   = 0;      drm_wait_vblank (backend_glx->dri_fd, &blank);#else      CLUTTER_NOTE (BACKEND, "No vblank mechanism found");#endif /* HAVE_DRM */    }}

static voidset_foreign_window_callback (ClutterActor *actor,                             void         *data){  ForeignWindowData *fwd = data;  CLUTTER_NOTE (BACKEND, "Setting foreign window (0x%x)",                (guint) fwd->hwnd);  if (fwd->destroy_old_hwnd && fwd->stage_win32->hwnd != NULL)    {      CLUTTER_NOTE (BACKEND, "Destroying previous window (0x%x)",                    (guint) fwd->stage_win32->hwnd);      DestroyWindow (fwd->stage_win32->hwnd);    }  fwd->stage_win32->hwnd = fwd->hwnd;  fwd->stage_win32->is_foreign_win = TRUE;  fwd->stage_win32->win_width = fwd->geom.width;  fwd->stage_win32->win_height = fwd->geom.height;  clutter_actor_set_size (actor, fwd->geom.width, fwd->geom.height);  /* calling this with the stage unrealized will unset the stage   * from the GL context; once the stage is realized the GL context   * will be set again   */  clutter_stage_ensure_current (CLUTTER_STAGE (actor));}

gboolean_clutter_feature_init (GError **error){  ClutterMainContext *context;  CLUTTER_NOTE (MISC, "checking features");  if (!__features)    {      CLUTTER_NOTE (MISC, "allocating features data");      __features = g_new0 (ClutterFeatures, 1);      __features->features_set = FALSE; /* don't rely on zero-ing */    }  if (__features->features_set)    return TRUE;  context = _clutter_context_get_default ();  /* makes sure we have a GL context; if we have, this is a no-op */  if (!_clutter_backend_create_context (context->backend, error))    return FALSE;  __features->flags = (clutter_features_from_cogl (cogl_get_features ())                    | _clutter_backend_get_features (context->backend));  __features->features_set = TRUE;  CLUTTER_NOTE (MISC, "features checked");  return TRUE;}

static voidclutter_device_manager_win32_constructed (GObject *gobject){  ClutterDeviceManager *manager = CLUTTER_DEVICE_MANAGER (gobject);  ClutterDeviceManagerWin32 *manager_win32;  ClutterInputDevice *device;  device = g_object_new (CLUTTER_TYPE_INPUT_DEVICE,                         "id", 0,                         "name", "Core Pointer",                         "device-type", CLUTTER_POINTER_DEVICE,                         "device-mode", CLUTTER_INPUT_MODE_MASTER,                         "has-cursor", TRUE,                         "enabled", TRUE,                         NULL);  CLUTTER_NOTE (BACKEND, "Added core pointer device");  _clutter_device_manager_add_device (manager, device);  device = g_object_new (CLUTTER_TYPE_INPUT_DEVICE,                         "id", 1,                         "name", "Core Keyboard",                         "device-type", CLUTTER_KEYBOARD_DEVICE,                         "device-mode", CLUTTER_INPUT_MODE_MASTER,                         "enabled", TRUE,                         NULL);  CLUTTER_NOTE (BACKEND, "Added core keyboard device");  _clutter_device_manager_add_device (manager, device);  manager_win32 = CLUTTER_DEVICE_MANAGER_WIN32 (manager);  _clutter_input_device_set_associated_device (manager_win32->core_pointer,                                               manager_win32->core_keyboard);  _clutter_input_device_set_associated_device (manager_win32->core_keyboard,                                               manager_win32->core_pointer);}

ClutterFeatureFlagsclutter_backend_win32_get_features (ClutterBackend *backend){  ClutterBackendClass *parent_class;  ClutterFeatureFlags flags;  parent_class = CLUTTER_BACKEND_CLASS (clutter_backend_win32_parent_class);  flags = CLUTTER_FEATURE_STAGE_USER_RESIZE | CLUTTER_FEATURE_STAGE_CURSOR;  if (cogl_clutter_winsys_has_feature (COGL_WINSYS_FEATURE_MULTIPLE_ONSCREEN))    {      CLUTTER_NOTE (BACKEND, "Cogl supports multiple onscreen framebuffers");      flags |= CLUTTER_FEATURE_STAGE_MULTIPLE;    }  else    {      CLUTTER_NOTE (BACKEND, "Cogl only supports one onscreen framebuffer");      flags |= CLUTTER_FEATURE_STAGE_STATIC;    }  if (cogl_clutter_winsys_has_feature (COGL_WINSYS_FEATURE_SWAP_THROTTLE))    {      CLUTTER_NOTE (BACKEND, "Cogl supports swap buffers throttling");      flags |= CLUTTER_FEATURE_SYNC_TO_VBLANK;    }  else    CLUTTER_NOTE (BACKEND, "Cogl doesn't support swap buffers throttling");  CLUTTER_NOTE (BACKEND, "backend features checked");  return flags;}

static voidclutter_backend_win32_dispose (GObject *gobject){  ClutterBackend *backend = CLUTTER_BACKEND (gobject);  ClutterBackendWin32 *backend_win32 = CLUTTER_BACKEND_WIN32 (gobject);  ClutterStageManager *stage_manager;  CLUTTER_NOTE (BACKEND, "Disposing the of stages");  stage_manager = clutter_stage_manager_get_default ();  g_object_unref (stage_manager);  CLUTTER_NOTE (BACKEND, "Removing the event source");  _clutter_backend_win32_events_uninit (CLUTTER_BACKEND (backend_win32));  /* Unrealize all shaders, since the GL context is going away */  _clutter_shader_release_all ();  G_OBJECT_CLASS (clutter_backend_win32_parent_class)->dispose (gobject);  if (backend->cogl_context)    {      cogl_object_unref (backend->cogl_context);      backend->cogl_context = NULL;    }}

static voidnotify_cb (GObject          *object,           GParamSpec       *param_spec,           ClutterBehaviour *behave){  ClutterBehaviourClass *klass;  klass = CLUTTER_BEHAVIOUR_GET_CLASS (behave);  CLUTTER_NOTE (BEHAVIOUR, "notify::alpha");  /* no actors, we can stop right here */  if (behave->priv->actors == NULL)    return;  if (klass->alpha_notify)    {      gdouble alpha_value = clutter_alpha_get_alpha (behave->priv->alpha);      CLUTTER_NOTE (BEHAVIOUR, "calling %s::alpha_notify (%p, %.4f)",                    g_type_name (G_TYPE_FROM_CLASS (klass)),                    behave, alpha_value);      klass->alpha_notify (behave, alpha_value);    }}

void_clutter_feature_init (void){  ClutterMainContext *context;  CLUTTER_NOTE (MISC, "checking features");  if (!__features)    {      CLUTTER_NOTE (MISC, "allocating features data");      __features = g_new0 (ClutterFeatures, 1);      __features->features_set = FALSE; /* don't rely on zero-ing */    }  if (__features->features_set)    return;  context = _clutter_context_get_default ();  __features->flags = (_clutter_features_from_cogl (cogl_get_features ())                    | _clutter_backend_get_features (context->backend));  __features->features_set = TRUE;  CLUTTER_NOTE (MISC, "features checked");}

static ClutterStageWindow *clutter_backend_glx_create_stage (ClutterBackend  *backend,                                  ClutterStage    *wrapper,                                  GError         **error){  ClutterBackendX11 *backend_x11 = CLUTTER_BACKEND_X11 (backend);  ClutterStageWindow *stage_window;  ClutterStageX11 *stage_x11;  CLUTTER_NOTE (BACKEND, "Creating stage of type '%s'",                g_type_name (CLUTTER_STAGE_TYPE));  stage_window = g_object_new (CLUTTER_TYPE_STAGE_GLX, NULL);  /* copy backend data into the stage */  stage_x11 = CLUTTER_STAGE_X11 (stage_window);  stage_x11->wrapper = wrapper;  CLUTTER_NOTE (BACKEND,                "GLX stage created[%p] (dpy:%p, screen:%d, root:%u, wrap:%p)",                stage_window,                backend_x11->xdpy,                backend_x11->xscreen_num,                (unsigned int) backend_x11->xwin_root,                wrapper);  return stage_window;}

static voidclutter_glx_texture_pixmap_update_area (ClutterX11TexturePixmap *texture,                                        gint                     x,                                        gint                     y,                                        gint                     width,                                        gint                     height){  ClutterGLXTexturePixmapPrivate       *priv;  Display                              *dpy;  CLUTTER_NOTE (TEXTURE, "Updating texture pixmap");  priv = CLUTTER_GLX_TEXTURE_PIXMAP (texture)->priv;  dpy = clutter_x11_get_default_display();  if (!CLUTTER_ACTOR_IS_REALIZED (texture))    return;  if (priv->use_fallback)    {      CLUTTER_NOTE (TEXTURE, "Falling back to X11");      parent_class->update_area (texture,                                 x, y,                                 width, height);      return;    }  if (priv->glx_pixmap == None)    return;  if (texture_bind (CLUTTER_GLX_TEXTURE_PIXMAP(texture)))    {      CLUTTER_NOTE (TEXTURE, "Really updating via GLX");      clutter_x11_trap_x_errors ();      (_gl_bind_tex_image) (dpy,                            priv->glx_pixmap,                            GLX_FRONT_LEFT_EXT,                            NULL);      XSync (clutter_x11_get_default_display(), FALSE);      /* Note above fires X error for non name pixmaps - but       * things still seem to work - i.e pixmap updated       */      if (clutter_x11_untrap_x_errors ())        CLUTTER_NOTE (TEXTURE, "Update bind_tex_image failed");      priv->bound = TRUE;    }  else    g_warning ("Failed to bind initial tex");  if (CLUTTER_ACTOR_IS_VISIBLE (CLUTTER_ACTOR(texture)))    clutter_actor_queue_redraw (CLUTTER_ACTOR(texture));}

void_clutter_backend_ensure_context (ClutterBackend *backend,                                 ClutterStage   *stage){  static ClutterStage *current_context_stage = NULL;  ClutterBackendClass *klass;  g_return_if_fail (CLUTTER_IS_BACKEND (backend));  g_return_if_fail (CLUTTER_IS_STAGE (stage));  if (current_context_stage != stage || !CLUTTER_ACTOR_IS_REALIZED (stage))    {      ClutterStage *new_stage = NULL;      if (!CLUTTER_ACTOR_IS_REALIZED (stage))        {          new_stage = NULL;          CLUTTER_NOTE (MULTISTAGE,                        "Stage [%p] is not realized, unsetting the stage",                        stage);        }      else        {          new_stage = stage;          CLUTTER_NOTE (MULTISTAGE,                        "Setting the new stage [%p]",                        new_stage);        }      klass = CLUTTER_BACKEND_GET_CLASS (backend);      if (G_LIKELY (klass->ensure_context))        klass->ensure_context (backend, new_stage);            /* FIXME: With a NULL stage and thus no active context it may make more       * sense to clean the context but then re call with the default stage        * so at least there is some kind of context in place (as to avoid       * potential issue of GL calls with no context)       */      current_context_stage = new_stage;      /* if the new stage has a different size than the previous one       * we need to update the viewport; we do it by simply setting the       * SYNC_MATRICES flag and letting the next redraw cycle take care       * of calling glViewport()       */      if (current_context_stage)        {          CLUTTER_SET_PRIVATE_FLAGS (current_context_stage,                                     CLUTTER_ACTOR_SYNC_MATRICES);        }    }  else    CLUTTER_NOTE (MULTISTAGE, "Stage is the same");}

static voidclutter_backend_x11_create_device_manager (ClutterBackendX11 *backend_x11){  ClutterEventTranslator *translator;  ClutterBackend *backend;#ifdef HAVE_XINPUT_2  if (clutter_enable_xinput)    {      int event_base, first_event, first_error;      if (XQueryExtension (backend_x11->xdpy, "XInputExtension",                           &event_base,                           &first_event,                           &first_error))        {          int major = 2;          int minor = 3;          if (XIQueryVersion (backend_x11->xdpy, &major, &minor) != BadRequest)            {              CLUTTER_NOTE (BACKEND, "Creating XI2 device manager");              backend_x11->has_xinput = TRUE;              backend_x11->device_manager =                g_object_new (CLUTTER_TYPE_DEVICE_MANAGER_XI2,                              "backend", backend_x11,                              "opcode", event_base,                              NULL);              backend_x11->xi_minor = minor;            }        }    }  if (backend_x11->device_manager == NULL)#endif /* HAVE_XINPUT_2 */    {      CLUTTER_NOTE (BACKEND, "Creating Core device manager");      backend_x11->has_xinput = FALSE;      backend_x11->device_manager =        g_object_new (CLUTTER_TYPE_DEVICE_MANAGER_X11,                      "backend", backend_x11,                      NULL);      backend_x11->xi_minor = -1;    }  backend = CLUTTER_BACKEND (backend_x11);  backend->device_manager = backend_x11->device_manager;  translator = CLUTTER_EVENT_TRANSLATOR (backend_x11->device_manager);  _clutter_backend_add_event_translator (backend, translator);}

static voidclutter_group_real_paint (ClutterActor *actor){  ClutterGroupPrivate *priv = CLUTTER_GROUP (actor)->priv;  CLUTTER_NOTE (PAINT, "ClutterGroup paint enter '%s'",                _clutter_actor_get_debug_name (actor));  g_list_foreach (priv->children, (GFunc) clutter_actor_paint, NULL);  CLUTTER_NOTE (PAINT, "ClutterGroup paint leave '%s'",                _clutter_actor_get_debug_name (actor));}

static gbooleanclutter_backend_glx_create_context (ClutterBackend  *backend,                                    gboolean         is_offscreen,                                    GError         **error){  ClutterBackendGLX *backend_glx = CLUTTER_BACKEND_GLX (backend);  ClutterBackendX11 *backend_x11 = CLUTTER_BACKEND_X11 (backend);  if (backend_glx->gl_context == None)    {      XVisualInfo *xvisinfo;      xvisinfo =        clutter_backend_x11_get_visual_info (backend_x11, is_offscreen);      CLUTTER_NOTE (GL, "Creating GL Context (display: %p, %s)",                    backend_x11->xdpy,                    is_offscreen ? "offscreen" : "onscreen");      backend_glx->gl_context = glXCreateContext (backend_x11->xdpy,                                                  xvisinfo,                                                  0,                                                  is_offscreen ? False : True);      XFree (xvisinfo);      if (backend_glx->gl_context == None)        {          g_set_error (error, CLUTTER_INIT_ERROR,                       CLUTTER_INIT_ERROR_BACKEND,                       "Unable to create suitable %s GL context",                       is_offscreen ? "offscreen" : "onscreen");          return FALSE;        }      if (!is_offscreen)        {          gboolean is_direct;          is_direct = glXIsDirect (backend_x11->xdpy,                                   backend_glx->gl_context);          CLUTTER_NOTE (GL, "Setting %s context",                        is_direct ? "direct" : "indirect");          _cogl_set_indirect_context (!is_direct);        }    }  return TRUE;}

/* * _clutter_input_device_update: * @device: a #ClutterInputDevice * * Updates the input @device by determining the #ClutterActor underneath the * pointer's cursor * * This function calls _clutter_input_device_set_actor() if needed. * * This function only works for #ClutterInputDevice of type * %CLUTTER_POINTER_DEVICE. * * Since: 1.2 */ClutterActor *_clutter_input_device_update (ClutterInputDevice *device,                              gboolean            emit_crossing){  ClutterStage *stage;  ClutterActor *new_cursor_actor;  ClutterActor *old_cursor_actor;  gint x, y;  if (device->device_type == CLUTTER_KEYBOARD_DEVICE)    return NULL;  stage = device->stage;  if (G_UNLIKELY (stage == NULL))    {      CLUTTER_NOTE (EVENT, "No stage defined for device '%s'",                    clutter_input_device_get_device_name (device));      return NULL;    }  clutter_input_device_get_device_coords (device, &x, &y);  old_cursor_actor = device->cursor_actor;  new_cursor_actor = _clutter_do_pick (stage, x, y, CLUTTER_PICK_REACTIVE);  /* if the pick could not find an actor then we do not update the   * input device, to avoid ghost enter/leave events; the pick should   * never fail, except for bugs in the glReadPixels() implementation   * in which case this is the safest course of action anyway   */  if (new_cursor_actor == NULL)    return NULL;  CLUTTER_NOTE (EVENT,                "Actor under cursor (device %d, at %d, %d): %s",                clutter_input_device_get_device_id (device),                x, y,                clutter_actor_get_name (new_cursor_actor) != NULL                  ? clutter_actor_get_name (new_cursor_actor)                  : G_OBJECT_TYPE_NAME (new_cursor_actor));  /* short-circuit here */  if (new_cursor_actor == old_cursor_actor)    return old_cursor_actor;  _clutter_input_device_set_actor (device, new_cursor_actor, emit_crossing);  return device->cursor_actor;}

static ClutterTranslateReturnclutter_keymap_x11_translate_event (ClutterEventTranslator *translator,                                    gpointer                native,                                    ClutterEvent           *event){  ClutterKeymapX11 *keymap_x11 = CLUTTER_KEYMAP_X11 (translator);  ClutterBackendX11 *backend_x11;  ClutterTranslateReturn retval;  XEvent *xevent;  backend_x11 = CLUTTER_BACKEND_X11 (keymap_x11->backend);  if (!backend_x11->use_xkb)    return CLUTTER_TRANSLATE_CONTINUE;  xevent = native;  retval = CLUTTER_TRANSLATE_CONTINUE;#ifdef HAVE_XKB  if (xevent->type == keymap_x11->xkb_event_base)    {      XkbEvent *xkb_event = (XkbEvent *) xevent;      switch (xkb_event->any.xkb_type)        {        case XkbStateNotify:          CLUTTER_NOTE (EVENT, "Updating keyboard state");          update_direction (keymap_x11, XkbStateGroup (&xkb_event->state));          update_locked_mods (keymap_x11, xkb_event->state.locked_mods);          retval = CLUTTER_TRANSLATE_REMOVE;          break;        case XkbNewKeyboardNotify:        case XkbMapNotify:          CLUTTER_NOTE (EVENT, "Updating keyboard mapping");          XkbRefreshKeyboardMapping (&xkb_event->map);          backend_x11->keymap_serial += 1;          retval = CLUTTER_TRANSLATE_REMOVE;          break;        default:          break;        }    }#endif /* HAVE_XKB */  return retval;}

static gbooleanclutter_backend_sdl_post_parse (ClutterBackend  *backend,                                GError         **error){  int err;  if (SDL_Init (SDL_INIT_VIDEO | SDL_INIT_NOPARACHUTE) < 0)    {      g_set_error (error, CLUTTER_INIT_ERROR,		   CLUTTER_INIT_ERROR_BACKEND,		   "Unable to Initialize SDL");      return FALSE;    }#if defined(WIN32)  err = SDL_GL_LoadLibrary ("opengl32.dll");#elif defined(__linux__) || defined(__FreeBSD__)  err = SDL_GL_LoadLibrary ("libGL.so");#else#error Your platform is not supported  err = 1;#endif  if (err != 0)    {      g_set_error (error, CLUTTER_INIT_ERROR,		   CLUTTER_INIT_ERROR_BACKEND,		   SDL_GetError ());      return FALSE;    }  CLUTTER_NOTE (BACKEND, "SDL successfully initialized");  return TRUE;}

/*< internal > * clutter_input_device_set_associated_device: * @device: a #ClutterInputDevice * @associated: (allow-none): a #ClutterInputDevice, or %NULL * * Sets the associated device for @device. * * This function keeps a reference on the associated device. */void_clutter_input_device_set_associated_device (ClutterInputDevice *device,                                             ClutterInputDevice *associated){  if (device->associated == associated)    return;  if (device->associated != NULL)    g_object_unref (device->associated);  device->associated = associated;  if (device->associated != NULL)    g_object_ref (device->associated);  CLUTTER_NOTE (MISC, "Associating device '%s' to device '%s'",                clutter_input_device_get_device_name (device),                device->associated != NULL                  ? clutter_input_device_get_device_name (device->associated)                  : "(none)");  if (device->device_mode != CLUTTER_INPUT_MODE_MASTER)    {      if (device->associated != NULL)        device->device_mode = CLUTTER_INPUT_MODE_SLAVE;      else        device->device_mode = CLUTTER_INPUT_MODE_FLOATING;      g_object_notify_by_pspec (G_OBJECT (device), obj_props[PROP_DEVICE_MODE]);    }}

static voidupdate_locked_mods (ClutterKeymapX11 *keymap_x11,                    gint              locked_mods){#if 0  gboolean old_caps_lock_state, old_num_lock_state;  old_caps_lock_state = keymap_x11->caps_lock_state;  old_num_lock_state  = keymap_x11->num_lock_state;#endif  keymap_x11->caps_lock_state = (locked_mods & CLUTTER_LOCK_MASK) != 0;  keymap_x11->num_lock_state  = (locked_mods & keymap_x11->num_lock_mask) != 0;  CLUTTER_NOTE (BACKEND, "Locks state changed - Num: %s, Caps: %s",                keymap_x11->num_lock_state ? "set" : "unset",                keymap_x11->caps_lock_state ? "set" : "unset");#if 0  /* Add signal to ClutterBackend? */  if ((keymap_x11->caps_lock_state != old_caps_lock_state) ||      (keymap_x11->num_lock_state != old_num_lock_state))    g_signal_emit_by_name (keymap_x11->backend, "key-lock-changed");#endif}

static gbooleanclutter_backend_egl_post_parse (ClutterBackend  *backend,                                GError         **error){    ClutterBackendEGL *backend_egl = CLUTTER_BACKEND_EGL(backend);    EGLBoolean status;    backend_egl->edpy = eglGetDisplay (EGL_DEFAULT_DISPLAY);    status = eglInitialize (backend_egl->edpy,                            &backend_egl->egl_version_major,                            &backend_egl->egl_version_minor);    if (status != EGL_TRUE)    {        g_set_error (error, CLUTTER_INIT_ERROR,                     CLUTTER_INIT_ERROR_BACKEND,                     "Unable to Initialize EGL");        return FALSE;    }    CLUTTER_NOTE (BACKEND, "EGL Reports version %i.%i",                  backend_egl->egl_version_major,                  backend_egl->egl_version_minor);    return TRUE;}

static voidclutter_backend_real_font_changed (ClutterBackend *backend){  backend->priv->units_per_em = get_units_per_em (backend, NULL);  CLUTTER_NOTE (BACKEND, "Units per em: %.2f", backend->priv->units_per_em);}

void_clutter_device_manager_wayland_add_input_group (ClutterDeviceManager *manager,                                                 uint32_t id){  ClutterBackend *backend = _clutter_device_manager_get_backend (manager);  ClutterBackendWayland *backend_wayland = CLUTTER_BACKEND_WAYLAND (backend);  ClutterInputDeviceWayland *device;  device = g_object_new (CLUTTER_TYPE_INPUT_DEVICE_WAYLAND,                         "id", id,                         "device-type", CLUTTER_POINTER_DEVICE,                         "name", "wayland device",                         "enabled", TRUE,                         NULL);  device->input_device =    wl_display_bind (backend_wayland->wayland_display, id,                     &wl_input_device_interface);  wl_input_device_add_listener (device->input_device,                                &_clutter_input_device_wayland_listener,                                device);  wl_input_device_set_user_data (device->input_device, device);  device->xkb = _clutter_xkb_desc_new (NULL,                                       option_xkb_layout,                                       option_xkb_variant,                                       option_xkb_options);  if (!device->xkb)    CLUTTER_NOTE (BACKEND, "Failed to compile keymap");  _clutter_device_manager_add_device (manager, CLUTTER_INPUT_DEVICE (device));}

static voidsend_wmspec_change_state (ClutterBackendX11 *backend_x11,                          Window             window,                          Atom               state,                          gboolean           add){  XClientMessageEvent xclient;  CLUTTER_NOTE (BACKEND, "%s NET_WM state", add ? "adding" : "removing");  memset (&xclient, 0, sizeof (xclient));  xclient.type         = ClientMessage;  xclient.window       = window;  xclient.message_type = backend_x11->atom_NET_WM_STATE;  xclient.format       = 32;  xclient.data.l[0] = add ? _NET_WM_STATE_ADD : _NET_WM_STATE_REMOVE;  xclient.data.l[1] = state;  xclient.data.l[2] = 0;  xclient.data.l[3] = 0;  xclient.data.l[4] = 0;  XSendEvent (backend_x11->xdpy,               DefaultRootWindow (backend_x11->xdpy),              False,              SubstructureRedirectMask | SubstructureNotifyMask,              (XEvent *)&xclient);}

GSource *_clutter_x11_event_source_new (ClutterBackendX11 *backend_x11){  ClutterEventSource *event_source;  int connection_number;  GSource *source;  gchar *name;  connection_number = ConnectionNumber (backend_x11->xdpy);  CLUTTER_NOTE (EVENT, "Connection number: %d", connection_number);  source = g_source_new (&event_funcs, sizeof (ClutterEventSource));  event_source = (ClutterEventSource *) source;  name = g_strdup_printf ("Clutter X11 Event (connection: %d)",                          connection_number);  g_source_set_name (source, name);  g_free (name);  event_source->backend = backend_x11;  event_source->event_poll_fd.fd = connection_number;  event_source->event_poll_fd.events = G_IO_IN;  g_source_add_poll (source, &event_source->event_poll_fd);  g_source_set_can_recurse (source, TRUE);  return source;}

static voidclutter_shader_effect_set_actor (ClutterActorMeta *meta,                                 ClutterActor     *actor){  ClutterShaderEffect *self = CLUTTER_SHADER_EFFECT (meta);  ClutterShaderEffectPrivate *priv = self->priv;  ClutterActorMetaClass *parent;  if (!clutter_feature_available (CLUTTER_FEATURE_SHADERS_GLSL))    {      /* if we don't have support for GLSL shaders then we       * forcibly disable the ActorMeta       */      g_warning ("Unable to use the ShaderEffect: the graphics hardware "                 "or the current GL driver does not implement support "                 "for the GLSL shading language.");      clutter_actor_meta_set_enabled (meta, FALSE);      return;    }  parent = CLUTTER_ACTOR_META_CLASS (clutter_shader_effect_parent_class);  parent->set_actor (meta, actor);  /* we keep a back pointer here */  priv->actor = clutter_actor_meta_get_actor (meta);  if (priv->actor == NULL)    return;  CLUTTER_NOTE (SHADER, "Preparing shader effect of type '%s'",                G_OBJECT_TYPE_NAME (meta));}

static voidstart_entry (ClutterScoreEntry *entry){  ClutterScorePrivate *priv = entry->score->priv;  /* timelines attached to a marker might already be playing when we   * end up here from the ::completed handler, so we need to perform   * this check to avoid restarting those timelines   */  if (clutter_timeline_is_playing (entry->timeline))    return;  entry->complete_id = g_signal_connect (entry->timeline,                                         "completed",                                         G_CALLBACK (on_timeline_completed),                                         entry);  CLUTTER_NOTE (SCHEDULER, "timeline [%p] ('%lu') started",                entry->timeline,                entry->id);  if (G_UNLIKELY (priv->running_timelines == NULL))    priv->running_timelines = g_hash_table_new (NULL, NULL);  g_hash_table_insert (priv->running_timelines,                       GUINT_TO_POINTER (entry->id),                       entry);  clutter_timeline_start (entry->timeline);  g_signal_emit (entry->score, score_signals[TIMELINE_STARTED], 0,                 entry->timeline);}

static voidclutter_backend_real_resolution_changed (ClutterBackend *backend){  ClutterBackendPrivate *priv = backend->priv;  ClutterMainContext *context;  ClutterSettings *settings;  gdouble resolution;  gint dpi;  settings = clutter_settings_get_default ();  g_object_get (settings, "font-dpi", &dpi, NULL);  if (dpi < 0)    resolution = 96.0;  else    resolution = dpi / 1024.0;  context = _clutter_context_get_default ();  if (context->font_map != NULL)    cogl_pango_font_map_set_resolution (context->font_map, resolution);  priv->units_per_em = get_units_per_em (backend, NULL);  priv->units_serial += 1;  CLUTTER_NOTE (BACKEND, "Units per em: %.2f", priv->units_per_em);}