transfer.h

Go to the documentation of this file.

/*
    KWin - the KDE window manager
    This file is part of the KDE project.
 
    SPDX-FileCopyrightText: 2018 Roman Gilg <subdiff@gmail.com>
 
    SPDX-License-Identifier: GPL-2.0-or-later
*/
#pragma once
 
#include <QList>
#include <QObject>
#include <QSocketNotifier>
 
#include <xcb/xcb.h>
 
namespace KWayland
{
namespace Client
{
class DataDevice;
class DataSource;
}
}
namespace KWin
{
class DataDeviceInterface;
 
namespace Xwl
{
 
class Transfer : public QObject
{
    Q_OBJECT
 
public:
    Transfer(xcb_atom_t selection,
             qint32 fd,
             xcb_timestamp_t timestamp,
             QObject *parent = nullptr);
 
    virtual bool handlePropertyNotify(xcb_property_notify_event_t *event) = 0;
    void timeout();
    xcb_timestamp_t timestamp() const
    {
        return m_timestamp;
    }
 
Q_SIGNALS:
    void finished();
 
protected:
    void endTransfer();
 
    xcb_atom_t atom() const
    {
        return m_atom;
    }
    qint32 fd() const
    {
        return m_fd;
    }
 
    void setIncr(bool set)
    {
        m_incr = set;
    }
    bool incr() const
    {
        return m_incr;
    }
    void resetTimeout()
    {
        m_timeout = false;
    }
    void createSocketNotifier(QSocketNotifier::Type type);
    void clearSocketNotifier();
    QSocketNotifier *socketNotifier() const
    {
        return m_notifier;
    }
 
private:
    void closeFd();
 
    xcb_atom_t m_atom;
    qint32 m_fd;
    xcb_timestamp_t m_timestamp = XCB_CURRENT_TIME;
 
    QSocketNotifier *m_notifier = nullptr;
    bool m_incr = false;
    bool m_timeout = false;
 
    Q_DISABLE_COPY(Transfer)
};
 
class TransferWltoX : public Transfer
{
    Q_OBJECT
 
public:
    TransferWltoX(xcb_atom_t selection,
                  xcb_selection_request_event_t *request,
                  qint32 fd,
                  QObject *parent = nullptr);
    ~TransferWltoX() override;
 
    void startTransferFromSource();
    bool handlePropertyNotify(xcb_property_notify_event_t *event) override;
 
Q_SIGNALS:
    void selectionNotify(xcb_selection_request_event_t *event, bool success);
 
private:
    void startIncr();
    void readWlSource();
    int flushSourceData();
    void handlePropertyDelete();
 
    xcb_selection_request_event_t *m_request = nullptr;
 
    /* contains all received data portioned in chunks
     * TODO: explain second QPair component
     */
    QList<QPair<QByteArray, int>> m_chunks;
 
    bool m_propertyIsSet = false;
    bool m_flushPropertyOnDelete = false;
 
    Q_DISABLE_COPY(TransferWltoX)
};
 
class DataReceiver
{
public:
    virtual ~DataReceiver();
 
    void transferFromProperty(xcb_get_property_reply_t *reply);
 
    void setData(const char *value, int length);
    QByteArray data() const;
 
    void partRead(int length);
 
private:
    xcb_get_property_reply_t *m_propertyReply = nullptr;
    int m_propertyStart = 0;
    QByteArray m_data;
};
 
class TransferXtoWl : public Transfer
{
    Q_OBJECT
 
public:
    TransferXtoWl(xcb_atom_t selection,
                  xcb_atom_t target,
                  qint32 fd,
                  xcb_timestamp_t timestamp, xcb_window_t parentWindow,
                  QObject *parent = nullptr);
    ~TransferXtoWl() override;
 
    bool handleSelectionNotify(xcb_selection_notify_event_t *event);
    bool handlePropertyNotify(xcb_property_notify_event_t *event) override;
 
private:
    void dataSourceWrite();
    void startTransfer();
    void getIncrChunk();
 
    xcb_window_t m_window;
    DataReceiver *m_receiver = nullptr;
 
    Q_DISABLE_COPY(TransferXtoWl)
};
 
} // namespace Xwl
} // namespace KWin