Wayland: クリップボード

$ cc -o test 15-clipboard.c client.c imagebuf.c xdg-shell-protocol.c -lwayland-client -lrt

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define __USE_GNU
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <poll.h>

#include <linux/input-event-codes.h>

#include <wayland-client.h>
#include "xdg-shell-client-protocol.h"

#include "client.h"
#include "imagebuf.h"


//-------------

typedef struct
{
    client b;
    struct pollfd poll[2];

    struct wl_data_device_manager *data_device_manager;
    struct wl_data_device *data_device;
    struct wl_data_source *data_source;
    struct wl_data_offer *data_offer;

    uint32_t data_device_manager_ver;

    char *copy_text,    //コピー文字列
        *recv_buf;        //受信バッファ
    int text_size,        //コピー文字列のサイズ
        recv_cursize,    //受信バッファ、現在の読み込みサイズ
        recv_bufsize;    //受信バッファ確保サイズ
}client_ex;

//-------------


/* ソースデータ解放 */

static void _source_release(client_ex *p)
{
    if(p->data_source)
    {
        wl_data_source_destroy(p->data_source);
        p->data_source = NULL;
    }

    if(p->copy_text)
    {
        free(p->copy_text);
        p->copy_text = NULL;
    }
}


//========================
// wl_data_source
//========================


static void _data_source_target(void *data,
    struct wl_data_source *source, const char *mime_type)
{
}

/* データが要求された時 */

static void _data_source_send(void *data, struct wl_data_source *source,
    const char *mime_type, int32_t fd)
{
    client_ex *p = (client_ex *)data;

    if(!mime_type)
        close(fd);
    else
    {
        printf("wl_data_source # send | mime_type:\"%s\", fd:%d\n", mime_type, fd);

        //fd に書き込んで、送る

        write(fd, p->copy_text, p->text_size);
        close(fd);
    }
}

/* データソースが置き換わった時 */

static void _data_source_cancelled(void *data, struct wl_data_source *source)
{
    printf("wl_data_source # cancelled | source:%p\n", source);

    _source_release((client_ex *)data);
}

void _data_source_dnd_drop_performed(void *data, struct wl_data_source *source)
{
}

void _data_source_dnd_finished(void *data, struct wl_data_source *source)
{
}

void _data_source_action(void *data, struct wl_data_source *source, uint32_t dnd_action)
{
}

static const struct wl_data_source_listener g_data_source_listener = {
    _data_source_target, _data_source_send, _data_source_cancelled,
    _data_source_dnd_drop_performed, _data_source_dnd_finished,
    _data_source_action
};


//========================
// wl_data_offer
//========================


/* 提供されている MIME タイプが通知される */

static void _data_offer_offer(void *data, struct wl_data_offer *offer, const char *type)
{
    printf("wl_data_offer # offer | type:\"%s\"\n", type);
}

static void _data_offer_source_actions(void *data,
    struct wl_data_offer *offer, uint32_t source_actions)
{
}

static void _data_offer_action(void *data, struct wl_data_offer *offer, uint32_t dnd_action)
{
}

static const struct wl_data_offer_listener g_data_offer_listener = {
    _data_offer_offer, _data_offer_source_actions, _data_offer_action
};


//========================
// wl_data_device
//========================


static void _device_data_offer(void *data,
    struct wl_data_device *data_device, struct wl_data_offer *offer)
{
    printf("wl_data_device # data_offer | offer:%p\n", offer);

    wl_data_offer_add_listener(offer, &g_data_offer_listener, data);
}

static void _device_enter(void *data, struct wl_data_device *data_device, uint32_t serial,
    struct wl_surface *surface, wl_fixed_t x, wl_fixed_t y, struct wl_data_offer *offer)
{
}

static void _device_leave(void *data, struct wl_data_device *data_device)
{
}

static void _device_motion(void *data, struct wl_data_device *data_device,
    uint32_t time, wl_fixed_t x, wl_fixed_t y)
{
}

static void _device_drop(void *data, struct wl_data_device *data_device)
{
}

/* クリップボード用の wl_data_offer が送られてくる */

static void _device_selection(void *data,
    struct wl_data_device *data_device, struct wl_data_offer *offer)
{
    client_ex *p = (client_ex *)data;

