content.h

Go to the documentation of this file.

/* ========================================================================= */
#ifndef __WLMTK_CONTENT_H__
#define __WLMTK_CONTENT_H__
 
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
 
struct _wlmtk_content_t;
typedef struct _wlmtk_content_t wlmtk_content_t;
struct _wlmtk_fake_content_t;
typedef struct _wlmtk_fake_content_t wlmtk_fake_content_t;
 
#include "container.h"  // IWYU pragma: keep
#include "element.h"
#include "libbase/libbase.h"
#include "popup.h"
#include "surface.h"
#include "util.h"
#include "window.h"  // IWYU pragma: keep
 
struct _wlmtk_content_vmt_t;
 
typedef struct _wlmtk_content_vmt_t wlmtk_content_vmt_t;
;
typedef struct _wlmtk_surface_t wlmtk_surface_t;
 
;
typedef struct _wlmtk_fake_surface_t wlmtk_fake_surface_t;
 
#ifdef __cplusplus
extern "C" {
#endif  // __cplusplus
 
struct _wlmtk_content_vmt_t {
    uint32_t (*request_maximized)(wlmtk_content_t *content_ptr,
                                  bool maximized);
 
    uint32_t (*request_fullscreen)(wlmtk_content_t *content_ptr,
                                   bool fullscreen);
 
    uint32_t (*request_size)(wlmtk_content_t *content_ptr,
                             int width,
                             int height);
 
    void (*request_close)(wlmtk_content_t *content_ptr);
 
    void (*set_activated)(wlmtk_content_t *content_ptr, bool activated);
};
 
struct _wlmtk_content_t {
    wlmtk_container_t         super_container;
    wlmtk_content_vmt_t       vmt;
 
    wlmtk_element_vmt_t       orig_super_element_vmt;
 
    // TODO(kaeser@gubbe.ch): Re-think whether this better be part of window?
    // To consider: positioning relative to window's content *is* desirable.
    wlmtk_container_t         popup_container;
 
    wlmtk_element_t           *element_ptr;
    wlmtk_window_t            *window_ptr;
 
    // TODO(kaeser@gubbe.ch): Should not be stored here & this way.
    wlmtk_util_client_t       client;
 
    wlmtk_content_t           *parent_content_ptr;
 
    int                       committed_width;
    int                       committed_height;
 
    bs_dllist_t               popups;
    bs_dllist_node_t          dlnode;
};
 
bool wlmtk_content_init(
    wlmtk_content_t *content_ptr,
    wlmtk_element_t *element_ptr);
 
void wlmtk_content_fini(
    wlmtk_content_t *content_ptr);
 
void wlmtk_content_set_element(
    wlmtk_content_t *content_ptr,
    wlmtk_element_t *element_ptr);
 
wlmtk_content_vmt_t wlmtk_content_extend(
    wlmtk_content_t *content_ptr,
    const wlmtk_content_vmt_t *content_vmt_ptr);
 
static inline uint32_t wlmtk_content_request_maximized(
    wlmtk_content_t *content_ptr,
    bool maximized) {
    // Guard clause, if method isn't implemented.
    if (NULL == content_ptr->vmt.request_maximized) return 0;
    return content_ptr->vmt.request_maximized(content_ptr, maximized);
}
 
static inline uint32_t wlmtk_content_request_fullscreen(
    wlmtk_content_t *content_ptr,
    bool fullscreen) {
    // Guard clause, if method isn't implemented.
    if (NULL == content_ptr->vmt.request_fullscreen) return 0;
    return content_ptr->vmt.request_fullscreen(content_ptr, fullscreen);
}
 
static inline uint32_t wlmtk_content_request_size(
    wlmtk_content_t *content_ptr,
    int width,
    int height) {
    // Guard clause, if method isn't implemented.
    if (NULL == content_ptr->vmt.request_size) return 0;
    return content_ptr->vmt.request_size(content_ptr, width, height);
}
 
static inline void wlmtk_content_request_close(wlmtk_content_t *content_ptr) {
    // Guard clause, if method isn't implemented.
    if (NULL == content_ptr->vmt.request_close) return;
    return content_ptr->vmt.request_close(content_ptr);
}
 
static inline void wlmtk_content_set_activated(
    wlmtk_content_t *content_ptr,
    bool activated) {
    // Guard clause, if method isn't implemented.
    if (NULL == content_ptr->vmt.set_activated) return;
    content_ptr->vmt.set_activated(content_ptr, activated);
}
 
 
void wlmtk_content_set_window(
    wlmtk_content_t *content_ptr,
    wlmtk_window_t *window_ptr);
 
void wlmtk_content_get_size(
    wlmtk_content_t *content_ptr,
    int *width_ptr,
    int *height_ptr);
 
void wlmtk_content_commit(
    wlmtk_content_t *content_ptr,
    int width,
    int height,
    uint32_t serial);
 
wlmtk_element_t *wlmtk_content_element(wlmtk_content_t *content_ptr);
 
void wlmtk_content_add_popup(
    wlmtk_content_t *content_ptr,
    wlmtk_content_t *popup_content_ptr);
 
void wlmtk_content_remove_popup(
    wlmtk_content_t *content_ptr,
    wlmtk_content_t *popup_content_ptr);
 
void wlmtk_content_add_wlmtk_popup(
    wlmtk_content_t *content_ptr,
    wlmtk_popup_t *popup_ptr);
 
void wlmtk_content_remove_wlmtk_popup(
    wlmtk_content_t *content_ptr,
    wlmtk_popup_t *popup_ptr);
 
wlmtk_content_t *wlmtk_content_get_parent_content(
    wlmtk_content_t *content_ptr);
 
extern const bs_test_case_t wlmtk_content_test_cases[];
 
struct _wlmtk_fake_content_t {
    wlmtk_content_t           content;
    wlmtk_fake_surface_t      *fake_surface_ptr;
 
    bool                      request_close_called;
 
    uint32_t                  serial;
    int                       requested_width;
    int                       requested_height;
    bool                      activated;
};
 
wlmtk_fake_content_t *wlmtk_fake_content_create(
    wlmtk_fake_surface_t *fake_surface_ptr);
void wlmtk_fake_content_destroy(wlmtk_fake_content_t *fake_content_ptr);
void wlmtk_fake_content_commit(wlmtk_fake_content_t *fake_content_ptr);
 
#ifdef __cplusplus
}  // extern "C"
#endif  // __cplusplus
 
#endif /* __WLMTK_CONTENT_H__ */
/* == End of content.h ===================================================== */