Wayland: D＆D

$ cc -o test 16-dnd.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 <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;
    Toplevel *win;

    int recv_bufsize,
        recv_cursize,
        is_uri_list;
    char *recv_buf;

    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,
        device_enter_serial,
        source_actions,
        dnd_action;
}client_ex;

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


/* wl_data_source 解放 */

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

/* アクション表示 */

static void _put_action(uint32_t f)
{
    if(f == WL_DATA_DEVICE_MANAGER_DND_ACTION_NONE)
        printf(" NONE");
    else
    {
        if(f & WL_DATA_DEVICE_MANAGER_DND_ACTION_COPY)
            printf(" COPY");

        if(f & WL_DATA_DEVICE_MANAGER_DND_ACTION_MOVE)
            printf(" MOVE");

        if(f & WL_DATA_DEVICE_MANAGER_DND_ACTION_ASK)
            printf(" ASK");
    }
}

/* ドロップ先の情報設定 */

static void _target_enter_leave(client_ex *p,int y)
{
    int type;

    type = ((y >> 8) >= p->win->sf.img->height / 2);

    //受け取る側が対応可能なアクションを指定 (ver 3 以降)

    if(p->data_device_manager_ver >= WL_DATA_OFFER_SET_ACTIONS_SINCE_VERSION)
    {
        if(type == 0)
        {
            //上半分: COPY, MOVE 対応で COPY 優先

            wl_data_offer_set_actions(p->data_offer,
                WL_DATA_DEVICE_MANAGER_DND_ACTION_COPY
                    | WL_DATA_DEVICE_MANAGER_DND_ACTION_MOVE,
                WL_DATA_DEVICE_MANAGER_DND_ACTION_COPY);
        }
        else
        {
            //下半分: ASK

            wl_data_offer_set_actions(p->data_offer,
                WL_DATA_DEVICE_MANAGER_DND_ACTION_ASK,
                WL_DATA_DEVICE_MANAGER_DND_ACTION_ASK);
        }
    }

    //受け入れる MIME タイプ (NULL で D&D を受け入れない)

    wl_data_offer_accept(p->data_offer, p->device_enter_serial,
        (p->is_uri_list)? "text/uri-list": "text/plain;charset=utf-8");
}

/* D&D データ受信 */

static void _recv_data(client_ex *p,int fd)
{
    ssize_t ret;

    p->recv_cursize = 0;

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

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

        if(ret <= 0)
        {
            //終了
            
            close(fd);

            p->recv_buf[p->recv_cursize] = 0;

            printf("<data>\n");
            puts(p->recv_buf);

            break;
        }
        else
        {
            p->recv_cursize += ret;

            //バッファが一杯
            if(p->recv_bufsize == p->recv_cursize + 1)
            {
                p->recv_bufsize += 2048;
                p->recv_buf = (char *)realloc(p->recv_buf, p->recv_bufsize);
            }
        }
    }
}


//===================================
// wl_data_source (D&D 元データ管理)
//===================================


/* ドロップ先で、enter/move イベント時に MIME タイプが指定された時 */

static void _data_source_target(void *data,
    struct wl_data_source *source, const char *mime_type)
{
    //ドロップ先がデータを受け入れない場合、NULL が渡される

    printf("wl_data_source # target | mime_type:\"%s\"\n",
        (mime_type)? mime_type: "NULL");
}

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

static void _data_source_send(void *data, struct wl_data_source *source,
    const char *mime_type, int32_t fd)
{
    printf("wl_data_source # send | mime_type:\"%s\"\n", mime_type);
    printf("@ write\n");
    
    write(fd, "dnd_test", 8);
    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);
}

/* ドロップ先が drop イベントを受け取った時 */

void _data_source_dnd_drop_performed(void *data, struct wl_data_source *source)
{
    printf("wl_data_source # dnd_drop_performed\n");
}

/* D&D 処理が全て終了した */

void _data_source_dnd_finished(void *data, struct wl_data_source *source)
{
    printf("wl_data_source # dnd_finished\n");

    _source_release((client_ex *)data);
}

