shadow.cpp

/*
    SPDX-FileCopyrightText: 2015 Martin Gräßlin <[email protected]>

    SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
*/
#include "shadow.h"
#include "event_queue.h"
#include "surface.h"
#include "wayland_pointer_p.h"

#include <QMarginsF>

#include <wayland-shadow-client-protocol.h>

namespace KWayland
{

namespace Client
{

class Q_DECL_HIDDEN ShadowManager::Private
{
public:
    Private() = default;

    WaylandPointer<org_kde_kwin_shadow_manager, org_kde_kwin_shadow_manager_destroy> manager;
    EventQueue *queue = nullptr;
};

ShadowManager::ShadowManager(QObject *parent)
    : QObject(parent)
    , d(new Private)
{
}

ShadowManager::~ShadowManager()
{
    release();
}

void ShadowManager::release()
{
    d->manager.release();
}

void ShadowManager::destroy()
{
    d->manager.destroy();
}

bool ShadowManager::isValid() const
{
    return d->manager.isValid();
}

void ShadowManager::setup(org_kde_kwin_shadow_manager *manager)
{
    Q_ASSERT(manager);
    Q_ASSERT(!d->manager);
    d->manager.setup(manager);
}

void ShadowManager::setEventQueue(EventQueue *queue)
{
    d->queue = queue;
}

EventQueue *ShadowManager::eventQueue()
{
    return d->queue;
}

Shadow *ShadowManager::createShadow(Surface *surface, QObject *parent)
{
    Q_ASSERT(isValid());
    Shadow *s = new Shadow(parent);
    auto w = org_kde_kwin_shadow_manager_create(d->manager, *surface);
    if (d->queue) {
        d->queue->addProxy(w);
    }
    s->setup(w);
    return s;
}

void ShadowManager::removeShadow(Surface *surface)
{
    Q_ASSERT(isValid());
    org_kde_kwin_shadow_manager_unset(d->manager, *surface);
}

ShadowManager::operator org_kde_kwin_shadow_manager*()
{
    return d->manager;
}

ShadowManager::operator org_kde_kwin_shadow_manager*() const
{
    return d->manager;
}

class Shadow::Private
{
public:
    WaylandPointer<org_kde_kwin_shadow, org_kde_kwin_shadow_destroy> shadow;
};

Shadow::Shadow(QObject *parent)
    : QObject(parent)
    , d(new Private)
{
}

Shadow::~Shadow()
{
    release();
}

void Shadow::release()
{
    d->shadow.release();
}

void Shadow::setup(org_kde_kwin_shadow *shadow)
{
    Q_ASSERT(shadow);
    Q_ASSERT(!d->shadow);
    d->shadow.setup(shadow);
}

void Shadow::destroy()
{
    d->shadow.destroy();
}

bool Shadow::isValid() const
{
    return d->shadow.isValid();
}

void Shadow::setOffsets(const QMarginsF &margins)
{
    Q_ASSERT(isValid());
    org_kde_kwin_shadow_set_left_offset(d->shadow, wl_fixed_from_double(margins.left()));
    org_kde_kwin_shadow_set_top_offset(d->shadow, wl_fixed_from_double(margins.top()));
    org_kde_kwin_shadow_set_right_offset(d->shadow, wl_fixed_from_double(margins.right()));
    org_kde_kwin_shadow_set_bottom_offset(d->shadow, wl_fixed_from_double(margins.bottom()));
}

void Shadow::commit()
{
    Q_ASSERT(isValid());
    org_kde_kwin_shadow_commit(d->shadow);
}

#ifndef K_DOXYGEN
#define attach( __PART__, __WAYLAND_PART__ ) \
void Shadow::attach##__PART__(wl_buffer *buffer) \
{ \
    Q_ASSERT(isValid()); \
    org_kde_kwin_shadow_attach_##__WAYLAND_PART__(d->shadow, buffer); \
} \
void Shadow::attach##__PART__(Buffer *buffer) \
{ \
    if (!buffer) {\
        return;\
    }\
    attach##__PART__(buffer->buffer()); \
} \
void Shadow::attach##__PART__(Buffer::Ptr buffer) \
{ \
    attach##__PART__(buffer.toStrongRef().data()); \
}

attach(Left, left)
attach(TopLeft, top_left)
attach(Top, top)
attach(TopRight, top_right)
attach(Right, right)
attach(BottomRight, bottom_right)
attach(Bottom, bottom)
attach(BottomLeft, bottom_left)

#undef attach
#endif

Shadow::operator org_kde_kwin_shadow*()
{
    return d->shadow;
}

Shadow::operator org_kde_kwin_shadow*() const
{
    return d->shadow;
}

}
}