void Compositor::onXdgToplevelCreated(QWaylandXdgToplevel *toplevel, QWaylandXdgSurface *shellSurface)
//void Compositor::onXdgSurfaceCreated(QWaylandXdgSurface *shellSurface)
{
unsigned int windowId = mNextWindowId++;
QWaylandSurface *surface = shellSurface->surface();
qDebug() << Q_FUNC_INFO << "windowId" << windowId << surface;
QQuickWindow *defaultOutputWindow = static_cast<QQuickWindow*>(defaultOutput()->window());
CompositorWindow *window = new CompositorWindow(windowId, defaultOutputWindow->contentItem());
window->setOutput(defaultOutput()); //useful ?
window->setFlag(QQuickItem::ItemIsFocusScope, true);
// window->setUseTextureAlpha(true);
window->initialize(shellSurface);
window->setSize(surface->size());
window->setTouchEventsEnabled(true);
mWindows.insert(windowId, window);
connect(window, &CompositorWindow::readyChanged, this, &Compositor::windowIsReady);
connect(window, &QWaylandQuickItem::surfaceDestroyed, this, &Compositor::onSurfaceDestroyed);
window->sendWindowIdToClient();
}
void QtWaylandMotorcarCompositor::surfaceMapped()
{
QWaylandSurface *surface = qobject_cast<QWaylandSurface *>(sender());
std::cout << "mapped surface: " << surface << std::endl;
QPoint pos;
//if (!m_surfaces.contains(surface)) {
//surface->setPos(QPoint(0, 0));
if (surface->hasShellSurface()) {
motorcar::WaylandSurface::SurfaceType surfaceType;
int type = static_cast<int>(surface->windowType());
float popupZOffset = 0.05;
if(type == QWaylandSurface::WindowType::Toplevel) {
surfaceType = motorcar::WaylandSurface::SurfaceType::TOPLEVEL;
} else if(type == QWaylandSurface::WindowType::Popup) {
surfaceType = motorcar::WaylandSurface::SurfaceType::POPUP;
} else if(type == QWaylandSurface::WindowType::Transient) {
surfaceType = motorcar::WaylandSurface::SurfaceType::TRANSIENT;
} else {
surfaceType = motorcar::WaylandSurface::SurfaceType::NA;
}
QtWaylandMotorcarSurface *motorsurface = this->getMotorcarSurface(surface);
if(motorsurface == NULL) {
//if it is not present for some weird reason just go ahead and create it for good measure
std::cout << "Warning: qwaylandsurface was mapped but motorcar surface does not exist yet, creating now" <<std::endl;
// surfaceCreated(surface);
// surfaceNode = this->getSurfaceNode(surface);
motorsurface = new QtWaylandMotorcarSurface(surface, this, motorcar::WaylandSurface::SurfaceType::NA);
m_surfaceMap.insert(std::pair<QWaylandSurface *, QtWaylandMotorcarSurface *>(surface, motorsurface));
}
// if((motorsurface->type() == motorcar::WaylandSurface::SurfaceType::CUBOID ||
// motorsurface->type() == motorcar::WaylandSurface::SurfaceType::PORTAL)
// && surfaceType == motorcar::WaylandSurface::SurfaceType::TOPLEVEL){
// std::cout << "Warning: ignoring request to remap a 3D surface to a top level surface " <<std::endl;
// }else{
this->scene()->windowManager()->mapSurface(motorsurface, surfaceType);
// }
//defaultInputDevice()->setKeyboardFocus(surface);
}
//m_renderScheduler.start(0);
}
void Compositor::onSurfaceMappedChanged()
{
QWaylandSurface *surface = qobject_cast<QWaylandSurface *>(sender());
CompositorWindow *window = surfaceWindow(surface);
if(window && surface) {
if(surface->hasContent()) {
qDebug() << __PRETTY_FUNCTION__ << " MAPPED " << window << "appId" << window->appId() << "windowType" << window->windowType();
// If it was a window created by QtWebProcess, it may be not already in our WindowModel list
if (!WindowModel::isWindowAlreadyAdded(mWindowModels, window)) {
qDebug() << Q_FUNC_INFO << "Adding window" << window << "to our models";
emit windowAdded(QVariant::fromValue(static_cast<QQuickItem*>(window)));
WindowModel::addWindowForEachModel(mWindowModels, window);
}
emit windowShown(QVariant::fromValue(static_cast<QQuickItem*>(window)));
}
else {
qDebug() << __PRETTY_FUNCTION__ << " UNMAPPED " << window << "appId" << window->appId() << "windowType" << window->windowType();
if (window == mFullscreenWindow)
setFullscreenWindow(0);
emit windowHidden(QVariant::fromValue(static_cast<QQuickItem*>(window)));
}
}
}
void LipstickCompositor::surfaceMapped()
{
QWaylandSurface *surface = qobject_cast<QWaylandSurface *>(sender());
//Ignore surface if it's not a window surface
if (!surface->hasShellSurface())
return;
QVariantMap properties = surface->windowProperties();
QString category = properties.value("CATEGORY").toString();
if (surface->surfaceItem())
return;
// The surface was mapped for the first time
int id = m_nextWindowId++;
LipstickCompositorWindow *item = new LipstickCompositorWindow(id, category, surface, contentItem());
item->setSize(surface->size());
QObject::connect(item, SIGNAL(destroyed(QObject*)), this, SLOT(windowDestroyed()));
m_totalWindowCount++;
m_mappedSurfaces.insert(id, item);
item->setTouchEventsEnabled(true);
emit windowCountChanged();
emit windowAdded(item);
windowAdded(id);
emit availableWinIdsChanged();
}
void LipstickCompositor::surfaceSizeChanged()
{
QWaylandSurface *surface = qobject_cast<QWaylandSurface *>(sender());
LipstickCompositorWindow *window = static_cast<LipstickCompositorWindow *>(surface->surfaceItem());
if (window)
window->setSize(surface->size());
}
void LipstickCompositor::surfaceLowered()
{
QWaylandSurface *surface = qobject_cast<QWaylandSurface *>(sender());
LipstickCompositorWindow *window = static_cast<LipstickCompositorWindow *>(surface->surfaceItem());
if (window) {
emit windowLowered(window);
}
}
void SystemCompositor::surfaceUnmapped()
{
// Set to 0 the current surface if it was unmapped
QWaylandSurface *surface = qobject_cast<QWaylandSurface *>(sender());
if (surface == m_currentSurface)
m_currentSurface = 0;
// Announce this window was destroyed
QQuickItem *item = surface->surfaceItem();
emit windowDestroyed(QVariant::fromValue(item));
}
void SystemCompositor::surfaceDestroyed(QObject *object)
{
// Set to 0 the current surface if it was destroyed
QWaylandSurface *surface = static_cast<QWaylandSurface *>(object);
if (surface == m_currentSurface)
m_currentSurface = 0;
// Announce this window was destroyed
QQuickItem *item = surface->surfaceItem();
if (item)
emit windowDestroyed(QVariant::fromValue(item));
}
QWaylandSurface *QWindowCompositor::surfaceAt(const QPointF &point, QPointF *local)
{
for (int i = m_surfaces.size() - 1; i >= 0; --i) {
QWaylandSurface *surface = m_surfaces.at(i);
QRectF geo(surface->pos(), surface->size());
if (geo.contains(point)) {
if (local)
*local = toSurface(surface, point);
return surface;
}
}
return 0;
}
void LipstickCompositor::surfaceTitleChanged()
{
QWaylandSurface *surface = qobject_cast<QWaylandSurface *>(sender());
LipstickCompositorWindow *window = static_cast<LipstickCompositorWindow *>(surface->surfaceItem());
if (window) {
emit window->titleChanged();
int windowId = window->windowId();
for (int ii = 0; ii < m_windowModels.count(); ++ii)
m_windowModels.at(ii)->titleChanged(windowId);
}
}
int LipstickCompositor::windowIdForLink(QWaylandSurface *s, uint link) const
{
for (QHash<int, LipstickCompositorWindow *>::ConstIterator iter = m_mappedSurfaces.begin();
iter != m_mappedSurfaces.end(); ++iter) {
QWaylandSurface *windowSurface = iter.value()->surface();
if (windowSurface && windowSurface->processId() == s->processId() &&
windowSurface->windowProperties().value("WINID", uint(0)).toUInt() == link)
return iter.value()->windowId();
}
return 0;
}
void PlasmaEffects::effects_slide(Resource *resource,
wl_resource *outputResource,
wl_resource *surfaceResource,
uint32_t from,
int32_t x, int32_t y)
{
Q_UNUSED(resource);
QWaylandOutput *output = QWaylandOutput::fromResource(outputResource);
if (!output) {
qCWarning(PLASMA_EFFECTS_PROTOCOL) << "Couldn't get output from resource";
return;
}
QWaylandSurface *surface = QWaylandSurface::fromResource(surfaceResource);
if (!surface) {
qCWarning(PLASMA_EFFECTS_PROTOCOL) << "Couldn't get surface from resource";
return;
}
QPointF ptFrom;
QPointF ptTo(x, y);
switch (from) {
case location_none:
ptFrom.setX(output->geometry().width() / 2);
ptFrom.setY(output->geometry().height() / 2);
break;
case location_left:
ptFrom = QPointF(-surface->size().width(), 0);
break;
case location_top:
ptFrom = QPointF(0, -surface->size().height());
break;
case location_right:
ptFrom = QPointF(output->geometry().width() +
surface->size().width(), 0);
break;
case location_bottom:
ptFrom = QPointF(0, output->geometry().height() +
surface->size().height());
break;
}
for (const PlasmaSurface *plasmaSurface: m_shell->surfaces()) {
if (plasmaSurface->surface() == surface)
Q_EMIT plasmaSurface->window()->moveRequested(ptFrom, ptTo);
}
}
bool NotificationPreviewPresenter::notificationShouldBeShown(LipstickNotification *notification)
{
bool screenOrDeviceLocked = locks->getState(MeeGo::QmLocks::TouchAndKeyboard) == MeeGo::QmLocks::Locked || locks->getState(MeeGo::QmLocks::Device) == MeeGo::QmLocks::Locked;
bool notificationHidden = notification->hints().value(NotificationManager::HINT_HIDDEN).toBool();
bool notificationHasPreviewText = !(notification->previewBody().isEmpty() && notification->previewSummary().isEmpty());
int notificationIsCritical = notification->hints().value(NotificationManager::HINT_URGENCY).toInt() >= 2;
uint mode = AllNotificationsEnabled;
QWaylandSurface *surface = LipstickCompositor::instance()->surfaceForId(LipstickCompositor::instance()->topmostWindowId());
if (surface != 0) {
mode = surface->windowProperties().value("NOTIFICATION_PREVIEWS_DISABLED", uint(AllNotificationsEnabled)).toUInt();
}
return !notificationHidden && notificationHasPreviewText && (!screenOrDeviceLocked || notificationIsCritical) &&
(mode == AllNotificationsEnabled || (mode == ApplicationNotificationsDisabled && notificationIsCritical) || (mode == SystemNotificationsDisabled && !notificationIsCritical));
}
void ScreenSaver::screensaver_set_surface(Resource *resource,
struct ::wl_resource *output_resource,
struct ::wl_resource *surface_resource)
{
Q_UNUSED(resource);
Q_UNUSED(output_resource);
QWaylandSurface *surface =
QtWayland::Surface::fromResource(surface_resource)->waylandSurface();
// TODO: As soon as QtCompositor handles outputs we need to center on output
QWaylandSurfaceItem *item = surface->surfaceItem();
if (item)
item->setZ(100000);
Q_EMIT m_compositor->fadeIn();
}
void LipstickCompositor::windowPropertyChanged(const QString &property)
{
QWaylandSurface *surface = qobject_cast<QWaylandSurface *>(sender());
if (debug())
qDebug() << "Window properties changed:" << surface << surface->windowProperties();
if (property == QLatin1String("MOUSE_REGION")) {
LipstickCompositorWindow *window = static_cast<LipstickCompositorWindow *>(surface->surfaceItem());
if (window)
window->refreshMouseRegion();
} else if (property == QLatin1String("GRABBED_KEYS")) {
LipstickCompositorWindow *window = static_cast<LipstickCompositorWindow *>(surface->surfaceItem());
if (window)
window->refreshGrabbedKeys();
}
}
QVariant WindowModel::data(const QModelIndex &index, int role) const
{
int idx = index.row();
if (idx < 0 || idx >= m_items.count())
return QVariant();
LipstickCompositor *c = LipstickCompositor::instance();
if (role == Qt::UserRole + 1) {
return m_items.at(idx);
} else if (role == Qt::UserRole + 2) {
QWaylandSurface *s = c->surfaceForId(m_items.at(idx));
return s?s->processId():0;
} else if (role == Qt::UserRole + 3) {
LipstickCompositorWindow *w = static_cast<LipstickCompositorWindow *>(c->windowForId(m_items.at(idx)));
return w->title();
} else {
return QVariant();
}
}
void LipstickCompositorWindow::refreshMouseRegion()
{
QWaylandSurface *s = surface();
if (s) {
QVariantMap properties = s->windowProperties();
if (properties.contains(QLatin1String("MOUSE_REGION"))) {
m_mouseRegion = s->windowProperties().value("MOUSE_REGION").value<QRegion>();
m_mouseRegionValid = true;
if (LipstickCompositor::instance()->debug())
qDebug() << "Window" << windowId() << "mouse region set:" << m_mouseRegion;
} else {
m_mouseRegionValid = false;
if (LipstickCompositor::instance()->debug())
qDebug() << "Window" << windowId() << "mouse region cleared";
}
emit mouseRegionBoundsChanged();
}
}
void DataDeviceManager::overrideSelection(const QMimeData &mimeData)
{
QStringList formats = mimeData.formats();
if (formats.isEmpty())
return;
m_retainedData.clear();
foreach (const QString &format, formats)
m_retainedData.setData(format, mimeData.data(format));
QWaylandCompositorPrivate::get(m_compositor)->feedRetainedSelectionData(&m_retainedData);
m_compositorOwnsSelection = true;
QWaylandSeat *dev = m_compositor->defaultSeat();
QWaylandSurface *focusSurface = dev->keyboardFocus();
if (focusSurface)
offerFromCompositorToClient(
QWaylandSeatPrivate::get(dev)->dataDevice()->resourceMap().value(focusSurface->waylandClient())->handle);
}
void Compositor::closeWindowWithId(int winId)
{
qDebug() << Q_FUNC_INFO << "winId" << winId;
CompositorWindow *window = mWindows.value(winId, 0);
if (window && window->surface()) {
QWaylandSurface *surface = window->surface();
if (window->checkIsAllowedToStay() ||
hasProcessMultipleWindows(surface->client()) ||
window->keepAlive()) {
qDebug() << Q_FUNC_INFO << "Destroying surface and keeping client alive";
window->sendClose();
}
else {
qDebug() << Q_FUNC_INFO << "Closing client and destroying surface";
destroyClientForSurface(surface);
}
}
}
void LipstickCompositorWindow::refreshGrabbedKeys()
{
QWaylandSurface *s = surface();
if (s) {
const QStringList grabbedKeys = s->windowProperties().value(
QLatin1String("GRABBED_KEYS")).value<QStringList>();
if (m_grabbedKeys.isEmpty() && !grabbedKeys.isEmpty()) {
qApp->installEventFilter(this);
} else if (!m_grabbedKeys.isEmpty() && grabbedKeys.isEmpty()) {
qApp->removeEventFilter(this);
}
m_grabbedKeys.clear();
foreach (const QString &key, grabbedKeys)
m_grabbedKeys.append(key.toInt());
if (LipstickCompositor::instance()->debug())
qDebug() << "Window" << windowId() << "grabbed keys changed:" << grabbedKeys;
}
}
void QWindowCompositor::paintChildren(QWaylandSurface *surface, QWaylandSurface *window, const QSize &windowSize) {
if (surface->subSurfaces().size() == 0)
return;
QLinkedListIterator<QWaylandSurface *> i(surface->subSurfaces());
while (i.hasNext()) {
QWaylandSurface *subSurface = i.next();
QPointF p = subSurface->mapTo(window,QPointF(0,0));
QSize subSize = subSurface->size();
subSurface->advanceBufferQueue();
if (subSize.isValid()) {
GLuint texture = 0;
if (subSurface->type() == QWaylandSurface::Texture) {
texture = subSurface->texture(QOpenGLContext::currentContext());
} else if (surface->type() == QWaylandSurface::Shm ) {
texture = m_textureCache->bindTexture(QOpenGLContext::currentContext(),surface->image());
}
QRect geo(p.toPoint(),subSize);
if (texture > 0)
m_textureBlitter->drawTexture(texture,geo,windowSize,0,window->isYInverted(),subSurface->isYInverted());
if (surface->type() == QWaylandSurface::Shm)
glDeleteTextures(1, &texture);
}
paintChildren(subSurface,window,windowSize);
}
}
void QWindowCompositor::surfaceMapped()
{
QWaylandSurface *surface = qobject_cast<QWaylandSurface *>(sender());
QPoint pos;
if (!m_surfaces.contains(surface)) {
uint px = 0;
uint py = 0;
if (!QCoreApplication::arguments().contains(QLatin1String("-stickytopleft"))) {
px = 1 + (qrand() % (m_window->width() - surface->size().width() - 2));
py = 1 + (qrand() % (m_window->height() - surface->size().height() - 2));
}
pos = QPoint(px, py);
surface->setPos(pos);
} else {
m_surfaces.removeOne(surface);
}
//Sometimes surfaces dont have shell_surfaces, so don't render them
if (surface->hasShellSurface()) {
m_surfaces.append(surface);
defaultInputDevice()->setKeyboardFocus(surface);
}
m_renderScheduler.start(0);
}
void SystemCompositor::surfaceMapped()
{
QWaylandSurface *surface = qobject_cast<QWaylandSurface *>(sender());
//A surface without a shell surface is not a window
if (!surface->hasShellSurface())
return;
QWaylandSurfaceItem *item = surface->surfaceItem();
// Create a QWaylandSurfaceItem from the surface
if (!item) {
item = new QWaylandSurfaceItem(surface, rootObject());
item->setClientRenderingEnabled(true);
item->setTouchEventsEnabled(true);
}
// Surface items gain focus right after they were mapped
item->takeFocus();
// Announce a window was added
emit windowAdded(QVariant::fromValue(static_cast<QQuickItem *>(item)));
}
void QWaylandPointerPrivate::pointer_set_cursor(wl_pointer::Resource *resource, uint32_t serial, wl_resource *surface, int32_t hotspot_x, int32_t hotspot_y)
{
Q_UNUSED(resource);
Q_UNUSED(serial);
if (!surface) {
seat->cursorSurfaceRequest(Q_NULLPTR, 0, 0);
return;
}
QWaylandSurface *s = QWaylandSurface::fromResource(surface);
// XXX FIXME
// The role concept was formalized in wayland 1.7, so that release adds one error
// code for each interface that implements a role, and we are supposed to pass here
// the newly constructed resource and the correct error code so that if setting the
// role fails, a proper error can be sent to the client.
// However we're still using wayland 1.4, which doesn't have interface specific role
// errors, so the best we can do is to use wl_display's object_id error.
wl_resource *displayRes = wl_client_get_object(resource->client(), 1);
if (s->setRole(&QWaylandPointerPrivate::s_role, displayRes, WL_DISPLAY_ERROR_INVALID_OBJECT)) {
s->markAsCursorSurface(true);
seat->cursorSurfaceRequest(s, hotspot_x, hotspot_y);
}
}
void QtwaylandSurfaceNode::paintChildren(QWaylandSurface *surface, QWaylandSurface *window, OpenGLData *glData) {
if (surface->subSurfaces().size() == 0)
return;
QLinkedListIterator<QWaylandSurface *> i(surface->subSurfaces());
while (i.hasNext()) {
QWaylandSurface *subSurface = i.next();
QPointF p = subSurface->mapTo(window,QPointF(0,0));
if (subSurface->size().isValid()) {
GLuint texture = 0;
if (subSurface->type() == QWaylandSurface::Texture) {
texture = subSurface->texture(QOpenGLContext::currentContext());
} else if (surface->type() == QWaylandSurface::Shm ) {
texture = glData->m_textureCache->bindTexture(QOpenGLContext::currentContext(),surface->image());
}
QRect geo(p.toPoint(),subSurface->size());
glData->m_textureBlitter->drawTexture(texture,geo,window->size(),0,window->isYInverted(),subSurface->isYInverted());
}
paintChildren(subSurface,window, glData);
}
}
void QWindowCompositor::sendExpose()
{
QWaylandSurface *surface = qobject_cast<QWaylandSurface *>(sender());
surface->sendOnScreenVisibilityChange(true);
}