/* サーバーが選択したアクションが通知される (D&D ソース向け) */

void _data_source_action(void *data, struct wl_data_source *source, uint32_t dnd_action)
{
    printf("wl_data_source # action | dnd_action:");
    _put_action(dnd_action);
    printf("\n");
}

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 (D&D 元の情報)
//===================================


/* D&D 元で提供されている MIME タイプの通知 */

static void _data_offer_offer(void *data, struct wl_data_offer *offer, const char *type)
{
    client_ex *p = (client_ex *)data;

    printf("wl_data_offer # offer | offer:%p, type:\"%s\"\n", offer, type);

    if(strcmp(type, "text/uri-list") == 0)
        p->is_uri_list |= 1;
}

/* D&D 元が対応可能なアクションの通知 */

static void _data_offer_source_actions(void *data,
    struct wl_data_offer *offer, uint32_t source_actions)
{
    printf("wl_data_offer # source_actions | offer:%p, source_actions:", offer);
    _put_action(source_actions);
    printf("\n");

    ((client_ex *)data)->source_actions = source_actions;
}

/* サーバーが選択したアクションが通知される (ドロップ先向け) */

static void _data_offer_action(void *data, struct wl_data_offer *offer, uint32_t dnd_action)
{
    printf("wl_data_offer # action | offer:%p, dnd_action:", offer);
    _put_action(dnd_action);
    printf("\n");

    ((client_ex *)data)->dnd_action = 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 (D&D 受け入れる側)
//===================================


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);

    ((client_ex *)data)->is_uri_list = 0;
}

/* D&D ポインタがウィンドウに入った時 */

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)
{
    client_ex *p = (client_ex *)data;

    printf("wl_data_device # enter | (%d, %d), offer:%p\n", x >> 8, y >> 8, offer);

    p->data_offer = offer;
    p->device_enter_serial = serial;

    _target_enter_leave(p, y);
}

/* D&D ポインタがウィンドウ外に出た or D&D が終了した時 */

static void _device_leave(void *data, struct wl_data_device *data_device)
{
    client_ex *p = (client_ex *)data;

    printf("wl_data_device # leave\n");

    if(p->data_offer)
    {
        wl_data_offer_destroy(p->data_offer);
        p->data_offer = NULL;
    }
}

/* ポインタがウィンドウ内で移動した時 */

static void _device_motion(void *data, struct wl_data_device *data_device,
    uint32_t time, wl_fixed_t x, wl_fixed_t y)
{
    printf("wl_data_device # motion | (%d, %d)\n", x >> 8, y >> 8);
    fflush(stdout);

    _target_enter_leave((client_ex *)data, y);
}

/* ユーザーがボタンを離して、ドロップを受け入れる時 */

static void _device_drop(void *data, struct wl_data_device *data_device)
{
    client_ex *p = (client_ex *)data;
    int fd[2];

    printf("wl_data_device # drop\n");

    //データ受信

    if(pipe2(fd, O_CLOEXEC) != -1)
    {
        wl_data_offer_receive(p->data_offer,
            (p->is_uri_list)? "text/uri-list": "text/plain;charset=utf-8", fd[1]);

        wl_display_flush(p->b.display);

        close(fd[1]);

        _recv_data(p, fd[0]);
    }

    //ASK の場合、ユーザーが選択したアクションをセット
    //(ここでは COPY で固定)

    if(p->dnd_action == WL_DATA_DEVICE_MANAGER_DND_ACTION_ASK
        && p->data_device_manager_ver >= WL_DATA_OFFER_SET_ACTIONS_SINCE_VERSION)
    {
        wl_data_offer_set_actions(p->data_offer,
            WL_DATA_DEVICE_MANAGER_DND_ACTION_COPY,
            WL_DATA_DEVICE_MANAGER_DND_ACTION_COPY);
    }

    //終了

    if(p->data_device_manager_ver >= WL_DATA_OFFER_FINISH_SINCE_VERSION)
        wl_data_offer_finish(p->data_offer);
}

