vlc_vout_window.h 10.9 KB
Newer Older
1 2 3 4 5 6 7 8 9
/*****************************************************************************
 * vlc_vout_window.h: vout_window_t definitions
 *****************************************************************************
 * Copyright (C) 2008 Rémi Denis-Courmont
 * Copyright (C) 2009 Laurent Aimar
 * $Id$
 *
 * Authors: Laurent Aimar <fenrir _AT_ videolan _DOT_ org>
 *
Jean-Baptiste Kempf's avatar
LGPL  
Jean-Baptiste Kempf committed
10 11 12
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation; either version 2.1 of the License, or
13 14 15 16
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
Jean-Baptiste Kempf's avatar
LGPL  
Jean-Baptiste Kempf committed
17 18
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Lesser General Public License for more details.
19
 *
Jean-Baptiste Kempf's avatar
LGPL  
Jean-Baptiste Kempf committed
20 21 22
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
23 24 25 26 27
 *****************************************************************************/

#ifndef VLC_VOUT_WINDOW_H
#define VLC_VOUT_WINDOW_H 1

28 29 30
#include <stdarg.h>
#include <vlc_common.h>

31
/**
32 33 34 35
 * \defgroup video_window Video window
 * \ingroup video_output
 * Video output window management
 * @{
36
 * \file
37
 * Video output window modules interface
38 39 40 41 42
 */

typedef struct vout_window_t vout_window_t;
typedef struct vout_window_sys_t vout_window_sys_t;

43 44
struct wl_display;
struct wl_surface;
45 46 47 48

/**
 * Window handle type
 */
49 50 51 52 53 54 55
enum vout_window_type {
    VOUT_WINDOW_TYPE_INVALID=0 /**< Invalid or unspecified window type */,
    VOUT_WINDOW_TYPE_XID /**< X11 window */,
    VOUT_WINDOW_TYPE_HWND /**< Win32 or OS/2 window */,
    VOUT_WINDOW_TYPE_NSOBJECT /**< MacOS X view */,
    VOUT_WINDOW_TYPE_ANDROID_NATIVE /**< Android native window */,
    VOUT_WINDOW_TYPE_WAYLAND /**< Wayland surface */,
56 57 58 59 60
};

/**
 * Control query for vout_window_t
 */
61
enum vout_window_control {
62
    VOUT_WINDOW_SET_STATE, /* unsigned state */
63 64
    VOUT_WINDOW_SET_SIZE,   /* unsigned i_width, unsigned i_height */
    VOUT_WINDOW_SET_FULLSCREEN, /* int b_fullscreen */
65
    VOUT_WINDOW_HIDE_MOUSE, /* int b_hide */
66 67
};

68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89
/**
 * Window mouse event type for vout_window_mouse_event_t
 */
enum vout_window_mouse_event_type {
    VOUT_WINDOW_MOUSE_STATE,
    VOUT_WINDOW_MOUSE_MOVED,
    VOUT_WINDOW_MOUSE_PRESSED,
    VOUT_WINDOW_MOUSE_RELEASED,
    VOUT_WINDOW_MOUSE_DOUBLE_CLICK,
};

/**
 * Window mouse event
 */
typedef struct vout_window_mouse_event_t
{
    enum vout_window_mouse_event_type type;
    int x;
    int y;
    int button_mask;
} vout_window_mouse_event_t;

90
typedef struct vout_window_cfg_t {
91
    /* Window handle type */
92
    unsigned type;
93

94 95 96 97
    /* If true, a standalone window is requested */
    bool is_standalone;
    bool is_fullscreen;

98
#ifdef __APPLE__
99 100 101
    /* Window position hint */
    int x;
    int y;
102
#endif
103

104 105 106
    /* Windows size hint */
    unsigned width;
    unsigned height;
107 108 109

} vout_window_cfg_t;

110 111 112
typedef struct vout_window_owner {
    void *sys;
    void (*resized)(vout_window_t *, unsigned width, unsigned height);
113
    void (*closed)(vout_window_t *);
114
    void (*mouse_event)(vout_window_t *, const vout_window_mouse_event_t *mouse);
115 116
} vout_window_owner_t;