    printf("wl_data_device # selection | offer:%p\n", offer);

    //前回の data_offer は破棄する

    if(p->data_offer)
        wl_data_offer_destroy(p->data_offer);

    //新しい offer を保持
    //(クリップボードにデータがない場合は NULL)

    p->data_offer = offer;
}

static const struct wl_data_device_listener g_data_device_listener = {
    _device_data_offer, _device_enter, _device_leave,
    _device_motion, _device_drop, _device_selection
};


//========================
// コピー/貼り付け処理
//========================


/* コピー */

static void _copy_text(client_ex *p,const char *text,uint32_t serial)
{
    printf("-- copy text: \"%s\"\n", text);

    //前のソースを解放

    _source_release(p);

    //内部データに文字列をコピー

    p->text_size = strlen(text);

    p->copy_text = (char *)malloc(p->text_size);

    memcpy(p->copy_text, text, p->text_size);

    //このクライアントがデータを持っていることを通知する

    p->data_source = wl_data_device_manager_create_data_source(p->data_device_manager);

    wl_data_source_offer(p->data_source, "text/plain;charset=utf-8");
    wl_data_source_offer(p->data_source, "UTF8_STRING");

    wl_data_source_add_listener(p->data_source, &g_data_source_listener, p);

    wl_data_device_set_selection(p->data_device, p->data_source, serial);
}

/* 貼り付け */

static void _paste(client_ex *p)
{
    int fd[2];

    if(!p->data_offer)
    {
        printf("-- paste: no data\n");
        return;
    }

    //現在、データを受信中

    if(p->poll[1].fd != -1) return;

    //データの受信を要求

    if(pipe2(fd, O_CLOEXEC) == -1) return;

    wl_data_offer_receive(p->data_offer, "text/plain;charset=utf-8", fd[1]);
    close(fd[1]);

    p->poll[1].fd = fd[0];
    p->recv_cursize = 0;
}

/* 貼り付け時のデータ受信 */

static void _data_recv_handle(client_ex *p,int events)
{
    int fd,ret = 0;

    fd = p->poll[1].fd;

    printf("@ poll | ");
    if(events & POLLIN) printf("POLLIN ");
    if(events & POLLHUP) printf("POLLHUP ");
    printf("\n");

    //受信するデータがある場合

    if(events & POLLIN)
    {
        //最後に NULL 文字を追加するので、読み込みサイズは 1 byte 減らす

        ret = read(fd, p->recv_buf + p->recv_cursize,
            p->recv_bufsize - p->recv_cursize - 1);

        p->recv_cursize += ret;

        printf("@ recv | read:%d byte, buf:%d/%d byte\n", (int)ret, p->recv_cursize, p->recv_bufsize);
    }

    //

    if(ret == 0)
    {
        //受信データがなくなったら終了

        close(fd);
        p->poll[1].fd = -1;

        //NULL 文字を追加
        p->recv_buf[p->recv_cursize] = 0;

        printf("<paste text>\n");
        puts(p->recv_buf);
    }
    else
    {
        //データが続く場合、常に 1 KB 以上の空き容量を作っておく

        if(p->recv_bufsize - p->recv_cursize < 1024)
        {
            p->recv_bufsize += 1024;
            p->recv_buf = (char *)realloc(p->recv_buf, p->recv_bufsize);
        }
    }
}


//========================


static void _registry_global(
    client *cl,struct wl_registry *reg,uint32_t id,const char *name,uint32_t ver)
{
    client_ex *p = (client_ex *)cl;

    if(strcmp(name, "wl_data_device_manager") == 0)
    {
        if(ver >= 3) ver = 3;

        p->data_device_manager = wl_registry_bind(reg, id, &wl_data_device_manager_interface, ver);
        p->data_device_manager_ver = ver;
    }
}

/* キー押し */

static void _keyboard_press(client *cl,uint32_t key,uint32_t serial)
{
    client_ex *p = (client_ex *)cl;
    char m[64];

    switch(key)
    {
        //コピー
        case KEY_C:
            snprintf(m, 64, "copytext-%u", serial);
            _copy_text(p, m, serial);
            break;
        //貼り付け
        case KEY_V:
            _paste(p);
            break;
        //所有権放棄
        case KEY_R:
            if(p->data_source)
            {
                wl_data_device_set_selection(p->data_device, NULL, serial);
                _source_release(p);
            }
            break;
        //ESC キーで終了
        case KEY_ESC:
            p->b.finish_loop = 1;
            break;
    }
}