static void _device_selection(void *data,
    struct wl_data_device *data_device, struct wl_data_offer *offer)
{
    printf("wl_data_device # selection | offer:%p\n", 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
};


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


/* D&D 開始 */

static void _start_drag(client_ex *p,uint32_t serial)
{
    //ソース準備

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

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

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

    //D&D 元が対応可能なアクションをセット

    if(p->data_device_manager_ver >= WL_DATA_SOURCE_SET_ACTIONS_SINCE_VERSION)
    {
        wl_data_source_set_actions(p->data_source,
            WL_DATA_DEVICE_MANAGER_DND_ACTION_COPY
                | WL_DATA_DEVICE_MANAGER_DND_ACTION_MOVE
                | WL_DATA_DEVICE_MANAGER_DND_ACTION_ASK);
    }

    //D&D 開始

    wl_data_device_start_drag(p->data_device,
        p->data_source, p->win->sf.surface, NULL, serial);
}


//==================
// wl_pointer
//==================


static void _pointer_enter(void *data, struct wl_pointer *pointer,
    uint32_t serial, struct wl_surface *surface, wl_fixed_t x, wl_fixed_t y)
{
    printf("wl_pointer # enter\n");

    client_set_cursor(CLIENT(data), serial);
}

static void _pointer_leave(void *data, struct wl_pointer *pointer,
    uint32_t serial, struct wl_surface *surface)
{
    printf("wl_pointer # leave\n");
}

static void _pointer_motion(void *data, struct wl_pointer *pointer,
    uint32_t time, wl_fixed_t x, wl_fixed_t y)
{
    printf("wl_pointer # motion | (%d, %d)\n", x >> 8, y >> 8);
}

static void _pointer_button(void *data, struct wl_pointer *pointer,
    uint32_t serial, uint32_t time, uint32_t button, uint32_t state)
{
    client_ex *p = (client_ex *)data;

    if(state == WL_POINTER_BUTTON_STATE_PRESSED)
    {
        if(button == BTN_MIDDLE)
            //中ボタンで終了
            p->b.finish_loop = 1;
        else if(button == BTN_LEFT)
            //D&D開始
            _start_drag(p, serial);
    }
}

static void _pointer_axis(void *data, struct wl_pointer *pointer,
    uint32_t time, uint32_t axis, wl_fixed_t value)
{
}

static void _pointer_frame(void *data, struct wl_pointer *pointer)
{
}

static void _pointer_axis_source(void *data, struct wl_pointer *pointer, uint32_t axis_source)
{
}

static void _pointer_axis_stop(void *data, struct wl_pointer *pointer, uint32_t time, uint32_t axis)
{
}

static void _pointer_axis_discrete(void *data, struct wl_pointer *pointer, uint32_t axis, int32_t discrete)
{
}

//ver 5
static const struct wl_pointer_listener g_pointer_listener = {
    _pointer_enter, _pointer_leave, _pointer_motion, _pointer_button,
    _pointer_axis, _pointer_frame, _pointer_axis_source, _pointer_axis_stop, _pointer_axis_discrete
};


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


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;
    }
}

/* client_ex 破棄 */

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

    if(p->recv_buf)
        free(p->recv_buf);

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

    _source_release(p);

    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_destroy(p->data_device_manager);
}

/* メイン */

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_POINTER
        | CLIENT_INIT_FLAGS_CREATE_CURSOR;
    p->b.registry_global = _registry_global;
    p->b.pointer_listener = &g_pointer_listener;

    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;

    //ウィンドウ

    p->win = win = toplevel_create(CLIENT(p), 256, 300, NULL);

    imagebuf_fill_horz(win->sf.img, 0, 150, 0xffff0000);
    imagebuf_fill_horz(win->sf.img, 150, 150, 0xff0000ff);

    //イベントループ

    client_loop_simple(CLIENT(p));

    //解放

    toplevel_destroy(win);

    client_destroy(CLIENT(p));

    return 0;
}