/* Registry callbacks. */
static void registry_handle_global(void *data, struct wl_registry *reg,
uint32_t id, const char *interface, uint32_t version)
{
struct wl_output *output = NULL;
gfx_ctx_wayland_data_t *wl = (gfx_ctx_wayland_data_t*)data;
(void)version;
if (string_is_equal_fast(interface, "wl_compositor", 13))
wl->compositor = (struct wl_compositor*)wl_registry_bind(reg,
id, &wl_compositor_interface, 3);
else if (string_is_equal_fast(interface, "wl_output", 9))
{
output = (struct wl_output*)wl_registry_bind(reg,
id, &wl_output_interface, 2);
wl_output_add_listener(output, &output_listener, wl);
wl_display_roundtrip(wl->input.dpy);
}
else if (string_is_equal_fast(interface, "wl_shell", 8))
wl->shell = (struct wl_shell*)
wl_registry_bind(reg, id, &wl_shell_interface, 1);
else if (string_is_equal_fast(interface, "wl_shm", 6))
wl->shm = (struct wl_shm*)wl_registry_bind(reg, id, &wl_shm_interface, 1);
else if (string_is_equal_fast(interface, "wl_seat", 7))
{
wl->seat = (struct wl_seat*)wl_registry_bind(reg, id, &wl_seat_interface, 4);
wl_seat_add_listener(wl->seat, &seat_listener, wl);
}
}
static void
display_handle_global(struct wl_display *display, uint32_t id,
const char *interface, uint32_t version, void *data)
{
struct display *d = data;
if (strcmp(interface, "compositor") == 0) {
d->compositor = wl_compositor_create(display, id);
} else if (strcmp(interface, "output") == 0) {
d->output = wl_output_create(display, id);
wl_output_add_listener(d->output, &output_listener, d);
} else if (strcmp(interface, "input_device") == 0) {
display_add_input(d, id);
} else if (strcmp(interface, "shell") == 0) {
d->shell = wl_shell_create(display, id);
wl_shell_add_listener(d->shell, &shell_listener, d);
} else if (strcmp(interface, "drm") == 0) {
d->drm = wl_drm_create(display, id);
wl_drm_add_listener(d->drm, &drm_listener, d);
} else if (strcmp(interface, "shm") == 0) {
d->shm = wl_shm_create(display, id);
} else if (strcmp(interface, "selection_offer") == 0) {
add_selection_offer(d, id);
} else if (d->global_handler) {
d->global_handler(d, interface, id, version);
}
}
void QWaylandDisplay::displayHandleGlobal(uint32_t id,
const QByteArray &interface,
uint32_t version)
{
Q_UNUSED(version);
if (interface == "wl_output") {
struct wl_output *output = wl_output_create(mDisplay, id, 1);
wl_output_add_listener(output, &outputListener, this);
} else if (interface == "wl_compositor") {
mCompositor = wl_compositor_create(mDisplay, id, 1);
wl_compositor_add_listener(mCompositor,
&compositorListener, this);
} else if (interface == "wl_shm") {
mShm = wl_shm_create(mDisplay, id, 1);
} else if (interface == "wl_shell"){
mShell = wl_shell_create(mDisplay, id, 1);
wl_shell_add_listener(mShell, &shellListener, this);
} else if (interface == "wl_input_device") {
QWaylandInputDevice *inputDevice =
new QWaylandInputDevice(this, id);
mInputDevices.append(inputDevice);
} else if (interface == "wl_selection_offer") {
QWaylandClipboard::instance(display)->createSelectionOffer(id);
}
}
void
NativeStateWayland::registry_handle_global(void *data, struct wl_registry *registry,
uint32_t id, const char *interface,
uint32_t /*version*/)
{
NativeStateWayland *that = static_cast<NativeStateWayland *>(data);
if (strcmp(interface, "wl_compositor") == 0) {
that->display_->compositor =
static_cast<struct wl_compositor *>(
wl_registry_bind(registry,
id, &wl_compositor_interface, 1));
} else if (strcmp(interface, "wl_shell") == 0) {
that->display_->shell =
static_cast<struct wl_shell *>(
wl_registry_bind(registry,
id, &wl_shell_interface, 1));
} else if (strcmp(interface, "wl_output") == 0) {
struct my_output *my_output = new struct my_output();
memset(my_output, 0, sizeof(*my_output));
my_output->output =
static_cast<struct wl_output *>(
wl_registry_bind(registry,
id, &wl_output_interface, 2));
that->display_->outputs.push_back(my_output);
wl_output_add_listener(my_output->output, &output_listener_, my_output);
wl_display_roundtrip(that->display_->display);
}
}
void QWaylandDisplay::displayHandleGlobal(uint32_t id,
const QByteArray &interface,
uint32_t version)
{
Q_UNUSED(version);
if (interface == "wl_output") {
struct wl_output *output = wl_output_create(mDisplay, id, 1);
wl_output_add_listener(output, &outputListener, this);
} else if (interface == "wl_compositor") {
mCompositor = wl_compositor_create(mDisplay, id, 1);
wl_compositor_add_listener(mCompositor,
&compositorListener, this);
} else if (interface == "wl_shm") {
mShm = wl_shm_create(mDisplay, id, 1);
} else if (interface == "wl_shell") {
mShell = wl_shell_create(mDisplay, id, 1);
wl_shell_add_listener(mShell, &shellListener, this);
} else if (interface == "wl_input_device") {
QWaylandInputDevice *inputDevice =
new QWaylandInputDevice(mDisplay, id);
mInputDevices.append(inputDevice);
} else if (interface == "wl_selection_offer") {
QPlatformIntegration *plat = QApplicationPrivate::platformIntegration();
QWaylandClipboard *clipboard = static_cast<QWaylandClipboard *>(plat->clipboard());
clipboard->createSelectionOffer(id);
}
}
static void
handle_global(void *data, struct wl_registry *registry, uint32_t id,
const char *interface, uint32_t version)
{
struct display *display = data;
struct input *input;
struct output *output;
if (strcmp(interface, "wl_compositor") == 0) {
display->compositor =
wl_registry_bind(display->registry,
id, &wl_compositor_interface, 1);
} else if (strcmp(interface, "wl_seat") == 0) {
input = calloc(1, sizeof *input);
input->seat = wl_registry_bind(display->registry, id,
&wl_seat_interface, 1);
input->pointer_focus = NULL;
input->keyboard_focus = NULL;
wl_seat_add_listener(input->seat, &seat_listener, input);
display->input = input;
} else if (strcmp(interface, "wl_output") == 0) {
output = malloc(sizeof *output);
output->output = wl_registry_bind(display->registry,
id, &wl_output_interface, 1);
wl_output_add_listener(output->output,
&output_listener, output);
display->output = output;
fprintf(stderr, "test-client: created output global %p\n",
display->output);
}
}
void _glfwAddOutputWayland(uint32_t name, uint32_t version)
{
_GLFWmonitor *monitor;
struct wl_output *output;
if (version < 2)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"Wayland: Unsupported output interface version");
return;
}
// The actual name of this output will be set in the geometry handler.
monitor = _glfwAllocMonitor(NULL, 0, 0);
output = wl_registry_bind(_glfw.wl.registry,
name,
&wl_output_interface,
2);
if (!output)
{
_glfwFreeMonitor(monitor);
return;
}
monitor->wl.scale = 1;
monitor->wl.output = output;
monitor->wl.name = name;
wl_output_add_listener(output, &outputListener, monitor);
}
static void
registry_handle_global(void *data, struct wl_registry *registry, uint32_t name,
const char *interface, uint32_t version)
{
struct wayland_compositor *c = data;
if (strcmp(interface, "wl_compositor") == 0) {
c->parent.compositor =
wl_registry_bind(registry, name,
&wl_compositor_interface, 1);
} else if (strcmp(interface, "wl_output") == 0) {
c->parent.output =
wl_registry_bind(registry, name,
&wl_output_interface, 1);
wl_output_add_listener(c->parent.output, &output_listener, c);
} else if (strcmp(interface, "wl_shell") == 0) {
c->parent.shell =
wl_registry_bind(registry, name,
&wl_shell_interface, 1);
} else if (strcmp(interface, "wl_seat") == 0) {
display_add_seat(c, name);
} else if (strcmp(interface, "wl_shm") == 0) {
c->parent.shm =
wl_registry_bind(registry, name, &wl_shm_interface, 1);
}
}
static void registry_global(void *data, struct wl_registry *registry,
uint32_t name, const char *interface, uint32_t version) {
struct registry *reg = data;
if (strcmp(interface, wl_compositor_interface.name) == 0) {
reg->compositor = wl_registry_bind(registry, name, &wl_compositor_interface, version);
} else if (strcmp(interface, wl_shm_interface.name) == 0) {
reg->shm = wl_registry_bind(registry, name, &wl_shm_interface, version);
} else if (strcmp(interface, wl_shell_interface.name) == 0) {
reg->shell = wl_registry_bind(registry, name, &wl_shell_interface, version);
} else if (strcmp(interface, wl_seat_interface.name) == 0) {
reg->seat = wl_registry_bind(registry, name, &wl_seat_interface, version);
reg->pointer = wl_seat_get_pointer(reg->seat);
reg->keyboard = wl_seat_get_keyboard(reg->seat);
if (reg->keyboard) {
wl_keyboard_add_listener(reg->keyboard, &keyboard_listener, reg);
}
} else if (strcmp(interface, wl_output_interface.name) == 0) {
struct wl_output *output = wl_registry_bind(registry, name, &wl_output_interface, version);
struct output_state *ostate = malloc(sizeof(struct output_state));
ostate->output = output;
wl_output_add_listener(output, &output_listener, ostate);
list_add(reg->outputs, ostate);
} else if (strcmp(interface, desktop_shell_interface.name) == 0) {
reg->desktop_shell = wl_registry_bind(registry, name, &desktop_shell_interface, version);
} else if (strcmp(interface, lock_interface.name) == 0) {
reg->swaylock = wl_registry_bind(registry, name, &lock_interface, version);
}
}
static void
gdk_display_handle_global(struct wl_display *display, uint32_t id,
const char *interface, uint32_t version, void *data)
{
GdkDisplayWayland *display_wayland = data;
GdkDisplay *gdk_display = GDK_DISPLAY_OBJECT (data);
struct wl_input_device *input;
if (strcmp(interface, "wl_compositor") == 0) {
display_wayland->compositor = wl_compositor_create(display, id, 1);
wl_compositor_add_listener(display_wayland->compositor,
&compositor_listener, display_wayland);
} else if (strcmp(interface, "wl_shm") == 0) {
display_wayland->shm = wl_shm_create(display, id, 1);
} else if (strcmp(interface, "wl_shell") == 0) {
display_wayland->shell = wl_shell_create(display, id, 1);
wl_shell_add_listener(display_wayland->shell,
&shell_listener, display_wayland);
} else if (strcmp(interface, "wl_output") == 0) {
display_wayland->output = wl_output_create(display, id, 1);
wl_output_add_listener(display_wayland->output,
&output_listener, display_wayland);
} else if (strcmp(interface, "wl_input_device") == 0) {
input = wl_input_device_create(display, id, 1);
_gdk_wayland_device_manager_add_device (gdk_display->device_manager,
input);
}
}
static void
mech_monitor_wayland_constructed (GObject *object)
{
MechMonitorWaylandPriv *priv = ((MechMonitorWayland *) object)->_priv;
wl_output_add_listener (priv->wl_output, &output_listener_funcs, object);
G_OBJECT_CLASS (mech_monitor_wayland_parent_class)->constructed (object);
}
void MockClient::handleGlobal(uint32_t id, const QByteArray &interface)
{
if (interface == "wl_compositor") {
compositor = static_cast<wl_compositor *>(wl_registry_bind(registry, id, &wl_compositor_interface, 1));
} else if (interface == "wl_output") {
output = static_cast<wl_output *>(wl_registry_bind(registry, id, &wl_output_interface, 1));
wl_output_add_listener(output, &outputListener, this);
} else if (interface == "wl_shm") {
shm = static_cast<wl_shm *>(wl_registry_bind(registry, id, &wl_shm_interface, 1));
}
}
Output::Output(uint32_t id, uint32_t version) {
p_ = std::make_unique<Private>(this);
p_->id = id;
p_->version = version;
Display *display = Application::GetInstance()->GetDisplay();
p_->wl_output =
static_cast<struct wl_output *>(wl_registry_bind(Display::Proxy::wl_registry(display),
id,
&wl_output_interface,
version));
wl_output_add_listener(p_->wl_output, &Private::kListener, this);
}
static void
handle_global(void *data, struct wl_registry *registry,
uint32_t id, const char *interface, uint32_t version)
{
struct client *client = data;
struct input *input;
struct output *output;
struct test *test;
struct global *global;
global = xzalloc(sizeof *global);
global->name = id;
global->interface = strdup(interface);
assert(interface);
global->version = version;
wl_list_insert(client->global_list.prev, &global->link);
if (strcmp(interface, "wl_compositor") == 0) {
client->wl_compositor =
wl_registry_bind(registry, id,
&wl_compositor_interface, 1);
} else if (strcmp(interface, "wl_seat") == 0) {
input = xzalloc(sizeof *input);
input->wl_seat =
wl_registry_bind(registry, id,
&wl_seat_interface, 1);
wl_seat_add_listener(input->wl_seat, &seat_listener, input);
client->input = input;
} else if (strcmp(interface, "wl_shm") == 0) {
client->wl_shm =
wl_registry_bind(registry, id,
&wl_shm_interface, 1);
wl_shm_add_listener(client->wl_shm, &shm_listener, client);
} else if (strcmp(interface, "wl_output") == 0) {
output = xzalloc(sizeof *output);
output->wl_output =
wl_registry_bind(registry, id,
&wl_output_interface, 1);
wl_output_add_listener(output->wl_output,
&output_listener, output);
client->output = output;
} else if (strcmp(interface, "wl_test") == 0) {
test = xzalloc(sizeof *test);
test->wl_test =
wl_registry_bind(registry, id,
&wl_test_interface, 1);
wl_test_add_listener(test->wl_test, &test_listener, test);
client->test = test;
}
}
void _glfwAddOutput(uint32_t name, uint32_t version)
{
_GLFWmonitor *monitor;
struct wl_output *output;
char name_str[80];
memset(name_str, 0, 80 * sizeof(char));
snprintf(name_str, 79, "wl_output@%u", name);
if (version < 2)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"Wayland: Unsupported output interface version");
return;
}
monitor = _glfwAllocMonitor(name_str, 0, 0);
output = wl_registry_bind(_glfw.wl.registry,
name,
&wl_output_interface,
2);
if (!output)
{
_glfwFreeMonitor(monitor);
return;
}
monitor->wl.modes = calloc(4, sizeof(_GLFWvidmodeWayland));
monitor->wl.modesSize = 4;
monitor->wl.output = output;
wl_output_add_listener(output, &output_listener, monitor);
if (_glfw.wl.monitorsCount + 1 >= _glfw.wl.monitorsSize)
{
_GLFWmonitor** monitors = _glfw.wl.monitors;
int size = _glfw.wl.monitorsSize * 2;
monitors = realloc(monitors, size * sizeof(_GLFWmonitor*));
_glfw.wl.monitors = monitors;
_glfw.wl.monitorsSize = size;
}
_glfw.wl.monitors[_glfw.wl.monitorsCount++] = monitor;
}
//output
Output::Output(WaylandAppContext& ac, wl_output& outp, unsigned int id)
: appContext_(&ac), wlOutput_(&outp), globalID_(id)
{
static constexpr wl_output_listener listener
{
memberCallback<decltype(&Output::geometry), &Output::geometry,
void(wl_output*, int32_t, int32_t, int32_t, int32_t, int32_t, const char*,
const char*, int32_t)>,
memberCallback<decltype(&Output::mode), &Output::mode,
void(wl_output*, uint32_t, int32_t, int32_t, int32_t)>,
memberCallback<decltype(&Output::done), &Output::done, void(wl_output*)>,
memberCallback<decltype(&Output::scale), &Output::scale, void(wl_output*, int32_t)>,
};
wl_output_add_listener(&outp, &listener, this);
}
void
_ecore_wl_output_add(Ecore_Wl_Display *ewd, unsigned int id)
{
Ecore_Wl_Output *output;
LOGFN(__FILE__, __LINE__, __FUNCTION__);
if (!(output = malloc(sizeof(Ecore_Wl_Output)))) return;
memset(output, 0, sizeof(Ecore_Wl_Output));
output->display = ewd;
output->output =
wl_registry_bind(ewd->wl.registry, id, &wl_output_interface, 1);
wl_list_insert(ewd->outputs.prev, &output->link);
wl_output_add_listener(output->output, &_ecore_wl_output_listener, output);
}
static void
Wayland_add_display(SDL_VideoData *d, uint32_t id)
{
struct wl_output *output;
SDL_VideoDisplay *display = SDL_malloc(sizeof *display);
if (!display) {
SDL_OutOfMemory();
return;
}
SDL_zero(*display);
output = wl_registry_bind(d->registry, id, &wl_output_interface, 2);
if (!output) {
SDL_SetError("Failed to retrieve output.");
return;
}
wl_output_add_listener(output, &output_listener, display);
}
static void registryHandleGlobal(void *data, struct wl_registry *registry,
uint32_t name, const char *interface, uint32_t version)
{
WaylandModule *wayland = reinterpret_cast<WaylandModule*>(data);
new QTreeWidgetItem(wayland->interfacesItem(), QStringList() << QString::fromUtf8(interface) << QString::number(version));
if (strcmp(interface, "wl_output") == 0) {
QTreeWidgetItem *outputItems = new QTreeWidgetItem(wayland->root(), QStringList() << i18n("Outputs"));
wl_output *output = reinterpret_cast<wl_output *>(wl_registry_bind(registry, name, &wl_output_interface, 1));
wl_output_add_listener(output, &s_outputListener, outputItems);
wayland->flush();
}
if (strcmp(interface, "wl_seat") == 0) {
QTreeWidgetItem *seatItem = new QTreeWidgetItem(wayland->root(), QStringList() << i18n("Seat"));
wl_seat *seat = reinterpret_cast<wl_seat*>(wl_registry_bind(registry, name, &wl_seat_interface, 1));
wl_seat_add_listener(seat, &s_seatListener, seatItem);
wayland->flush();
}
}
static void
display_handle_global (struct wl_display *display,
uint32_t id,
const char *interface,
uint32_t version,
void *data)
{
ClutterBackendWayland *backend_wayland = data;
if (strcmp (interface, "compositor") == 0)
{
backend_wayland->wayland_compositor = wl_compositor_create (display, id);
}
else if (strcmp (interface, "output") == 0)
{
backend_wayland->wayland_output = wl_output_create (display, id);
wl_output_add_listener (backend_wayland->wayland_output,
&output_listener, backend_wayland);
}
else if (strcmp (interface, "input_device") == 0)
{
_clutter_backend_add_input_device (backend_wayland, id);
}
else if (strcmp (interface, "shell") == 0)
{
backend_wayland->wayland_shell = wl_shell_create (display, id);
wl_shell_add_listener (backend_wayland->wayland_shell,
&shell_listener, backend_wayland);
}
else if (strcmp (interface, "drm") == 0)
{
backend_wayland->wayland_drm = wl_drm_create (display, id);
wl_drm_add_listener (backend_wayland->wayland_drm,
&drm_listener, backend_wayland);
}
else if (strcmp (interface, "shm") == 0)
{
backend_wayland->wayland_shm = wl_shm_create (display, id);
}
}
/* Registry callbacks. */
static void registry_handle_global(void *data, struct wl_registry *reg,
uint32_t id, const char *interface, uint32_t version)
{
gfx_ctx_wayland_data_t *wl = (gfx_ctx_wayland_data_t*)data;
struct wl_output *output;
(void)version;
if (string_is_equal(interface, "wl_compositor"))
wl->compositor = (struct wl_compositor*)wl_registry_bind(reg,
id, &wl_compositor_interface, 3);
else if (string_is_equal(interface, "wl_output"))
{
output = (struct wl_output*)wl_registry_bind(reg,
id, &wl_output_interface, 2);
wl_output_add_listener(output, &output_listener, wl);
wl_display_roundtrip(wl->dpy);
}
else if (string_is_equal(interface, "wl_shell"))
wl->shell = (struct wl_shell*)
wl_registry_bind(reg, id, &wl_shell_interface, 1);
}
static void registry_handle_global (void *data,
struct wl_registry *registry,
uint32_t id,
const char *interface,
uint32_t version)
{
struct vo_wayland_state *wl = data;
struct wl_registry *reg = wl->display.registry;
if (strcmp(interface, "wl_compositor") == 0) {
wl->display.compositor = wl_registry_bind(reg, id,
&wl_compositor_interface, 1);
}
else if (strcmp(interface, "wl_shell") == 0) {
wl->display.shell = wl_registry_bind(reg, id, &wl_shell_interface, 1);
}
else if (strcmp(interface, "wl_shm") == 0) {
wl->display.shm = wl_registry_bind(reg, id, &wl_shm_interface, 1);
}
else if (strcmp(interface, "wl_output") == 0) {
struct vo_wayland_output *output =
talloc_zero(wl, struct vo_wayland_output);
output->id = id;
output->output = wl_registry_bind(reg, id, &wl_output_interface, 1);
wl_output_add_listener(output->output, &output_listener, output);
wl_list_insert(&wl->display.output_list, &output->link);
}
else if (strcmp(interface, "wl_seat") == 0) {
/** Create an output from a wl_output
*
* \param proxy The proxy for a wl_output (struct wl_output *).
* \param name The global name for the wl_output.
* \return A new output object.
*
* The wl_output must be at least version 2.
*
* Events on the wl_output will be automatically handled. The reference
* count is initialized to 1. The ownership of the proxy is taken.
*/
struct output *
output_create(void *proxy, uint32_t name)
{
struct output *o;
if (wl_proxy_get_version(proxy) < 2) {
fprintf(stderr,
"unsupported: wl_output version is below 2\n");
return NULL;
}
o = xzalloc(sizeof(*o));
wl_list_init(&o->mode_list);
o->proxy = proxy;
o->name = name;
wl_list_init(&o->link);
o->refcount = 1;
wl_output_add_listener(o->proxy, &output_listener, o);
return o;
}
static void
registry_handle_global (void *data,
struct wl_registry *registry,
uint32_t id,
const char *interface,
uint32_t version)
{
ClutterBackendWayland *backend_wayland = data;
if (strcmp (interface, "wl_compositor") == 0)
backend_wayland->wayland_compositor =
wl_registry_bind (registry, id, &wl_compositor_interface, 1);
else if (strcmp (interface, "wl_seat") == 0)
{
ClutterDeviceManager *device_manager = backend_wayland->device_manager;
_clutter_device_manager_wayland_add_input_group (device_manager, id);
}
else if (strcmp (interface, "wl_shell") == 0)
{
backend_wayland->wayland_shell =
wl_registry_bind (registry, id, &wl_shell_interface, 1);
}
else if (strcmp (interface, "wl_shm") == 0)
{
backend_wayland->wayland_shm =
wl_registry_bind (registry, id, &wl_shm_interface, 1);
}
else if (strcmp (interface, "wl_output") == 0)
{
/* FIXME: Support multiple outputs */
backend_wayland->wayland_output =
wl_registry_bind (registry, id, &wl_output_interface, 1);
wl_output_add_listener (backend_wayland->wayland_output,
&wayland_output_listener,
backend_wayland);
}
}
void CompositorOutput::AddListener( WlOutput* outputInterface )
{
mOutput = outputInterface;
wl_output_add_listener( mOutput , &OutputListener, this);
}
static int Open(vlc_object_t *obj)
{
demux_t *demux = (demux_t *)obj;
if (demux->out == NULL)
return VLC_EGENERIC;
demux_sys_t *sys = malloc(sizeof (*sys));
if (unlikely(sys == NULL))
return VLC_ENOMEM;
/* Connect to the display server */
char *dpy_name = var_InheritString(demux, "wl-display");
sys->display = wl_display_connect(dpy_name);
free(dpy_name);
if (sys->display == NULL)
{
free(sys);
return VLC_EGENERIC;
}
sys->output = NULL;
sys->shm = NULL;
sys->screenshooter = NULL;
sys->es = NULL;
sys->pagemask = sysconf(_SC_PAGE_SIZE) - 1;
sys->rate = var_InheritFloat(demux, "screen-fps");
sys->x = var_InheritInteger(demux, "screen-left");
sys->y = var_InheritInteger(demux, "screen-top");
sys->w = var_InheritInteger(demux, "screen-width");
sys->h = var_InheritInteger(demux, "screen-height");
if (1000.f * sys->rate <= 0x1.p-30)
goto error;
demux->p_sys = sys;
/* Find the interesting singleton(s) */
struct wl_registry *registry = wl_display_get_registry(sys->display);
if (registry == NULL)
goto error;
wl_registry_add_listener(registry, ®istry_cbs, demux);
wl_display_roundtrip(sys->display);
wl_registry_destroy(registry);
if (sys->output == NULL || sys->shm == NULL || sys->screenshooter == NULL)
{
msg_Err(demux, "screenshooter extension not supported");
goto error;
}
wl_output_add_listener(sys->output, &output_cbs, demux);
screenshooter_add_listener(sys->screenshooter, &screenshooter_cbs,
&sys->done);
wl_display_roundtrip(sys->display);
if (DisplayError(demux, sys->display))
goto error;
/* Initializes demux */
sys->start = vlc_tick_now();
if (vlc_clone(&sys->thread, Thread, demux, VLC_THREAD_PRIORITY_INPUT))
goto error;
demux->pf_demux = NULL;
demux->pf_control = Control;
return VLC_SUCCESS;
error:
if (sys->screenshooter != NULL)
screenshooter_destroy(sys->screenshooter);
if (sys->shm != NULL)
wl_shm_destroy(sys->shm);
if (sys->output != NULL)
wl_output_destroy(sys->output);
wl_display_disconnect(sys->display);
free(sys);
return VLC_EGENERIC;
}
/**
* Creates a Wayland shell surface.
*/
static int Open(vout_window_t *wnd, const vout_window_cfg_t *cfg)
{
if (cfg->type != VOUT_WINDOW_TYPE_INVALID
&& cfg->type != VOUT_WINDOW_TYPE_WAYLAND)
return VLC_EGENERIC;
vout_window_sys_t *sys = malloc(sizeof (*sys));
if (unlikely(sys == NULL))
return VLC_ENOMEM;
sys->compositor = NULL;
sys->output = NULL;
sys->shell = NULL;
sys->shell_surface = NULL;
sys->top_width = cfg->width;
sys->top_height = cfg->height;
sys->fs_width = cfg->width;
sys->fs_height = cfg->height;
sys->fullscreen = false;
vlc_mutex_init(&sys->lock);
wnd->sys = sys;
/* Connect to the display server */
char *dpy_name = var_InheritString(wnd, "wl-display");
struct wl_display *display = wl_display_connect(dpy_name);
free(dpy_name);
if (display == NULL)
{
vlc_mutex_destroy(&sys->lock);
free(sys);
return VLC_EGENERIC;
}
/* Find the interesting singleton(s) */
struct wl_registry *registry = wl_display_get_registry(display);
if (registry == NULL)
goto error;
wl_registry_add_listener(registry, ®istry_cbs, wnd);
wl_display_roundtrip(display);
wl_registry_destroy(registry);
if (sys->compositor == NULL || sys->shell == NULL)
goto error;
if (sys->output != NULL)
wl_output_add_listener(sys->output, &output_cbs, wnd);
/* Create a surface */
struct wl_surface *surface = wl_compositor_create_surface(sys->compositor);
if (surface == NULL)
goto error;
struct wl_shell_surface *shell_surface =
wl_shell_get_shell_surface(sys->shell, surface);
if (shell_surface == NULL)
goto error;
sys->shell_surface = shell_surface;
wl_shell_surface_add_listener(shell_surface, &shell_surface_cbs, wnd);
wl_shell_surface_set_class(shell_surface, PACKAGE_NAME);
wl_shell_surface_set_toplevel(shell_surface);
char *title = var_InheritString(wnd, "video-title");
wl_shell_surface_set_title(shell_surface, title ? title
: _("VLC media player"));
free(title);
//if (var_InheritBool (wnd, "keyboard-events"))
// do_something();
wl_display_flush(display);
wnd->type = VOUT_WINDOW_TYPE_WAYLAND;
wnd->handle.wl = surface;
wnd->display.wl = display;
wnd->control = Control;
if (vlc_clone (&sys->thread, Thread, wnd, VLC_THREAD_PRIORITY_LOW))
goto error;
vout_window_ReportSize(wnd, cfg->width, cfg->height);
return VLC_SUCCESS;
error:
if (sys->shell_surface != NULL)
wl_shell_surface_destroy(sys->shell_surface);
if (sys->shell != NULL)
wl_shell_destroy(sys->shell);
if (sys->output != NULL)
wl_output_destroy(sys->output);
if (sys->compositor != NULL)
wl_compositor_destroy(sys->compositor);
wl_display_disconnect(display);
vlc_mutex_destroy(&sys->lock);
free(sys);
return VLC_EGENERIC;
}
