Wayland: ポップアップウィンドウ (xdg_popup)

$ cc -o test 14-popup.c client.c imagebuf.c xdg-shell-protocol.c -lwayland-client -lrt

• 左ドラッグで、ウィンドウ位置を移動します。
• 右クリックで、青いポップアップウィンドウを表示します。
• ポップアップウィンドウ内で右クリックするか、ポップアップウィンドウ外をクリックすると、ポップアップウィンドウを閉じます。
• トップレベルウィンドウを中ボタン押しで、終了します。
• Space キー押しで、次にポップアップを表示する時の位置を、以下の２通りから切り替えます。
  [1] ウィンドウ内の黒い矩形の右上位置を基準にする。
  [2] (0, 0) - (1 x 1) の左上位置を基準にする。

#include <stdio.h>
#include <stdlib.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
{
    Surface sf;
    client *cl;
    struct xdg_surface *xdg_surface;
    struct xdg_popup *xdg_popup;
    Toplevel *parent;
}popupwindow;

void popupwindow_destroy(popupwindow *p);


typedef struct
{
    client b;
    
    Toplevel *win;
    popupwindow *popup;
    struct wl_surface *enter_surface;
    int popup_pos;
}client_ex;

#define ANCHOR_X  100
#define ANCHOR_Y  100
#define ANCHOR_W  100
#define ANCHOR_H  80

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


static void _clientex_popup_finish(client_ex *p)
{
    popupwindow_destroy(p->popup);
    p->popup = NULL;
}


//========================
// xdg_surface (popup)
//========================


static void _popup_xdg_surface_configure(
    void *data,struct xdg_surface *surface,uint32_t serial)
{
    printf("[popup] xdg_surface # configure\n");

    xdg_surface_ack_configure(surface, serial);

    surface_update(&((popupwindow *)data)->sf);
}

static const struct xdg_surface_listener g_popup_xdg_surface_listener = {
    _popup_xdg_surface_configure
};


//========================
// xdg_popup
//========================


/* 位置やサイズ変更時
 *
 * サーバーによって位置やサイズが調整される場合がある */

static void _popup_configure(void *data, struct xdg_popup *popup,
    int32_t x, int32_t y, int32_t width, int32_t height)
{
    popupwindow *p = (popupwindow *)data;

    printf("xdg_popup # configure | (%d, %d)-(%d x %d)\n",
        x, y, width, height);

    if(surface_resize(&p->sf, p->cl, width, height))
        imagebuf_fill(p->sf.img, 0xff0000ff);
}

/* ポップアップ終了時 */

static void _popup_done(void *data, struct xdg_popup *popup)
{
    popupwindow *p = (popupwindow *)data;

    printf("xdg_popup # done\n");

    _clientex_popup_finish((client_ex *)p->cl);
}

static const struct xdg_popup_listener g_popup_listener = {
    _popup_configure, _popup_done
};


//========================
// popupwindow
//========================


/* ポップアップ用 xdg_positioner 作成 */

static struct xdg_positioner *_create_popup_positioner(
    client *cl,int w,int h,int pos_point)
{
    struct xdg_positioner *xdgpos;

    //xdg_positioner 作成

    xdgpos = xdg_wm_base_create_positioner(cl->xdg_wm_base);

    //ウィンドウサイズ

    xdg_positioner_set_size(xdgpos, w, h);

    //

    if(pos_point)
    {
        //(0, 0) 左上
        
        xdg_positioner_set_anchor_rect(xdgpos, 0, 0, 1, 1);

        xdg_positioner_set_anchor(xdgpos, XDG_POSITIONER_ANCHOR_TOP_LEFT);
    }
    else
    {
        //黒い矩形の右上
        
        xdg_positioner_set_anchor_rect(xdgpos,
            ANCHOR_X, ANCHOR_Y, ANCHOR_W, ANCHOR_H);

        xdg_positioner_set_anchor(xdgpos, XDG_POSITIONER_ANCHOR_TOP_RIGHT);
    }

    xdg_positioner_set_gravity(xdgpos, XDG_POSITIONER_GRAVITY_BOTTOM_RIGHT);

    //サーバー側で位置やサイズを調整できるようにする

    xdg_positioner_set_constraint_adjustment(xdgpos,
        XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_FLIP_X
        | XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_SLIDE_Y
        | XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_RESIZE_X
        | XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_RESIZE_Y);

    return xdgpos;
}

/* ポップアップウィンドウ作成 */

