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; }
void GammaControlManager::bind(wl_client *client, uint32_t version, uint32_t id) { static const struct gamma_control_manager_interface implementation = { wrapInterface(destroy), wrapInterface(getGammaControl) }; wl_resource *resource = wl_resource_create(client, &gamma_control_manager_interface, version, id); wl_resource_set_implementation(resource, &implementation, this, nullptr); }
void Screenshooter::bind(wl_client *client, uint32_t version, uint32_t id) { wl_resource *resource = wl_resource_create(client, &orbital_screenshooter_interface, version, id); static const struct orbital_screenshooter_interface implementation = { wrapInterface(shoot), wrapInterface(shootSurface), }; wl_resource_set_implementation(resource, &implementation, this, nullptr); }
SurfaceScreenshot(Compositor *c, wl_resource *res) : m_compositor(c) , m_resource(res) , m_surface(nullptr) { static const struct orbital_surface_screenshot_interface implementation = { wrapInterface(shoot), }; wl_resource_set_implementation(m_resource, &implementation, this, nullptr); }
void global(wl_registry *registry, uint32_t id, const char *interface, uint32_t version) { #define registry_bind(type, v) static_cast<type *>(wl_registry_bind(registry, id, &type ## _interface, qMin(version, v))) if (strcmp(interface, "orbital_authorizer_helper") == 0) { helper = registry_bind(orbital_authorizer_helper, 1u); static const orbital_authorizer_helper_listener listener = { wrapInterface(&Helper::authorizationRequested) }; orbital_authorizer_helper_add_listener(helper, &listener, this); } }
jobjectArray wrapInterfaces(JNIEnv *env, int count, const struct libusb_interface *interfaces) { jobjectArray array = (jobjectArray) (*env)->NewObjectArray(env, count, (*env)->FindClass(env, CLASS_PATH("Interface")), NULL); for (int i = 0; i < count; i++) (*env)->SetObjectArrayElement(env, array, i, wrapInterface(env, &interfaces[i])); return array; }
void DesktopShellSettings::bind(wl_client *client, uint32_t version, uint32_t id) { wl_resource *resource = wl_resource_create(client, &orbital_settings_interface, version, id); // FIXME // // We trust only client we started ourself // pid_t pid; // wl_client_get_credentials(client, &pid, nullptr, nullptr); // if (pid != getpid()) { // wl_resource_post_error(resource, WL_DISPLAY_ERROR_INVALID_OBJECT, "permission to bind orbital_settings denied"); // wl_resource_destroy(resource); // return; // } static const struct orbital_settings_interface implementation = { wrapInterface(destroy), wrapInterface(setKeymap), }; wl_resource_set_implementation(resource, &implementation, this, nullptr); }
void ClipboardManager::bind(wl_client *client, uint32_t version, uint32_t id) { static const struct orbital_clipboard_manager_interface implementation = { wrapInterface(destroy) }; wl_resource *resource = wl_resource_create(client, &orbital_clipboard_manager_interface, version, id); wl_resource_set_implementation(resource, &implementation, this, [](wl_resource *r) { auto *_this = static_cast<ClipboardManager *>(wl_resource_get_user_data(r)); auto it = std::find(_this->m_resources.begin(), _this->m_resources.end(), r); if (it != _this->m_resources.end()) { _this->m_resources.erase(it); } }); m_resources.push_back(resource); }
return true; } void CompositorSettings::stringOption(nuclear_settings *settings, const char *path, const char *name) { m_options.insert(QString(path) + "." + name, Option(Option::Type::String)); } void CompositorSettings::intOption(nuclear_settings *settings, const char *path, const char *name) { m_options.insert(QString(path) + "." + name, Option(Option::Type::Int)); } void CompositorSettings::bindingOption(nuclear_settings *settings, const char *path, const char *name, int types) { m_options.insert(QString(path) + "." + name, Option(Option::Type::Binding, types)); } const nuclear_settings_listener CompositorSettings::s_listener = { wrapInterface(&CompositorSettings::stringOption), wrapInterface(&CompositorSettings::intOption), wrapInterface(&CompositorSettings::bindingOption) }; CompositorSettings::Option::Option(Type t, int b) : type(t) , bindingType(b) , used(false) { }
} void Window::handleState(desktop_shell_window *window, int32_t state) { m_state = wlState2State(state); emit stateChanged(); } void Window::handleRemoved(desktop_shell_window *window) { emit destroyed(this); deleteLater(); } const desktop_shell_window_listener Window::m_window_listener = { wrapInterface(&Window::handleTitle), wrapInterface(&Window::handleIcon), wrapInterface(&Window::handleState), wrapInterface(&Window::handleRemoved) }; Window::Window(desktop_shell_window *window, pid_t pid, QObject *p) : QObject(p) , m_window(window) , m_pid(pid) , m_state(Window::Inactive) { desktop_shell_window_add_listener(window, &m_window_listener, this); } Window::~Window()
desktop_shell_panel_destroy(m_panel); } void Panel::move() { desktop_shell_panel_move(m_panel); } void Panel::setLocation(Element::Location loc) { if (loc == m_element->location()) { return; } m_element->setLocation(loc); setWidth(m_element->width()); setHeight(m_element->height()); Client::client()->setInputRegion(this, m_element->inputRegion()); desktop_shell_panel_set_position(m_panel, (uint32_t)loc); } void Panel::locationChanged(desktop_shell_panel *panel, uint32_t loc) { setLocation((Element::Location)loc); } const desktop_shell_panel_listener Panel::s_listener = { wrapInterface(&Panel::locationChanged) };
{ desktop_shell_grab_end(m_grab); } void Grab::handleEnded(desktop_shell_grab *grab) { emit ended(); } void Grab::handleFocus(desktop_shell_grab *grab, wl_surface *surface, wl_fixed_t x, wl_fixed_t y) { emit focus(surface, wl_fixed_to_int(x), wl_fixed_to_int(y)); } void Grab::handleMotion(desktop_shell_grab *grab, uint32_t time, wl_fixed_t x, wl_fixed_t y) { emit motion(time, wl_fixed_to_int(x), wl_fixed_to_int(y)); } void Grab::handleButton(desktop_shell_grab *grab, uint32_t time , uint32_t btn, uint32_t state) { emit button(time, btn, state); } const struct desktop_shell_grab_listener Grab::s_desktop_shell_grab_listener = { wrapInterface(&Grab::handleEnded), wrapInterface(&Grab::handleFocus), wrapInterface(&Grab::handleMotion), wrapInterface(&Grab::handleButton) };
namespace Orbital { WlShell::WlShell(Shell *shell, Compositor *c) : Interface(shell) , Global(c, &wl_shell_interface, 1) , m_shell(shell) { // weston_seat *seat; // wl_list_for_each(seat, &Shell::compositor()->seat_list, link) { // ShellSeat *shseat = ShellSeat::shellSeat(seat); // shseat->pointerFocusSignal.connect(this, &WlShell::pointerFocus); // } } void WlShell::bind(wl_client *client, uint32_t version, uint32_t id) { wl_resource *resource = wl_resource_create(client, &wl_shell_interface, version, id); if (resource) wl_resource_set_implementation(resource, &shell_implementation, this, nullptr); } ShellSurface *WlShell::getShellSurface(wl_client *client, wl_resource *resource, uint32_t id, wl_resource *surface_resource) { weston_surface *surface = static_cast<weston_surface *>(wl_resource_get_user_data(surface_resource)); if (surface->configure) { wl_resource_post_error(surface_resource, WL_DISPLAY_ERROR_INVALID_OBJECT, "The surface has a role already"); return nullptr; } ShellSurface *shsurf = m_shell->createShellSurface(surface); WlShellSurface *wlss = new WlShellSurface(this, shsurf, client, id); shsurf->addInterface(wlss); // wlss->responsivenessChangedSignal.connect(this, &WlShell::surfaceResponsiveness); // return shsurf; } // // void WlShell::pointerFocus(ShellSeat *, weston_pointer *pointer) // { // weston_view *view = pointer->focus; // // if (!view) // return; // // ShellSurface *shsurf = Shell::getShellSurface(view->surface); // if (!shsurf) // return; // // WlShellSurface *wlss = shsurf->findInterface<WlShellSurface>(); // if (!wlss) { // return; // } // // if (!wlss->isResponsive()) { // surfaceResponsivenessChangedSignal(shsurf, false); // } else { // uint32_t serial = wl_display_next_serial(Shell::compositor()->wl_display); // wlss->ping(serial); // } // } // // void WlShell::surfaceResponsiveness(WlShellSurface *wlsurf) // { // ShellSurface *shsurf = wlsurf->shsurf(); // surfaceResponsivenessChangedSignal(shsurf, wlsurf->isResponsive()); // } // // const weston_shell_client WlShell::shell_client = { // WlShell::sendConfigure // }; // const struct wl_shell_interface WlShell::shell_implementation = { wrapInterface(&WlShell::getShellSurface) }; }
shsurf()->setMaximized(output); } void XdgSurface::unsetMaximized(wl_client *client, wl_resource *resource) { shsurf()->unsetMaximized(); } void XdgSurface::setMinimized(wl_client *client, wl_resource *resource) { shsurf()->setMinimized(true); } const struct xdg_surface_interface XdgSurface::s_implementation = { wrapInterface(&XdgSurface::destroy), wrapInterface(&XdgSurface::setTransientFor), wrapInterface(&XdgSurface::setTitle), wrapInterface(&XdgSurface::setAppId), wrapInterface(&XdgSurface::pong), wrapInterface(&XdgSurface::move), wrapInterface(&XdgSurface::resize), wrapInterface(&XdgSurface::setOutput), wrapInterface(&XdgSurface::setFullscreen), wrapInterface(&XdgSurface::unsetFullscreen), wrapInterface(&XdgSurface::setMaximized), wrapInterface(&XdgSurface::unsetMaximized), wrapInterface(&XdgSurface::setMinimized) };