/* イベントループ */

static void _event_loop(client_ex *p)
{
    //display イベント用

    p->poll[0].fd = wl_display_get_fd(p->b.display);
    p->poll[0].events = POLLIN;

    //貼り付けデータ取得用
    // 初期状態ではデータがないため、fd = -1。
    // fd が負の値の場合、poll() 時に無視される。

    p->poll[1].fd = -1;
    p->poll[1].events = POLLIN;

    //ループ

    while(!p->b.finish_loop)
    {
        wl_display_flush(p->b.display);

        if(poll(p->poll, 2, -1) < 0) break;

        //イベントを処理

        if(p->poll[0].revents & POLLIN)
            wl_display_dispatch(p->b.display);

        //データ受信

        if(p->poll[1].revents)
            _data_recv_handle(p, p->poll[1].revents);
    }
}

/* client_ex 破棄 */

static void _clientex_destroy(client *cl)
{
    client_ex *p = (client_ex *)cl;

    free(p->recv_buf);

    //wl_data_offer

    if(p->data_offer)
        wl_data_offer_destroy(p->data_offer);

    //ソースデータ

    _source_release(p);

    //wl_data_device

    if(p->data_device_manager_ver >= WL_DATA_DEVICE_RELEASE_SINCE_VERSION)
        wl_data_device_release(p->data_device);
    else
        wl_data_device_destroy(p->data_device);

    //wl_data_device_manager

    wl_data_device_manager_destroy(p->data_device_manager);
}

/* main */

int main(void)
{
    client_ex *p;
    Toplevel *win;

    p = (client_ex *)client_new(sizeof(client_ex));

    p->b.destroy = _clientex_destroy;
    p->b.init_flags = CLIENT_INIT_FLAGS_SEAT | CLIENT_INIT_FLAGS_KEYBOARD;
    p->b.registry_global = _registry_global;
    p->b.func_keyboard_key_press = _keyboard_press;

    client_init(CLIENT(p));

    //wl_data_device

    p->data_device = wl_data_device_manager_get_data_device(
        p->data_device_manager, p->b.seat);

    wl_data_device_add_listener(p->data_device, &g_data_device_listener, p);

    //貼り付け時用の受信バッファ

    p->recv_buf = (char *)malloc(1024);
    p->recv_bufsize = 1024;

    //ウィンドウ

    win = toplevel_create(CLIENT(p), 256, 256, NULL);

    imagebuf_fill(win->sf.img, 0xffff0000);

    //

    _event_loop(p);

    //解放

    toplevel_destroy(win);

    client_destroy(CLIENT(p));

    return 0;
}

//破棄
void wl_data_device_manager_destroy(struct wl_data_device_manager *wl_data_device_manager);

//wl_data_device の作成

struct wl_data_device *wl_data_device_manager_get_data_device(
  struct wl_data_device_manager *wl_data_device_manager, struct wl_seat *seat);

//破棄

void wl_data_device_destroy(struct wl_data_device *wl_data_device);

//解放 (ver 2)

void wl_data_device_release(struct wl_data_device *wl_data_device);

//ハンドラ設定

int wl_data_device_add_listener(struct wl_data_device *wl_data_device,
  const struct wl_data_device_listener *listener, void *data);

struct wl_data_device_listener {
    void (*data_offer)(void *data, struct wl_data_device *data_device, struct wl_data_offer *id);
    void (*enter)(void *data, struct wl_data_device *data_device, uint32_t serial,
        struct wl_surface *surface, wl_fixed_t x, wl_fixed_t y, struct wl_data_offer *id);
    void (*leave)(void *data, struct wl_data_device *data_device);
    void (*motion)(void *data, struct wl_data_device *data_device,
        uint32_t time, wl_fixed_t x, wl_fixed_t y);
    void (*drop)(void *data, struct wl_data_device *data_device)
    void (*selection)(void *data, struct wl_data_device *data_device, struct wl_data_offer *id);
};
//data_offer, selection 以外は D&D で使用する