popupwindow *popupwindow_create(client *cl,Toplevel *parent,
    int width,int height,uint32_t serial,int pos_point)
{
    popupwindow *p;
    struct xdg_positioner *xdgpos;

    p = (popupwindow *)calloc(1, sizeof(popupwindow));
    if(!p) return NULL;

    p->cl = cl;
    p->parent = parent;

    surface_create(&p->sf, cl, width, height);

    imagebuf_fill(p->sf.img, 0xff0000ff);

    //xdg_surface

    p->xdg_surface = xdg_wm_base_get_xdg_surface(cl->xdg_wm_base, p->sf.surface);

    xdg_surface_add_listener(p->xdg_surface, &g_popup_xdg_surface_listener, p);

    //xdg_positioner 作成

    xdgpos = _create_popup_positioner(cl, width, height, pos_point);

    //xdg_popup 作成

    p->xdg_popup = xdg_surface_get_popup(p->xdg_surface,
        parent->xdg_surface, xdgpos);

    xdg_positioner_destroy(xdgpos);

    xdg_popup_add_listener(p->xdg_popup, &g_popup_listener, p);

    //グラブ

    xdg_popup_grab(p->xdg_popup, cl->seat, serial);

    //適用

    wl_surface_commit(p->sf.surface);

    return p;
}

/* 破棄 */

void popupwindow_destroy(popupwindow *p)
{
    if(p)
    {
        xdg_popup_destroy(p->xdg_popup);
        xdg_surface_destroy(p->xdg_surface);

        surface_destroy(&p->sf);
    
        free(p);
    }
}


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


static const char *_get_surface_name(client_ex *p,struct wl_surface *surface)
{
    return (surface == p->win->sf.surface)? "toplevel": "popup";
}


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

    printf("wl_pointer # enter | %s\n", _get_surface_name(p, surface));

    p->enter_surface = surface;

    client_set_cursor(CLIENT(p), serial);
}

static void _pointer_leave(void *data, struct wl_pointer *pointer,
    uint32_t serial, struct wl_surface *surface)
{
    client_ex *p = (client_ex *)data;

    printf("wl_pointer # leave | %s\n", _get_surface_name(p, surface));

    p->enter_surface = NULL;
}

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;
    Toplevel *win;

    printf("wl_pointer # button | %s, serial:%u\n",
        (state == WL_POINTER_BUTTON_STATE_PRESSED)? "press":"release",
        serial);

    if(state != WL_POINTER_BUTTON_STATE_PRESSED)
        return;

    win = p->win;

    //

    if(p->enter_surface == win->sf.surface)
    {
        //トップレベル

        if(p->popup)
            _clientex_popup_finish(p);
        else
        {
            switch(button)
            {
                //左ボタン:ウィンドウ位置移動
                case BTN_LEFT:
                    xdg_toplevel_move(win->xdg_toplevel, p->b.seat, serial);
                    break;
                //右ボタン:ポップアップ表示
                case BTN_RIGHT:
                    printf("-- create popup\n");

                    p->popup = popupwindow_create(CLIENT(p), win, 200, 300,
                        serial, p->popup_pos);
                    break;
                //中ボタン:終了
                case BTN_MIDDLE:
                    p->b.finish_loop = 1;
                    break;
            }
        }
    }
    else
    {
        //ポップアップ
        
        if(button == BTN_RIGHT)
            _clientex_popup_finish(p);
    }
}

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 _keyboard_press(client *cl,uint32_t key,uint32_t serial)
{
    client_ex *p = (client_ex *)cl;

    //Space キーで表示位置を切り替え
    
    if(key == KEY_SPACE)
    {
        p->popup_pos ^= 1;
        printf("# popup pos: %s\n", (p->popup_pos)? "(0,0)": "anchor");
    }
}

/* main */

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

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

    p->b.init_flags = CLIENT_INIT_FLAGS_SEAT | CLIENT_INIT_FLAGS_POINTER
        | CLIENT_INIT_FLAGS_KEYBOARD | CLIENT_INIT_FLAGS_CREATE_CURSOR;

    p->b.pointer_listener = &g_pointer_listener;
    p->b.xdg_shell_need_ver = 3;
    p->b.func_keyboard_key_press = _keyboard_press;

    client_init(CLIENT(p));

    //ウィンドウ

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

    imagebuf_fill(win->sf.img, 0xffff0000);
    imagebuf_box(win->sf.img, 0, 0, 256, 256, 0xff00ff00);
    imagebuf_box(win->sf.img, ANCHOR_X, ANCHOR_Y, ANCHOR_W, ANCHOR_H, 0xff000000);

    //イベントループ

    client_loop_simple(CLIENT(p));

    //解放

    toplevel_destroy(win);

    client_destroy(CLIENT(p));

    return 0;
}

struct xdg_popup_listener {
    void (*configure)(void *data, struct xdg_popup *xdg_popup,
        int32_t x, int32_t y, int32_t width, int32_t height);
    void (*popup_done)(void *data, struct xdg_popup *xdg_popup);
    //ver 3
    void (*repositioned)(void *data, struct xdg_popup *xdg_popup, uint32_t token);
};