117
/**
118 119 120 121 122 123 124 125 126 127 128
 * Graphical window
 *
 * This structure is an abstract interface to the windowing system.
 * The window is normally used to draw video (and subpictures) into, but it
 * can also be used for other purpose (e.g. OpenGL visualization).
 *
 * The window is responsible for providing a window handle, whose exact
 * meaning depends on the windowing system. It also must report some events
 * such as user input (keyboard, mouse) and window resize.
 *
 * Finally, it must support some control requests such as for fullscreen mode.
129 130
 */
struct vout_window_t {
131
    struct vlc_common_members obj;
132

133 134 135 136 137 138 139 140 141 142 143 144 145 146
     /**
      * Window handle type
      *
      * This identified the windowing system and protocol that the window
      * needs to use. This also selects which member of the \ref handle union
      * and the \ref display union are to be set.
      *
      * The possible values are defined in \ref vout_window_type.
      *
      * VOUT_WINDOW_TYPE_INVALID is a special placeholder type. It means that
      * any windowing system is acceptable. In that case, the plugin must set
      * its actual type during activation.
      */
    unsigned type;
147

148 149 150 151
    /**
     * Window handle (mandatory)
     *
     * This must be filled by the plugin upon activation.
152
     *
153 154
     * Depending on the \ref type above, a different member of this union is
     * used.
155 156
     */
    union {
157 158 159 160 161
        void     *hwnd;          /**< Win32 window handle */
        uint32_t xid;            /**< X11 windows ID */
        void     *nsobject;      /**< Mac OSX view object */
        void     *anativewindow; /**< Android native window */
        struct wl_surface *wl;   /**< Wayland surface (client pointer) */
162
    } handle;
163

164 165 166 167 168 169 170 171
    /** Display server (mandatory)
     *
     * This must be filled by the plugin upon activation.
     *
     * The window handle is relative to the display server. The exact meaning
     * of the display server depends on the window handle type. Not all window
     * handle type provide a display server field.
     */
172
    union {
173 174
        char     *x11; /**< X11 display string (NULL = use default) */
        struct wl_display *wl; /**< Wayland display (client pointer) */
175
    } display;
176

177 178 179 180 181
    /**
     * Control callback (mandatory)
     *
     * This callback handles some control request regarding the window.
     * See \ref vout_window_control.
182
     *
183 184
     * This field should not be used directly when manipulating a window.
     * vout_window_Control() should be used instead.
185 186 187
     */
    int (*control)(vout_window_t *, int query, va_list);

188 189 190 191 192
    struct {
        bool has_double_click; /**< Whether double click events are sent,
                                    or need to be emulated */
    } info;

193 194
    /* Private place holder for the vout_window_t module (optional)
     *
195
     * A module is free to use it as it wishes.
196 197
     */
    vout_window_sys_t *sys;
198 199

    vout_window_owner_t owner;
200 201
};

202
/**
Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
203 204 205
 * Creates a new window.
 *
 * @param module plugin name (usually "$window")
206
 * @note If you are inside a "vout display", you must use
Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
207 208
 / vout_display_NewWindow() and vout_display_DeleteWindow() instead.
 * This enables recycling windows.
209
 */
210
VLC_API vout_window_t * vout_window_New(vlc_object_t *, const char *module, const vout_window_cfg_t *, const vout_window_owner_t *);
211 212

/**
Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
213
 * Deletes a window created by vout_window_New().
214
 *
215
 * @note See vout_window_New() about window recycling.
216
 */
217
VLC_API void vout_window_Delete(vout_window_t *);
218

219 220
void vout_window_SetInhibition(vout_window_t *window, bool enabled);

221 222 223 224 225
static inline int vout_window_vaControl(vout_window_t *window, int query,
                                        va_list ap)
{
    return window->control(window, query, ap);
}
Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
226

227
/**
Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
228 229 230
 * Reconfigures a window.
 *
 * @note The vout_window_* wrappers should be used instead of this function.
231
 *
232
 * @warning The caller must own the window, as vout_window_t is not thread safe.
233
 */
234 235 236 237 238 239 240 241 242 243
static inline int vout_window_Control(vout_window_t *window, int query, ...)
{
    va_list ap;
    int ret;

    va_start(ap, query);
    ret = vout_window_vaControl(window, query, ap);
    va_end(ap);
    return ret;
}
244 245

