WaylandDisplay::WaylandDisplay()
{
m_display = wl_display_connect(nullptr);
m_registry = wl_display_get_registry(m_display);
wl_registry_add_listener(m_registry, &g_registryListener, &m_interfaces);
wl_display_roundtrip(m_display);
m_eventSource = g_source_new(&EventSource::sourceFuncs, sizeof(EventSource));
auto* source = reinterpret_cast<EventSource*>(m_eventSource);
source->display = m_display;
source->pfd.fd = wl_display_get_fd(m_display);
source->pfd.events = G_IO_IN | G_IO_ERR | G_IO_HUP;
source->pfd.revents = 0;
g_source_add_poll(m_eventSource, &source->pfd);
g_source_set_name(m_eventSource, "[WPE] WaylandDisplay");
g_source_set_priority(m_eventSource, G_PRIORITY_HIGH + 30);
g_source_set_can_recurse(m_eventSource, TRUE);
g_source_attach(m_eventSource, g_main_context_get_thread_default());
if (m_interfaces.xdg) {
xdg_shell_add_listener(m_interfaces.xdg, &g_xdgShellListener, nullptr);
xdg_shell_use_unstable_version(m_interfaces.xdg, 5);
}
}
TestBase::TestBase()
: wlDisplay(NULL)
, wlRegistry(NULL)
{
wlDisplay = wl_display_connect(NULL);
if (!wlDisplay)
{
throw std::runtime_error("could not connect to wayland display");
}
wlRegistry = wl_display_get_registry(wlDisplay);
static const struct wl_registry_listener registry_listener = {
registry_listener_callback,
NULL
};
wl_registry_add_listener(wlRegistry, ®istry_listener, &wlCompositor);
if (wl_display_roundtrip(wlDisplay) == -1 || wl_display_roundtrip(wlDisplay) == -1)
{
throw std::runtime_error("wl_display error");
}
wlSurfaces.reserve(10);
for (int i = 0; i < wlSurfaces.capacity(); ++i)
{
wlSurfaces.push_back(wl_compositor_create_surface(wlCompositor));
}
}
bool cWaylandInterface::Initialize(void *config)
{
if (!GLWin.wl_display) {
printf("Error: couldn't open wayland display\n");
return false;
}
GLWin.pointer.wl_pointer = nullptr;
GLWin.keyboard.wl_keyboard = nullptr;
GLWin.keyboard.xkb.context = xkb_context_new((xkb_context_flags) 0);
if (GLWin.keyboard.xkb.context == nullptr) {
fprintf(stderr, "Failed to create XKB context\n");
return nullptr;
}
GLWin.wl_registry = wl_display_get_registry(GLWin.wl_display);
wl_registry_add_listener(GLWin.wl_registry,
®istry_listener, nullptr);
while (!GLWin.wl_compositor)
wl_display_dispatch(GLWin.wl_display);
GLWin.wl_cursor_surface =
wl_compositor_create_surface(GLWin.wl_compositor);
return true;
}
static struct display *
create_display(void)
{
struct display *display;
display = malloc(sizeof *display);
if (display == NULL) {
fprintf(stderr, "out of memory\n");
exit(1);
}
display->display = wl_display_connect(NULL);
assert(display->display);
/* XXX: fake, because the compositor does not yet advertise anything */
display->xrgb8888_format_found = 1;
display->registry = wl_display_get_registry(display->display);
wl_registry_add_listener(display->registry,
®istry_listener, display);
wl_display_roundtrip(display->display);
if (display->dmabuf == NULL) {
fprintf(stderr, "No zwp_linux_dmabuf global\n");
exit(1);
}
wl_display_roundtrip(display->display);
if (!display->xrgb8888_format_found) {
fprintf(stderr, "DRM_FORMAT_XRGB8888 not available\n");
exit(1);
}
return display;
}
xdl_int initWayland() {
//
// Connect to the Wayland server.
//
display = wl_display_connect(nullptr);
if(display == nullptr) {
std::cerr << "## XdevLWindowWayland::wl_display_connect failed" << std::endl;
return xdl::ERR_ERROR;
}
// We get the registry for the window which holds extension
// of the wayland server.
m_registry = wl_display_get_registry(display);
if(m_registry == nullptr) {
std::cerr << "## XdevLWindowWayland::wl_display_get_registry failed" << std::endl;
return ERR_ERROR;
}
// Now we tell the registry that we want to listen to events.
wl_registry_add_listener(m_registry, ®istry_listener, nullptr);
wl_display_dispatch(display);
return ERR_OK;
}
void fgPlatformInitialize( const char* displayName )
{
fgDisplay.pDisplay.display = wl_display_connect( NULL );
if( fgDisplay.pDisplay.display == NULL )
fgError( "failed to connect to a Wayland compositor" );
fgDisplay.pDisplay.registry = wl_display_get_registry(
fgDisplay.pDisplay.display );
wl_registry_add_listener( fgDisplay.pDisplay.registry,
&fghRegistryListener,
&fgDisplay.pDisplay );
wl_display_roundtrip( fgDisplay.pDisplay.display );
if( fgDisplay.pDisplay.compositor == NULL ||
fgDisplay.pDisplay.shell == NULL ||
fgDisplay.pDisplay.seat == NULL ||
fgDisplay.pDisplay.shm == NULL )
fgError( "failed to discover all needed compositor interfaces" );
fghInitialiseCursorTheme();
fghPlatformInitializeEGL();
/* Get start time */
fgState.Time = fgSystemTime();
fgState.Initialised = GL_TRUE;
atexit(fgDeinitialize);
/* InputDevice uses GlutTimerFunc(), so fgState.Initialised must be TRUE */
fgPlatformInitialiseInputDevices();
}
WaylandEventQueue::WaylandEventQueue(IOLoop &_io_loop, EventQueue &_queue)
:io_loop(_io_loop), queue(_queue),
display(wl_display_connect(nullptr))
{
if (display == nullptr) {
fprintf(stderr, "wl_display_connect() failed\n");
exit(EXIT_FAILURE);
}
auto registry = wl_display_get_registry(display);
wl_registry_add_listener(registry, ®istry_listener, this);
wl_display_dispatch(display);
wl_display_roundtrip(display);
if (compositor == nullptr) {
fprintf(stderr, "No Wayland compositor found\n");
exit(EXIT_FAILURE);
}
if (seat == nullptr) {
fprintf(stderr, "No Wayland seat found\n");
exit(EXIT_FAILURE);
}
if (shell == nullptr) {
fprintf(stderr, "No Wayland shell found\n");
exit(EXIT_FAILURE);
}
io_loop.Add(FileDescriptor(wl_display_get_fd(display)), io_loop.READ, *this);
}
BOOL wl_pre_connect(freerdp* instance)
{
struct display* display;
struct wl_context* context;
freerdp_channels_pre_connect(instance->context->channels, instance);
display = malloc(sizeof(*display));
display->display = wl_display_connect(NULL);
if (!display->display)
{
fprintf(stderr, "wl_pre_connect: failed to connect to Wayland compositor\n");
fprintf(stderr, "Please check that the XDG_RUNTIME_DIR environment variable is properly set.\n");
free(display);
return FALSE;
}
display->registry = wl_display_get_registry(display->display);
wl_registry_add_listener(display->registry, &wl_registry_listener, display);
wl_display_roundtrip(display->display);
if (!display->compositor || !display->shell || !display->shm)
{
fprintf(stderr, "wl_pre_connect: failed to find needed compositor interfaces\n");
free(display);
return FALSE;
}
/* put Wayland data in the context here */
context = (struct wl_context*) instance->context;
context->display = display;
return TRUE;
}
int main(int argc, char **argv)
{
Helper helper;
helper.display = wl_display_connect(nullptr);
helper.registry = wl_display_get_registry(helper.display);
static const wl_registry_listener registryListener = {
wrapInterface(&Helper::global),
wrapInterface(&Helper::globalRemove)
};
wl_registry_add_listener(helper.registry, ®istryListener, &helper);
wl_display_roundtrip(helper.display);
if (!helper.helper) {
qWarning("No orbital_authorizer_helper interface.");
exit(1);
}
int ret = 0;
while (ret != -1)
ret = wl_display_dispatch(helper.display);
return 0;
}
WaylandDisplay::WaylandDisplay()
{
m_display = wl_display_connect(nullptr);
m_registry = wl_display_get_registry(m_display);
wl_registry_add_listener(m_registry, &g_registryListener, &m_interfaces);
wl_display_roundtrip(m_display);
m_eventSource = g_source_new(&EventSource::sourceFuncs, sizeof(EventSource));
auto* source = reinterpret_cast<EventSource*>(m_eventSource);
source->display = m_display;
source->pfd.fd = wl_display_get_fd(m_display);
source->pfd.events = G_IO_IN | G_IO_ERR | G_IO_HUP;
source->pfd.revents = 0;
g_source_add_poll(m_eventSource, &source->pfd);
g_source_set_name(m_eventSource, "[WPE] WaylandDisplay");
g_source_set_priority(m_eventSource, G_PRIORITY_HIGH + 30);
g_source_set_can_recurse(m_eventSource, TRUE);
g_source_attach(m_eventSource, g_main_context_get_thread_default());
if (m_interfaces.xdg) {
xdg_shell_add_listener(m_interfaces.xdg, &g_xdgShellListener, nullptr);
xdg_shell_use_unstable_version(m_interfaces.xdg, 5);
}
wl_seat_add_listener(m_interfaces.seat, &g_seatListener, &m_seatData);
m_seatData.xkb.context = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
m_seatData.xkb.composeTable = xkb_compose_table_new_from_locale(m_seatData.xkb.context, setlocale(LC_CTYPE, nullptr), XKB_COMPOSE_COMPILE_NO_FLAGS);
if (m_seatData.xkb.composeTable)
m_seatData.xkb.composeState = xkb_compose_state_new(m_seatData.xkb.composeTable, XKB_COMPOSE_STATE_NO_FLAGS);
}
static int createWLContext()
{
t_ilm_bool result = ILM_TRUE;
g_wlContextStruct.wlDisplay = wl_display_connect(NULL);
if (NULL == g_wlContextStruct.wlDisplay)
{
printf("Error: wl_display_connect() failed.\n");
}
g_wlContextStruct.wlRegistry = wl_display_get_registry(g_wlContextStruct.wlDisplay);
wl_registry_add_listener(g_wlContextStruct.wlRegistry, ®istry_listener, &g_wlContextStruct);
wl_display_dispatch(g_wlContextStruct.wlDisplay);
wl_display_roundtrip(g_wlContextStruct.wlDisplay);
g_wlContextStruct.wlSurface = wl_compositor_create_surface(g_wlContextStruct.wlCompositor);
if (NULL == g_wlContextStruct.wlSurface)
{
printf("Error: wl_compositor_create_surface failed.\n");
destroyWLContext();
}
createShmBuffer();
return result;
}
void DrmEglServerBufferIntegration::initialize(QWaylandDisplay *display)
{
m_egl_display = eglGetDisplay((EGLNativeDisplayType) display->wl_display());
if (EGL_NO_DISPLAY) {
qWarning("Failed to initialize drm egl server buffer integration. Could not get egl display from wl_display.");
return;
}
const char *extensionString = eglQueryString(m_egl_display, EGL_EXTENSIONS);
if (!extensionString || !strstr(extensionString, "EGL_KHR_image")) {
qWarning("Failed to initialize drm egl server buffer integration. There is no EGL_KHR_image extension.\n");
return;
}
m_egl_create_image = reinterpret_cast<PFNEGLCREATEIMAGEKHRPROC>(eglGetProcAddress("eglCreateImageKHR"));
m_egl_destroy_image = reinterpret_cast<PFNEGLDESTROYIMAGEKHRPROC>(eglGetProcAddress("eglDestroyImageKHR"));
if (!m_egl_create_image || !m_egl_destroy_image) {
qWarning("Failed to initialize drm egl server buffer integration. Could not resolve eglCreateImageKHR or eglDestroyImageKHR");
return;
}
m_gl_egl_image_target_texture = reinterpret_cast<PFNGLEGLIMAGETARGETTEXTURE2DOESPROC>(eglGetProcAddress("glEGLImageTargetTexture2DOES"));
if (!m_gl_egl_image_target_texture) {
qWarning("Failed to initialize drm egl server buffer integration. Could not resolve glEGLImageTargetTexture2DOES");
return;
}
QtWayland::wl_registry::init(wl_display_get_registry(display->wl_display()));
}
Client::Client(wl_display* dpy)
: wfits_input_(NULL)
, wfits_query_(NULL)
, wfits_manip_(NULL)
, yieldFactor_(1.f)
{
ASSERT(NULL != dpy);
wl_registry *reg = wl_display_get_registry(dpy);
static const struct wl_registry_listener listener = {bind_wfits};
wl_registry_add_listener(reg, &listener, this);
wl_display_roundtrip(dpy);
ASSERT(NULL != wfits_input_);
ASSERT(NULL != wfits_query_);
ASSERT(NULL != wfits_manip_);
const char* emu(getenv("WFITS_YIELD_FACTOR"));
if (emu != NULL)
{
yieldFactor_ = boost::lexical_cast<float>(emu);
}
}
WaylandNativeWindow::WaylandNativeWindow(struct wl_egl_window *window, struct wl_display *display, const gralloc_module_t* gralloc, alloc_device_t* alloc_device)
{
int i;
this->m_window = window;
this->m_display = display;
this->m_width = window->width;
this->m_height = window->height;
this->m_defaultWidth = window->width;
this->m_defaultHeight = window->height;
this->m_format = 1;
this->wl_queue = wl_display_create_queue(display);
this->frame_callback = NULL;
this->registry = wl_display_get_registry(display);
wl_proxy_set_queue((struct wl_proxy *) this->registry,
this->wl_queue);
wl_registry_add_listener(this->registry, ®istry_listener, this);
assert(wayland_roundtrip(this) >= 0);
assert(this->m_android_wlegl != NULL);
this->m_gralloc = gralloc;
this->m_alloc = alloc_device;
m_usage=GRALLOC_USAGE_HW_RENDER | GRALLOC_USAGE_HW_TEXTURE;
pthread_mutex_init(&mutex, NULL);
TRACE("WaylandNativeWindow created in %p", pthread_self());
}
PlatformDisplayWayland::PlatformDisplayWayland(struct wl_display* wlDisplay)
: m_display(wlDisplay)
, m_registry(wl_display_get_registry(m_display))
, m_eglConfigChosen(false)
{
wl_registry_add_listener(m_registry, &m_registryListener, this);
wl_display_roundtrip(m_display);
static const EGLint configAttributes[] = {
EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
EGL_RED_SIZE, 1,
EGL_GREEN_SIZE, 1,
EGL_BLUE_SIZE, 1,
EGL_ALPHA_SIZE, 1,
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
EGL_NONE
};
m_eglDisplay = eglGetDisplay(m_display);
PlatformDisplay::initializeEGLDisplay();
if (m_eglDisplay == EGL_NO_DISPLAY)
return;
EGLint numberOfConfigs;
if (!eglChooseConfig(m_eglDisplay, configAttributes, &m_eglConfig, 1, &numberOfConfigs) || numberOfConfigs != 1) {
g_warning("PlatformDisplayWayland initialization: failed to find the desired EGL configuration.");
return;
}
m_eglConfigChosen = true;
}
wlfDisplay* wlf_CreateDisplay(void)
{
wlfDisplay* display;
display = (wlfDisplay*) calloc(1, sizeof(wlfDisplay));
if (display)
{
display->display = wl_display_connect(NULL);
if (!display->display)
{
WLog_ERR(TAG, "wl_pre_connect: failed to connect to Wayland compositor");
WLog_ERR(TAG, "Please check that the XDG_RUNTIME_DIR environment variable is properly set.");
free(display);
return NULL;
}
display->registry = wl_display_get_registry(display->display);
wl_registry_add_listener(display->registry, &wl_registry_listener, display);
wl_display_roundtrip(display->display);
if (!display->compositor || !display->shell || !display->shm)
{
WLog_ERR(TAG, "wl_pre_connect: failed to find needed compositor interfaces");
free(display);
return NULL;
}
}
return display;
}
static struct cursor_viewer *
cursor_viewer_create(void)
{
struct cursor_viewer *viewer = calloc(1, sizeof (struct cursor_viewer));
if (!viewer)
die("Cannot allocate memory for cursor_viewer\n");
viewer->display = wl_display_connect(NULL);
if (!viewer->display) {
cursor_viewer_destroy(viewer);
die("Cannot connect to Wayland display\n");
}
viewer->registry = wl_display_get_registry(viewer->display);
if (!viewer->registry) {
cursor_viewer_destroy(viewer);
die("Cannot get registry from Wayland display\n");
}
wl_registry_add_listener(viewer->registry, ®istry_listener, viewer);
wl_display_roundtrip(viewer->display);
wl_display_roundtrip(viewer->display);
return viewer;
}
static struct display *
create_display(int version)
{
struct display *display;
display = malloc(sizeof *display);
if (display == NULL) {
fprintf(stderr, "out of memory\n");
exit(1);
}
display->display = wl_display_connect(NULL);
assert(display->display);
display->compositor_version = version;
display->formats = 0;
display->registry = wl_display_get_registry(display->display);
wl_registry_add_listener(display->registry,
®istry_listener, display);
wl_display_roundtrip(display->display);
if (display->shm == NULL) {
fprintf(stderr, "No wl_shm global\n");
exit(1);
}
wl_display_roundtrip(display->display);
if (!(display->formats & (1 << WL_SHM_FORMAT_XRGB8888))) {
fprintf(stderr, "WL_SHM_FORMAT_XRGB32 not available\n");
exit(1);
}
return display;
}
static struct display *
create_display (void)
{
struct display *display;
display = malloc (sizeof *display);
display->display = wl_display_connect (NULL);
if (display->display == NULL) {
free (display);
return NULL;
}
display->registry = wl_display_get_registry (display->display);
wl_registry_add_listener (display->registry, ®istry_listener, display);
wl_display_roundtrip (display->display);
if (display->shm == NULL) {
GST_ERROR ("No wl_shm global..");
return NULL;
}
wl_display_roundtrip (display->display);
if (!(display->formats & (1 << WL_SHM_FORMAT_XRGB8888))) {
GST_ERROR ("WL_SHM_FORMAT_XRGB32 not available");
return NULL;
}
wl_display_get_fd (display->display);
return display;
}
WaylandNativeWindow::WaylandNativeWindow(struct wl_egl_window *window, struct wl_display *display, const gralloc_module_t* gralloc, alloc_device_t* alloc_device)
{
int wayland_ok;
HYBRIS_TRACE_BEGIN("wayland-platform", "create_window", "");
this->m_window = window;
this->m_window->nativewindow = (void *) this;
this->m_display = display;
this->m_width = window->width;
this->m_height = window->height;
this->m_defaultWidth = window->width;
this->m_defaultHeight = window->height;
this->m_window->resize_callback = resize_callback;
this->m_format = 1;
this->wl_queue = wl_display_create_queue(display);
this->frame_callback = NULL;
this->registry = wl_display_get_registry(display);
wl_proxy_set_queue((struct wl_proxy *) this->registry,
this->wl_queue);
wl_registry_add_listener(this->registry, ®istry_listener, this);
wayland_ok = wayland_roundtrip(this);
assert(wayland_ok >= 0);
assert(this->m_android_wlegl != NULL);
this->m_gralloc = gralloc;
this->m_alloc = alloc_device;
m_usage=GRALLOC_USAGE_HW_RENDER | GRALLOC_USAGE_HW_TEXTURE;
pthread_mutex_init(&mutex, NULL);
pthread_cond_init(&cond, NULL);
m_freeBufs = 0;
setBufferCount(3);
HYBRIS_TRACE_END("wayland-platform", "create_window", "");
}
bool WaylandEGLContext::attach (GtkWidget *widget)
{
GdkWindow *window = gtk_widget_get_window (widget);
if (!GDK_IS_WAYLAND_WINDOW (window))
return false;
gdk_window = window;
gdk_window_get_geometry (gdk_window, &x, &y, &width, &height);
display = gdk_wayland_display_get_wl_display (gdk_window_get_display (gdk_window));
parent = gdk_wayland_window_get_wl_surface (gdk_window);
registry = wl_display_get_registry (display);
wl_registry_add_listener (registry, &wl_registry_listener, this);
wl_display_roundtrip (display);
if (!compositor || !subcompositor)
return false;
child = wl_compositor_create_surface (compositor);
region = wl_compositor_create_region (compositor);
subsurface = wl_subcompositor_get_subsurface (subcompositor, child, parent);
wl_surface_set_input_region (child, region);
wl_subsurface_set_desync (subsurface);
wl_subsurface_set_position (subsurface, x, y);
return true;
}
GdkDisplay *
_gdk_wayland_display_open (const gchar *display_name)
{
struct wl_display *wl_display;
GdkDisplay *display;
GdkWaylandDisplay *display_wayland;
GDK_NOTE (MISC, g_message ("opening display %s", display_name ? display_name : ""));
/* If this variable is unset then wayland initialisation will surely
* fail, logging a fatal error in the process. Save ourselves from
* that.
*/
if (g_getenv ("XDG_RUNTIME_DIR") == NULL)
return NULL;
wl_log_set_handler_client (log_handler);
wl_display = wl_display_connect (display_name);
if (!wl_display)
return NULL;
display = g_object_new (GDK_TYPE_WAYLAND_DISPLAY, NULL);
display->device_manager = _gdk_wayland_device_manager_new (display);
display_wayland = GDK_WAYLAND_DISPLAY (display);
display_wayland->wl_display = wl_display;
display_wayland->screen = _gdk_wayland_screen_new (display);
display_wayland->event_source = _gdk_wayland_display_event_source_new (display);
display_wayland->known_globals =
g_hash_table_new_full (NULL, NULL, NULL, g_free);
_gdk_wayland_display_init_cursors (display_wayland);
_gdk_wayland_display_prepare_cursor_themes (display_wayland);
display_wayland->wl_registry = wl_display_get_registry (display_wayland->wl_display);
wl_registry_add_listener (display_wayland->wl_registry, ®istry_listener, display_wayland);
_gdk_wayland_display_async_roundtrip (display_wayland);
/* Wait for initializing to complete. This means waiting for all
* asynchrounous roundtrips that were triggered during initial roundtrip. */
while (g_list_length (display_wayland->async_roundtrips) > 0)
{
if (wl_display_dispatch (display_wayland->wl_display) < 0)
{
g_object_unref (display);
return NULL;
}
}
gdk_input_init (display);
display_wayland->selection = gdk_wayland_selection_new ();
g_signal_emit_by_name (display, "opened");
return display;
}
int _glfwPlatformInit(void)
{
_glfw.wl.display = wl_display_connect(NULL);
if (!_glfw.wl.display)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"Wayland: Failed to connect to display");
return GLFW_FALSE;
}
_glfw.wl.registry = wl_display_get_registry(_glfw.wl.display);
wl_registry_add_listener(_glfw.wl.registry, ®istryListener, NULL);
_glfw.wl.monitors = calloc(4, sizeof(_GLFWmonitor*));
_glfw.wl.monitorsSize = 4;
_glfw.wl.xkb.context = xkb_context_new(0);
if (!_glfw.wl.xkb.context)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"Wayland: Failed to initialize xkb context");
return GLFW_FALSE;
}
// Sync so we got all registry objects
wl_display_roundtrip(_glfw.wl.display);
// Sync so we got all initial output events
wl_display_roundtrip(_glfw.wl.display);
if (!_glfwInitContextAPI())
return GLFW_FALSE;
_glfwInitTimer();
_glfwInitJoysticks();
if (_glfw.wl.pointer && _glfw.wl.shm)
{
_glfw.wl.cursorTheme = wl_cursor_theme_load(NULL, 32, _glfw.wl.shm);
if (!_glfw.wl.cursorTheme)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"Wayland: Unable to load default cursor theme\n");
return GLFW_FALSE;
}
_glfw.wl.defaultCursor =
wl_cursor_theme_get_cursor(_glfw.wl.cursorTheme, "left_ptr");
if (!_glfw.wl.defaultCursor)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"Wayland: Unable to load default left pointer\n");
return GLFW_FALSE;
}
_glfw.wl.cursorSurface =
wl_compositor_create_surface(_glfw.wl.compositor);
}
return GLFW_TRUE;
}
GstWlDisplay *
gst_wl_display_new_existing (struct wl_display * display,
gboolean take_ownership, GError ** error)
{
GstWlDisplay *self;
GError *err = NULL;
gint i;
g_return_val_if_fail (display != NULL, NULL);
self = g_object_new (GST_TYPE_WL_DISPLAY, NULL);
self->display = display;
self->own_display = take_ownership;
self->queue = wl_display_create_queue (self->display);
self->registry = wl_display_get_registry (self->display);
wl_proxy_set_queue ((struct wl_proxy *) self->registry, self->queue);
wl_registry_add_listener (self->registry, ®istry_listener, self);
/* we need exactly 2 roundtrips to discover global objects and their state */
for (i = 0; i < 2; i++) {
if (gst_wl_display_roundtrip (self) < 0) {
*error = g_error_new (g_quark_from_static_string ("GstWlDisplay"), 0,
"Error communicating with the wayland display");
g_object_unref (self);
return NULL;
}
}
/* verify we got all the required interfaces */
#define VERIFY_INTERFACE_EXISTS(var, interface) \
if (!self->var) { \
g_set_error (error, g_quark_from_static_string ("GstWlDisplay"), 0, \
"Could not bind to " interface ". Either it is not implemented in " \
"the compositor, or the implemented version doesn't match"); \
g_object_unref (self); \
return NULL; \
}
VERIFY_INTERFACE_EXISTS (compositor, "wl_compositor");
VERIFY_INTERFACE_EXISTS (subcompositor, "wl_subcompositor");
VERIFY_INTERFACE_EXISTS (shell, "wl_shell");
VERIFY_INTERFACE_EXISTS (shm, "wl_shm");
VERIFY_INTERFACE_EXISTS (scaler, "wl_scaler");
#undef VERIFY_INTERFACE_EXISTS
self->thread = g_thread_try_new ("GstWlDisplay", gst_wl_display_thread_run,
self, &err);
if (err) {
g_propagate_prefixed_error (error, err,
"Failed to start thread for the display's events");
g_object_unref (self);
return NULL;
}
return self;
}
bool
va_wayland_drm_create(VADisplayContextP pDisplayContext)
{
VADriverContextP const ctx = pDisplayContext->pDriverContext;
struct va_wayland_drm_context *wl_drm_ctx;
struct drm_state *drm_state;
wl_drm_ctx = malloc(sizeof(*wl_drm_ctx));
if (!wl_drm_ctx)
return false;
wl_drm_ctx->base.destroy = va_wayland_drm_destroy;
wl_drm_ctx->handle = NULL;
wl_drm_ctx->drm = NULL;
wl_drm_ctx->drm_interface = NULL;
wl_drm_ctx->is_authenticated = 0;
pDisplayContext->opaque = wl_drm_ctx;
pDisplayContext->vaGetDriverName = va_DisplayContextGetDriverName;
drm_state = calloc(1, sizeof(struct drm_state));
if (!drm_state)
return false;
drm_state->fd = -1;
drm_state->auth_type = 0;
ctx->drm_state = drm_state;
wl_drm_ctx->handle = dlopen(LIBWAYLAND_DRM_NAME, RTLD_LAZY|RTLD_LOCAL);
if (!wl_drm_ctx->handle)
return false;
wl_drm_ctx->drm_interface =
dlsym(wl_drm_ctx->handle, "wl_drm_interface");
if (!wl_drm_ctx->drm_interface)
return false;
wl_drm_ctx->registry = wl_display_get_registry(ctx->native_dpy);
wl_registry_add_listener(wl_drm_ctx->registry, ®istry_listener, wl_drm_ctx);
wl_display_roundtrip(ctx->native_dpy);
/* registry_handle_global should have been called by the
* wl_display_roundtrip above
*/
if (!wl_drm_ctx->drm)
return false;
wl_drm_add_listener(wl_drm_ctx->drm, &drm_listener, pDisplayContext);
wl_display_roundtrip(ctx->native_dpy);
if (drm_state->fd < 0)
return false;
wl_display_roundtrip(ctx->native_dpy);
if (!wl_drm_ctx->is_authenticated)
return false;
return true;
}
int main(int argc, char **argv) {
display = wl_display_connect(NULL);
if (display == NULL) {
fprintf(stderr, "Can't connect to display\n");
exit(1);
}
printf("connected to display\n");
struct wl_registry *registry = wl_display_get_registry(display);
wl_registry_add_listener(registry, ®istry_listener, NULL);
wl_display_dispatch(display);
wl_display_roundtrip(display);
if (compositor == NULL) {
fprintf(stderr, "Can't find compositor\n");
exit(1);
} else {
fprintf(stderr, "Found compositor\n");
}
surface = wl_compositor_create_surface(compositor);
if (surface == NULL) {
fprintf(stderr, "Can't create surface\n");
exit(1);
} else {
fprintf(stderr, "Created surface\n");
}
shell_surface = wl_shell_get_shell_surface(shell, surface);
if (shell_surface == NULL) {
fprintf(stderr, "Can't create shell surface\n");
exit(1);
} else {
fprintf(stderr, "Created shell surface\n");
}
wl_shell_surface_set_toplevel(shell_surface);
wl_shell_surface_add_listener(shell_surface,
&shell_surface_listener, NULL);
create_window();
paint_pixels();
while (wl_display_dispatch(display) != -1) {
;
}
wl_display_disconnect(display);
printf("disconnected from display\n");
exit(0);
}
struct client *
client_create(int x, int y, int width, int height)
{
struct client *client;
struct surface *surface;
wl_log_set_handler_client(log_handler);
/* connect to display */
client = xzalloc(sizeof *client);
client->wl_display = wl_display_connect(NULL);
assert(client->wl_display);
wl_list_init(&client->global_list);
/* setup registry so we can bind to interfaces */
client->wl_registry = wl_display_get_registry(client->wl_display);
wl_registry_add_listener(client->wl_registry, ®istry_listener, client);
/* trigger global listener */
wl_display_dispatch(client->wl_display);
wl_display_roundtrip(client->wl_display);
/* must have WL_SHM_FORMAT_ARGB32 */
assert(client->has_argb);
/* must have wl_test interface */
assert(client->test);
/* must have an output */
assert(client->output);
/* initialize the client surface */
surface = xzalloc(sizeof *surface);
surface->wl_surface =
wl_compositor_create_surface(client->wl_compositor);
assert(surface->wl_surface);
wl_surface_add_listener(surface->wl_surface, &surface_listener,
surface);
client->surface = surface;
wl_surface_set_user_data(surface->wl_surface, surface);
surface->width = width;
surface->height = height;
surface->wl_buffer = create_shm_buffer(client, width, height,
&surface->data);
memset(surface->data, 64, width * height * 4);
move_client(client, x, y);
return client;
}
static gboolean
clutter_backend_wayland_post_parse (ClutterBackend *backend,
GError **error)
{
ClutterBackendWayland *backend_wayland = CLUTTER_BACKEND_WAYLAND (backend);
/* TODO: expose environment variable/commandline option for this... */
backend_wayland->wayland_display = wl_display_connect (NULL);
if (!backend_wayland->wayland_display)
{
g_set_error (error, CLUTTER_INIT_ERROR,
CLUTTER_INIT_ERROR_BACKEND,
"Failed to open Wayland display socket");
return FALSE;
}
backend_wayland->wayland_registry =
wl_display_get_registry (backend_wayland->wayland_display);
backend_wayland->wayland_source =
_clutter_event_source_wayland_new (backend_wayland->wayland_display);
g_source_attach (backend_wayland->wayland_source, NULL);
g_object_set (clutter_settings_get_default (), "font-dpi", 96 * 1024, NULL);
/* XXX: We require the device manager to exist as soon as we connect to the
* compositor and setup an event handler because we will immediately be
* notified of the available input devices which need to be associated with
* the device-manager.
*
* FIXME: At some point we could perhaps just collapse the
* _clutter_backend_post_parse(), and _clutter_backend_init_events()
* functions into one called something like _clutter_backend_init() which
* would allow the real backend to manage the precise order of
* initialization.
*/
backend_wayland->device_manager =
_clutter_device_manager_wayland_new (backend);
/* Set up listener so we'll catch all events. */
wl_registry_add_listener (backend_wayland->wayland_registry,
&wayland_registry_listener,
backend_wayland);
/* Wait until we have been notified about the compositor and shell objects */
while (!(backend_wayland->wayland_compositor &&
backend_wayland->wayland_shell))
wl_display_roundtrip (backend_wayland->wayland_display);
/* We need the shm object before we can create the cursor */
clutter_backend_wayland_load_cursor (backend_wayland);
return TRUE;
}
static void
gtk_im_context_wayland_global_init (GdkDisplay *display)
{
g_return_if_fail (global == NULL);
global = g_new0 (GtkIMContextWaylandGlobal, 1);
global->display = gdk_wayland_display_get_wl_display (display);
global->registry = wl_display_get_registry (global->display);
wl_registry_add_listener (global->registry, ®istry_listener, global);
}
int
main (int argc,
char *argv[])
{
struct desktop *desktop;
gdk_set_allowed_backends ("wayland");
gtk_init (&argc, &argv);
g_resources_register (maynard_get_resource ());
desktop = malloc (sizeof *desktop);
desktop->output = NULL;
desktop->shell = NULL;
desktop->helper = NULL;
desktop->gdk_display = gdk_display_get_default ();
desktop->display =
gdk_wayland_display_get_wl_display (desktop->gdk_display);
if (desktop->display == NULL)
{
fprintf (stderr, "failed to get display: %m\n");
return -1;
}
desktop->registry = wl_display_get_registry (desktop->display);
wl_registry_add_listener (desktop->registry,
®istry_listener, desktop);
/* Wait until we have been notified about the compositor,
* shell, and shell helper objects */
while (!desktop->output || !desktop->shell || !desktop->helper)
wl_display_roundtrip (desktop->display);
desktop->grid_visible = FALSE;
desktop->system_visible = FALSE;
desktop->volume_visible = FALSE;
css_setup (desktop);
background_create (desktop);
/* panel needs to be first so the clock and launcher grid can
* be added to its layer */
panel_create (desktop);
clock_create (desktop);
launcher_grid_create (desktop);
gtk_main ();
/* TODO cleanup */
return EXIT_SUCCESS;
}