• すべての wl_registry:global イベントが終了した後に行う。
• global イベント内で、wl_data_device_manager と wl_seat の２つが作成できた時点で行う。

void (*selection)(void *data, struct wl_data_device *data_device, struct wl_data_offer *id);

void (*data_offer)(void *data, struct wl_data_device *data_device, struct wl_data_offer *id);

wl_data_device:data_offer  -> wl_data_offer ハンドラ設定
wl_data_offer:offer (複数) -> MIME タイプの取得
wl_data_device:selection   -> wl_data_offer の保持と破棄

//破棄

void wl_data_offer_destroy(struct wl_data_offer *wl_data_offer);

//ハンドラ設定

int wl_data_offer_add_listener(struct wl_data_offer *data_offer,
    const struct wl_data_offer_listener *listener, void *data);

struct wl_data_offer_listener {
    void (*offer)(void *data, struct wl_data_offer *data_offer, const char *mime_type);
    //ver 3
    void (*source_actions)(void *data, struct wl_data_offer *data_offer, uint32_t source_actions);
    void (*action)(void *data, struct wl_data_offer *data_offer, uint32_t dnd_action);
};

void (*offer)(void *data, struct wl_data_offer *data_offer, const char *mime_type);

===== クリップボードデータがない時

wl_data_device # selection | offer:(nil)

===== テキストデータがある時

wl_data_device # selection | offer:(nil)
wl_data_device # data_offer | offer:0x5bac2d54df00
wl_data_offer # offer | type:"text/plain"
wl_data_offer # offer | type:"text/plain;charset=utf-8"
wl_data_offer # offer | type:"STRING"
wl_data_offer # offer | type:"text/plain"
wl_data_offer # offer | type:"TEXT"
wl_data_offer # offer | type:"COMPOUND_TEXT"
wl_data_offer # offer | type:"UTF8_STRING"
wl_data_offer # offer | type:"text/plain;charset=utf-8"
wl_data_offer # offer | type:"application/x-gtk-text-buffer-rich-text"
wl_data_offer # offer | type:"GTK_TEXT_BUFFER_CONTENTS"
wl_data_device # selection | offer:0x5bac2d54df00

//wl_data_source を作成

struct wl_data_source *wl_data_device_manager_create_data_source(
    struct wl_data_device_manager *wl_data_device_manager);

//破棄

void wl_data_source_destroy(struct wl_data_source *wl_data_source);

//ハンドラ設定

int wl_data_source_add_listener(struct wl_data_source *wl_data_source,
    const struct wl_data_source_listener *listener, void *data);

struct wl_data_source_listener {
    void (*target)(void *data, struct wl_data_source *wl_data_source, const char *mime_type);
    void (*send)(void *data, struct wl_data_source *wl_data_source, const char *mime_type, int32_t fd);
    void (*cancelled)(void *data, struct wl_data_source *wl_data_source);
    //ver 3
    void (*dnd_drop_performed)(void *data, struct wl_data_source *wl_data_source);
    void (*dnd_finished)(void *data, struct wl_data_source *wl_data_source);
    void (*action)(void *data, struct wl_data_source *wl_data_source, uint32_t dnd_action);
};
//send, cancelled 以外は D&D で使用する

//MIME タイプ追加

void wl_data_source_offer(struct wl_data_source *wl_data_source, const char *mime_type);

//(wl_data_device) クリップボードのデータとしてセット

void wl_data_device_set_selection(struct wl_data_device *wl_data_device,
    struct wl_data_source *source, uint32_t serial);

-- copy text: "copytext-414"
wl_data_device # data_offer | offer:0x5be5bff76560
wl_data_offer # offer | type:"UTF8_STRING"
wl_data_offer # offer | type:"text/plain;charset=utf-8"
wl_data_device # selection | offer:0x5be5bff76560

wl_data_source # send | mime_type:"text/plain;charset=utf-8", fd:5
wl_data_source # send | mime_type:"UTF8_STRING", fd:5
wl_data_source # send | mime_type:"UTF8_STRING", fd:5

void (*send)(void *data, struct wl_data_source *wl_data_source, const char *mime_type, int32_t fd);

void (*cancelled)(void *data, struct wl_data_source *wl_data_source);