Compositor::Compositor() : m_display(wl_display_create()) , m_time(0) { wl_list_init(&m_outputResources); if (wl_display_add_socket(m_display, 0)) { fprintf(stderr, "Fatal: Failed to open server socket\n"); exit(EXIT_FAILURE); } wl_display_add_global(m_display, &wl_compositor_interface, this, bindCompositor); m_data_device_manager.reset(new DataDeviceManager(this, m_display)); wl_display_init_shm(m_display); m_seat.reset(new Seat(this, m_display)); m_pointer = m_seat->pointer(); m_keyboard = m_seat->keyboard(); wl_display_add_global(m_display, &wl_output_interface, this, bindOutput); wl_display_add_global(m_display, &wl_shell_interface, this, bindShell); m_loop = wl_display_get_event_loop(m_display); m_fd = wl_event_loop_get_fd(m_loop); }
ClaylandSeat * clayland_seat_new (struct wl_display *display) { ClaylandSeat *seat = g_new0 (ClaylandSeat, 1); wl_signal_init (&seat->destroy_signal); seat->selection_data_source = NULL; wl_list_init (&seat->base_resource_list); wl_signal_init (&seat->selection_signal); wl_list_init (&seat->drag_resource_list); wl_signal_init (&seat->drag_icon_signal); clayland_pointer_init (&seat->pointer); clayland_keyboard_init (&seat->keyboard, display); seat->display = display; seat->current_stage = 0; seat->sprite = NULL; seat->sprite_destroy_listener.notify = pointer_handle_sprite_destroy; seat->hotspot_x = 16; seat->hotspot_y = 16; wl_display_add_global (display, &wl_seat_interface, seat, bind_seat); return seat; }
DataDeviceManager::DataDeviceManager(Compositor *compositor) : m_compositor(compositor) , m_current_selection_source(0) , m_retainedReadNotifier(0) , m_compositorOwnsSelection(false) { wl_display_add_global(compositor->wl_display(), &wl_data_device_manager_interface, this, DataDeviceManager::bind_func_drag); }
SubSurfaceExtensionGlobal::SubSurfaceExtensionGlobal(Compositor *compositor) : m_compositor(compositor) { wl_display_add_global(m_compositor->wl_display(), &qt_sub_surface_extension_interface, this, SubSurfaceExtensionGlobal::bind_func); }
OutputExtensionGlobal::OutputExtensionGlobal(Compositor *compositor) : m_compositor(compositor) { wl_display_add_global(compositor->wl_display(), &wl_output_extension_interface, this, OutputExtensionGlobal::bind_func); }
WL_EXPORT int wl_data_device_manager_init(struct wl_display *display) { if (wl_display_add_global(display, &wl_data_device_manager_interface, NULL, bind_manager) == NULL) return -1; return 0; }
static void cogland_compositor_create_output (CoglandCompositor *compositor, int x, int y, int width_mm, int height_mm) { CoglandOutput *output = g_slice_new0 (CoglandOutput); CoglFramebuffer *fb; CoglError *error = NULL; CoglandMode *mode; output->x = x; output->y = y; output->width_mm = width_mm; output->height_mm = height_mm; output->wayland_output.interface = &wl_output_interface; wl_display_add_global (compositor->wayland_display, &wl_output_interface, output, bind_output); output->onscreen = cogl_onscreen_new (compositor->cogl_context, width_mm, height_mm); /* Eventually there will be an implicit allocate on first use so this * will become optional... */ fb = output->onscreen; if (!cogl_framebuffer_allocate (fb, &error)) g_error ("Failed to allocate framebuffer: %s\n", error->message); cogl_onscreen_add_dirty_callback (output->onscreen, dirty_cb, compositor, NULL /* destroy */); cogl_onscreen_show (output->onscreen); cogl_framebuffer_set_viewport (fb, -x, -y, compositor->virtual_width, compositor->virtual_height); mode = g_slice_new0 (CoglandMode); mode->flags = 0; mode->width = width_mm; mode->height = height_mm; mode->refresh = 60; output->modes = g_list_prepend (output->modes, mode); compositor->outputs = g_list_prepend (compositor->outputs, output); }
TouchExtensionGlobal::TouchExtensionGlobal(Compositor *compositor) : m_compositor(compositor), m_flags(0) { wl_array_init(&m_rawdata_array); m_rawdata_ptr = static_cast<float *>(wl_array_add(&m_rawdata_array, maxRawPos * sizeof(float) * 2)); wl_display_add_global(compositor->wl_display(), &qt_touch_extension_interface, this, TouchExtensionGlobal::bind_func); }
Eina_Bool e_mod_comp_wl_output_init(void) { Ecore_X_Window *roots; int num = 0, rw, rh; LOGFN(__FILE__, __LINE__, __FUNCTION__); roots = ecore_x_window_root_list(&num); if ((!roots) || (num <= 0)) { EINA_LOG_ERR("Could not get root window list\n"); return EINA_FALSE; } ecore_x_window_size_get(roots[0], &rw, &rh); free(roots); if (!(_wl_output = malloc(sizeof(Wayland_Output)))) { EINA_LOG_ERR("Could not allocate space for output\n"); return EINA_FALSE; } memset(_wl_output, 0, sizeof(*_wl_output)); _wl_output->mode.flags = (WL_OUTPUT_MODE_CURRENT | WL_OUTPUT_MODE_PREFERRED); _wl_output->mode.w = rw; _wl_output->mode.h = rh; _wl_output->mode.refresh = 60; _wl_output->x = 0; _wl_output->y = 0; _wl_output->w = rw; _wl_output->h = rh; _wl_output->flags = WL_OUTPUT_FLIPPED; wl_list_init(&_wl_output->link); wl_list_init(&_wl_output->frame_callbacks); if (!wl_display_add_global(_wl_disp, &wl_output_interface, _wl_output, _e_mod_comp_wl_output_bind)) { EINA_LOG_ERR("Failed to add output to wayland\n"); free(_wl_output); return EINA_FALSE; } return EINA_TRUE; }
struct wl_drm * wayland_drm_init(struct wl_display *display, char *device_name, struct wayland_drm_callbacks *callbacks, void *user_data) { struct wl_drm *drm; drm = malloc(sizeof *drm); drm->display = display; drm->device_name = strdup(device_name); drm->callbacks = callbacks; drm->user_data = user_data; wl_display_add_global(display, &wl_drm_interface, drm, bind_drm); return drm; }
struct wl_drm * wayland_drm_init(struct wl_display *display, char *device_name, struct wayland_drm_callbacks *callbacks, void *user_data) { struct wl_drm *drm; drm = malloc(sizeof *drm); drm->display = display; drm->device_name = strdup(device_name); drm->callbacks = callbacks; drm->user_data = user_data; drm->object.interface = &wl_drm_interface; drm->object.implementation = (void (**)(void)) &drm_interface; wl_display_add_object(display, &drm->object); wl_display_add_global(display, &drm->object, post_drm_device); return drm; }
static void cogland_compositor_create_output (CoglandCompositor *compositor, int x, int y, int width, int height) { CoglandOutput *output = g_slice_new0 (CoglandOutput); CoglFramebuffer *fb; GError *error = NULL; output->wayland_output.interface = &wl_output_interface; wl_display_add_object (compositor->wayland_display, &output->wayland_output); wl_display_add_global (compositor->wayland_display, &output->wayland_output, cogland_output_post_geometry); output->onscreen = cogl_onscreen_new (compositor->cogl_context, width, height); /* Eventually there will be an implicit allocate on first use so this * will become optional... */ fb = COGL_FRAMEBUFFER (output->onscreen); if (!cogl_framebuffer_allocate (fb, &error)) g_error ("Failed to allocate framebuffer: %s\n", error->message); cogl_onscreen_show (output->onscreen); #if 0 cogl_framebuffer_set_viewport (fb, x, y, width, height); #else cogl_push_framebuffer (fb); cogl_set_viewport (-x, -y, compositor->virtual_width, compositor->virtual_height); cogl_pop_framebuffer (); #endif compositor->outputs = g_list_prepend (compositor->outputs, output); }
int main (int argc, char **argv) { CoglandCompositor compositor; GMainLoop *loop; CoglError *error = NULL; GError *gerror = NULL; CoglVertexP2C4 triangle_vertices[] = { {0, 0.7, 0xff, 0x00, 0x00, 0xff}, {-0.7, -0.7, 0x00, 0xff, 0x00, 0xff}, {0.7, -0.7, 0x00, 0x00, 0xff, 0xff} }; GSource *cogl_source; if (!process_arguments (&argc, &argv, &gerror)) { fprintf (stderr, "%s\n", gerror->message); return EXIT_FAILURE; } memset (&compositor, 0, sizeof (compositor)); compositor.wayland_display = wl_display_create (); if (compositor.wayland_display == NULL) g_error ("failed to create wayland display"); wl_list_init (&compositor.frame_callbacks); if (!wl_display_add_global (compositor.wayland_display, &wl_compositor_interface, &compositor, compositor_bind)) g_error ("Failed to register wayland compositor object"); wl_display_init_shm (compositor.wayland_display); loop = g_main_loop_new (NULL, FALSE); compositor.wayland_loop = wl_display_get_event_loop (compositor.wayland_display); compositor.wayland_event_source = wayland_event_source_new (compositor.wayland_display); g_source_attach (compositor.wayland_event_source, NULL); /* We want Cogl to use an EGL renderer because otherwise it won't * set up the wl_drm object and only SHM buffers will work. */ compositor.cogl_context = create_cogl_context (&compositor, TRUE /* use EGL constraint */, &error); if (compositor.cogl_context == NULL) { /* If we couldn't get an EGL context then try any type of * context */ cogl_error_free (error); error = NULL; compositor.cogl_context = create_cogl_context (&compositor, FALSE, /* don't set EGL constraint */ &error); if (compositor.cogl_context) g_warning ("Failed to create context with EGL constraint, " "falling back"); else g_error ("Failed to create a Cogl context: %s\n", error->message); } compositor.virtual_width = 800; compositor.virtual_height = 600; if (option_multiple_outputs) { int hw = compositor.virtual_width / 2; int hh = compositor.virtual_height / 2; /* Emulate compositing with multiple monitors... */ cogland_compositor_create_output (&compositor, 0, 0, hw, hh); cogland_compositor_create_output (&compositor, hw, 0, hw, hh); cogland_compositor_create_output (&compositor, 0, hh, hw, hh); cogland_compositor_create_output (&compositor, hw, hh, hw, hh); } else { cogland_compositor_create_output (&compositor, 0, 0, compositor.virtual_width, compositor.virtual_height); } if (wl_display_add_global (compositor.wayland_display, &wl_shell_interface, &compositor, bind_shell) == NULL) g_error ("Failed to register a global shell object"); if (wl_display_add_socket (compositor.wayland_display, "wayland-0")) g_error ("Failed to create socket"); compositor.triangle = cogl_primitive_new_p2c4 (compositor.cogl_context, COGL_VERTICES_MODE_TRIANGLES, 3, triangle_vertices); compositor.triangle_pipeline = cogl_pipeline_new (compositor.cogl_context); cogl_source = cogl_glib_source_new (compositor.cogl_context, G_PRIORITY_DEFAULT); g_source_attach (cogl_source, NULL); g_main_loop_run (loop); return 0; }
Compositor::Compositor(QWaylandCompositor *qt_compositor) : m_display(new Display) , m_default_input_device(0) , m_pageFlipper(0) , m_current_frame(0) , m_last_queued_buf(-1) , m_qt_compositor(qt_compositor) , m_orientation(Qt::PrimaryOrientation) , m_directRenderSurface(0) , m_directRenderContext(0) , m_directRenderActive(false) #if defined (QT_COMPOSITOR_WAYLAND_GL) , m_graphics_hw_integration(0) #endif , m_outputExtension(0) , m_surfaceExtension(0) , m_subSurfaceExtension(0) , m_touchExtension(0) , m_retainNotify(0) { compositor = this; #if defined (QT_COMPOSITOR_WAYLAND_GL) QWindow *window = qt_compositor->window(); if (window && window->surfaceType() != QWindow::RasterSurface) { QStringList keys = QWaylandGraphicsHardwareIntegrationFactory::keys(); QString targetKey; QByteArray hardwareIntegration = qgetenv("QT_WAYLAND_HARDWARE_INTEGRATION"); if (keys.contains(QString::fromLocal8Bit(hardwareIntegration.constData()))) { targetKey = QString::fromLocal8Bit(hardwareIntegration.constData()); } else if (keys.contains(QString::fromLatin1("wayland-egl"))) { targetKey = QString::fromLatin1("wayland-egl"); } else if (!keys.isEmpty()) { targetKey = keys.first(); } if (!targetKey.isEmpty()) { m_graphics_hw_integration = QWaylandGraphicsHardwareIntegrationFactory::create(targetKey, QStringList()); if (m_graphics_hw_integration) { m_graphics_hw_integration->setCompositor(qt_compositor); } } //BUG: if there is no hw_integration, bad things will probably happen } #endif m_windowManagerIntegration = new WindowManagerServerIntegration(qt_compositor, this); wl_display_add_global(m_display->handle(),&wl_compositor_interface,this,Compositor::bind_func); m_data_device_manager = new DataDeviceManager(this); wl_display_init_shm(m_display->handle()); m_output_global = new OutputGlobal(m_display->handle()); m_shell = new Shell(); wl_display_add_global(m_display->handle(), &wl_shell_interface, m_shell, Shell::bind_func); m_outputExtension = new OutputExtensionGlobal(this); m_surfaceExtension = new SurfaceExtensionGlobal(this); m_qtkeyExtension = new QtKeyExtensionGlobal(this); m_touchExtension = new TouchExtensionGlobal(this); if (wl_display_add_socket(m_display->handle(), qt_compositor->socketName())) { fprintf(stderr, "Fatal: Failed to open server socket\n"); exit(EXIT_FAILURE); } m_loop = wl_display_get_event_loop(m_display->handle()); int fd = wl_event_loop_get_fd(m_loop); QSocketNotifier *sockNot = new QSocketNotifier(fd, QSocketNotifier::Read, this); connect(sockNot, SIGNAL(activated(int)), this, SLOT(processWaylandEvents())); QAbstractEventDispatcher *dispatcher = QGuiApplicationPrivate::eventDispatcher; connect(dispatcher, SIGNAL(aboutToBlock()), this, SLOT(processWaylandEvents())); qRegisterMetaType<SurfaceBuffer*>("SurfaceBuffer*"); //initialize distancefieldglyphcache here }
WL_EXPORT int weston_xserver_init(struct weston_compositor *compositor) { struct wl_display *display = compositor->wl_display; struct weston_xserver *mxs; char lockfile[256], display_name[8]; mxs = malloc(sizeof *mxs); memset(mxs, 0, sizeof *mxs); mxs->process.cleanup = weston_xserver_cleanup; mxs->wl_display = display; mxs->compositor = compositor; mxs->display = 0; retry: if (create_lockfile(mxs->display, lockfile, sizeof lockfile) < 0) { if (errno == EAGAIN) { goto retry; } else if (errno == EEXIST) { mxs->display++; goto retry; } else { free(mxs); return -1; } } mxs->abstract_fd = bind_to_abstract_socket(mxs->display); if (mxs->abstract_fd < 0 && errno == EADDRINUSE) { mxs->display++; unlink(lockfile); goto retry; } mxs->unix_fd = bind_to_unix_socket(mxs->display); if (mxs->unix_fd < 0) { unlink(lockfile); close(mxs->abstract_fd); free(mxs); return -1; } snprintf(display_name, sizeof display_name, ":%d", mxs->display); weston_log("xserver listening on display %s\n", display_name); setenv("DISPLAY", display_name, 1); mxs->loop = wl_display_get_event_loop(display); mxs->abstract_source = wl_event_loop_add_fd(mxs->loop, mxs->abstract_fd, WL_EVENT_READABLE, weston_xserver_handle_event, mxs); mxs->unix_source = wl_event_loop_add_fd(mxs->loop, mxs->unix_fd, WL_EVENT_READABLE, weston_xserver_handle_event, mxs); wl_display_add_global(display, &xserver_interface, mxs, bind_xserver); mxs->destroy_listener.notify = weston_xserver_destroy; wl_signal_add(&compositor->destroy_signal, &mxs->destroy_listener); return 0; }
int main (int argc, char **argv) { CoglandCompositor compositor; GMainLoop *loop; CoglError *error = NULL; CoglVertexP2C4 triangle_vertices[] = { {0, 0.7, 0xff, 0x00, 0x00, 0x80}, {-0.7, -0.7, 0x00, 0xff, 0x00, 0xff}, {0.7, -0.7, 0x00, 0x00, 0xff, 0xff} }; GSource *cogl_source; memset (&compositor, 0, sizeof (compositor)); compositor.wayland_display = wl_display_create (); if (compositor.wayland_display == NULL) g_error ("failed to create wayland display"); g_queue_init (&compositor.frame_callbacks); if (!wl_display_add_global (compositor.wayland_display, &wl_compositor_interface, &compositor, compositor_bind)) g_error ("Failed to register wayland compositor object"); compositor.wayland_shm = wl_shm_init (compositor.wayland_display, &shm_callbacks); if (!compositor.wayland_shm) g_error ("Failed to allocate setup wayland shm callbacks"); loop = g_main_loop_new (NULL, FALSE); compositor.wayland_loop = wl_display_get_event_loop (compositor.wayland_display); compositor.wayland_event_source = wayland_event_source_new (compositor.wayland_loop); g_source_attach (compositor.wayland_event_source, NULL); compositor.cogl_display = cogl_display_new (NULL, NULL); cogl_wayland_display_set_compositor_display (compositor.cogl_display, compositor.wayland_display); compositor.cogl_context = cogl_context_new (compositor.cogl_display, &error); if (!compositor.cogl_context) g_error ("Failed to create a Cogl context: %s\n", error->message); compositor.virtual_width = 640; compositor.virtual_height = 480; /* Emulate compositing with multiple monitors... */ cogland_compositor_create_output (&compositor, 0, 0, 320, 240); cogland_compositor_create_output (&compositor, 320, 0, 320, 240); cogland_compositor_create_output (&compositor, 0, 240, 320, 240); cogland_compositor_create_output (&compositor, 320, 240, 320, 240); if (wl_display_add_global (compositor.wayland_display, &wl_shell_interface, &compositor, bind_shell) == NULL) g_error ("Failed to register a global shell object"); if (wl_display_add_socket (compositor.wayland_display, "wayland-0")) g_error ("Failed to create socket"); compositor.triangle = cogl_primitive_new_p2c4 (compositor.cogl_context, COGL_VERTICES_MODE_TRIANGLES, 3, triangle_vertices); compositor.triangle_pipeline = cogl_pipeline_new (compositor.cogl_context); g_timeout_add (16, paint_cb, &compositor); cogl_source = cogl_glib_source_new (compositor.cogl_context, G_PRIORITY_DEFAULT); g_source_attach (cogl_source, NULL); g_main_loop_run (loop); return 0; }