/**
Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
246
 * Configures the window manager state for this window.
247
 */
248
static inline int vout_window_SetState(vout_window_t *window, unsigned state)
249
{
250
    return vout_window_Control(window, VOUT_WINDOW_SET_STATE, state);
251 252 253
}

/**
Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
254
 * Configures the window display (i.e. inner/useful) size.
255
 */
256 257
static inline int vout_window_SetSize(vout_window_t *window,
                                      unsigned width, unsigned height)
258 259 260 261
{
    return vout_window_Control(window, VOUT_WINDOW_SET_SIZE, width, height);
}

262
/**
Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
263
 * Sets fullscreen mode.
264 265 266 267 268 269
 */
static inline int vout_window_SetFullScreen(vout_window_t *window, bool full)
{
    return vout_window_Control(window, VOUT_WINDOW_SET_FULLSCREEN, full);
}

270 271 272 273 274 275 276 277
/**
 * Hide the mouse cursor
 */
static inline int vout_window_HideMouse(vout_window_t *window, bool hide)
{
    return vout_window_Control(window, VOUT_WINDOW_HIDE_MOUSE, hide);
}

278 279 280 281 282 283 284 285 286
/**
 * Report current window size
 *
 * This notifies the user of the window what the pixel dimensions of the
 * window are (or should be, depending on the windowing system).
 *
 * \note This function is thread-safe. In case of concurrent call, it is
 * undefined which one is taken into account (but at least one is).
 */
287 288 289 290 291 292 293
static inline void vout_window_ReportSize(vout_window_t *window,
                                          unsigned width, unsigned height)
{
    if (window->owner.resized != NULL)
        window->owner.resized(window, width, height);
}

294 295 296 297 298 299
static inline void vout_window_ReportClose(vout_window_t *window)
{
    if (window->owner.closed != NULL)
        window->owner.closed(window);
}

300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362
static inline void vout_window_SendMouseEvent(vout_window_t *window,
                                              const vout_window_mouse_event_t *mouse)
{
    if (window->owner.mouse_event != NULL)
        window->owner.mouse_event(window, mouse);
}

/**
 * Send a full mouse state
 *
 * The mouse position must be expressed against window unit. You can use this
 * function of others vout_window_ReportMouse*() functions.
 */
static inline void vout_window_ReportMouseState(vout_window_t *window,
                                                int x, int y, int button_mask)
{
    const vout_window_mouse_event_t mouse = {
        VOUT_WINDOW_MOUSE_STATE, x, y, button_mask
    };
    vout_window_SendMouseEvent(window, &mouse);
}

/**
 * Send a mouse movement
 *
 * The mouse position must be expressed against window unit.
 */
static inline void vout_window_ReportMouseMoved(vout_window_t *window,
                                                int x, int y)
{
    const vout_window_mouse_event_t mouse = {
        VOUT_WINDOW_MOUSE_MOVED, x, y, 0
    };
    vout_window_SendMouseEvent(window, &mouse);
}

/**
 * Send a mouse pressed event
 */
static inline void vout_window_ReportMousePressed(vout_window_t *window,
                                                  int button)
{
    const vout_window_mouse_event_t mouse = {
        VOUT_WINDOW_MOUSE_PRESSED, 0, 0, button,
    };
    vout_window_SendMouseEvent(window, &mouse);
}

/**
 * Send a mouse released event
 */
static inline void vout_window_ReportMouseReleased(vout_window_t *window,
                                                  int button)
{
    const vout_window_mouse_event_t mouse = {
        VOUT_WINDOW_MOUSE_RELEASED, 0, 0, button,
    };
    vout_window_SendMouseEvent(window, &mouse);
}

/**
 * Send a mouse double click event
 */
363 364
static inline void vout_window_ReportMouseDoubleClick(vout_window_t *window,
                                                      int button)
365 366
{
    const vout_window_mouse_event_t mouse = {
367
        VOUT_WINDOW_MOUSE_DOUBLE_CLICK, 0, 0, button,
368 369 370 371
    };
    vout_window_SendMouseEvent(window, &mouse);
}

372
/** @} */
373
#endif /* VLC_VOUT_WINDOW_H */