pugl.h

Go to the documentation of this file.

// Copyright 2012-2022 David Robillard <d@drobilla.net>
// SPDX-License-Identifier: ISC
 
#ifndef PUGL_PUGL_H
#define PUGL_PUGL_H
 
#include <stddef.h>
#include <stdint.h>
 
#ifndef __cplusplus
#  include <stdbool.h>
#endif
 
#ifndef PUGL_API
#  if defined(_WIN32) && !defined(PUGL_STATIC) && defined(PUGL_INTERNAL)
#    define PUGL_API __declspec(dllexport)
#  elif defined(_WIN32) && !defined(PUGL_STATIC)
#    define PUGL_API __declspec(dllimport)
#  elif defined(__GNUC__)
#    define PUGL_API __attribute__((visibility("default")))
#  else
#    define PUGL_API
#  endif
#endif
 
#ifndef PUGL_DISABLE_DEPRECATED
#  if defined(__clang__)
#    define PUGL_DEPRECATED_BY(rep) __attribute__((deprecated("", rep)))
#  elif defined(__GNUC__)
#    define PUGL_DEPRECATED_BY(rep) __attribute__((deprecated("Use " rep)))
#  else
#    define PUGL_DEPRECATED_BY(rep)
#  endif
#endif
 
#if defined(__GNUC__)
#  define PUGL_CONST_FUNC __attribute__((const))
#else
#  define PUGL_CONST_FUNC
#endif
 
#define PUGL_CONST_API \
  PUGL_API             \
  PUGL_CONST_FUNC
 
#define PUGL_BEGIN_DECLS
#define PUGL_END_DECLS
 
PUGL_BEGIN_DECLS


typedef int16_t PuglCoord;

typedef uint16_t PuglSpan;

typedef struct {
  PuglCoord x;
  PuglCoord y;
  PuglSpan  width;
  PuglSpan  height;
} PuglRect;


typedef enum {
  PUGL_MOD_SHIFT = 1u << 0u, 
  PUGL_MOD_CTRL  = 1u << 1u, 
  PUGL_MOD_ALT   = 1u << 2u, 
  PUGL_MOD_SUPER = 1u << 3u  
} PuglMod;

typedef uint32_t PuglMods;

typedef enum {
  // ASCII control codes
  PUGL_KEY_BACKSPACE = 0x08,
  PUGL_KEY_ESCAPE    = 0x1B,
  PUGL_KEY_DELETE    = 0x7F,
 
  // Unicode Private Use Area
  PUGL_KEY_F1 = 0xE000,
  PUGL_KEY_F2,
  PUGL_KEY_F3,
  PUGL_KEY_F4,
  PUGL_KEY_F5,
  PUGL_KEY_F6,
  PUGL_KEY_F7,
  PUGL_KEY_F8,
  PUGL_KEY_F9,
  PUGL_KEY_F10,
  PUGL_KEY_F11,
  PUGL_KEY_F12,
  PUGL_KEY_LEFT,
  PUGL_KEY_UP,
  PUGL_KEY_RIGHT,
  PUGL_KEY_DOWN,
  PUGL_KEY_PAGE_UP,
  PUGL_KEY_PAGE_DOWN,
  PUGL_KEY_HOME,
  PUGL_KEY_END,
  PUGL_KEY_INSERT,
  PUGL_KEY_SHIFT,
  PUGL_KEY_SHIFT_L = PUGL_KEY_SHIFT,
  PUGL_KEY_SHIFT_R,
  PUGL_KEY_CTRL,
  PUGL_KEY_CTRL_L = PUGL_KEY_CTRL,
  PUGL_KEY_CTRL_R,
  PUGL_KEY_ALT,
  PUGL_KEY_ALT_L = PUGL_KEY_ALT,
  PUGL_KEY_ALT_R,
  PUGL_KEY_SUPER,
  PUGL_KEY_SUPER_L = PUGL_KEY_SUPER,
  PUGL_KEY_SUPER_R,
  PUGL_KEY_MENU,
  PUGL_KEY_CAPS_LOCK,
  PUGL_KEY_SCROLL_LOCK,
  PUGL_KEY_NUM_LOCK,
  PUGL_KEY_PRINT_SCREEN,
  PUGL_KEY_PAUSE
} PuglKey;

typedef enum {
  PUGL_NOTHING,        
  PUGL_CREATE,         
  PUGL_DESTROY,        
  PUGL_CONFIGURE,      
  PUGL_MAP,            
  PUGL_UNMAP,          
  PUGL_UPDATE,         
  PUGL_EXPOSE,         
  PUGL_CLOSE,          
  PUGL_FOCUS_IN,       
  PUGL_FOCUS_OUT,      
  PUGL_KEY_PRESS,      
  PUGL_KEY_RELEASE,    
  PUGL_TEXT,           
  PUGL_POINTER_IN,     
  PUGL_POINTER_OUT,    
  PUGL_BUTTON_PRESS,   
  PUGL_BUTTON_RELEASE, 
  PUGL_MOTION,         
  PUGL_SCROLL,         
  PUGL_CLIENT,         
  PUGL_TIMER,          
  PUGL_LOOP_ENTER,     
  PUGL_LOOP_LEAVE,     
  PUGL_DATA_OFFER,     
  PUGL_DATA,           
} PuglEventType;

typedef enum {
  PUGL_IS_SEND_EVENT = 1, 
  PUGL_IS_HINT       = 2  
} PuglEventFlag;

typedef uint32_t PuglEventFlags;

typedef enum {
  PUGL_CROSSING_NORMAL, 
  PUGL_CROSSING_GRAB,   
  PUGL_CROSSING_UNGRAB  
} PuglCrossingMode;

typedef enum {
  PUGL_SCROLL_UP,    
  PUGL_SCROLL_DOWN,  
  PUGL_SCROLL_LEFT,  
  PUGL_SCROLL_RIGHT, 
  PUGL_SCROLL_SMOOTH 
} PuglScrollDirection;

typedef struct {
  PuglEventType  type;  
  PuglEventFlags flags; 
} PuglAnyEvent;

typedef PuglAnyEvent PuglCreateEvent;

typedef PuglAnyEvent PuglDestroyEvent;

typedef struct {
  PuglEventType  type;   
  PuglEventFlags flags;  
  PuglCoord      x;      
  PuglCoord      y;      
  PuglSpan       width;  
  PuglSpan       height; 
} PuglConfigureEvent;

typedef PuglAnyEvent PuglMapEvent;

typedef PuglAnyEvent PuglUnmapEvent;

typedef PuglAnyEvent PuglUpdateEvent;

typedef struct {
  PuglEventType  type;   
  PuglEventFlags flags;  
  PuglCoord      x;      
  PuglCoord      y;      
  PuglSpan       width;  
  PuglSpan       height; 
} PuglExposeEvent;

typedef PuglAnyEvent PuglCloseEvent;

typedef struct {
  PuglEventType    type;  
  PuglEventFlags   flags; 
  PuglCrossingMode mode;  
} PuglFocusEvent;

typedef struct {
  PuglEventType  type;    
  PuglEventFlags flags;   
  double         time;    
  double         x;       
  double         y;       
  double         xRoot;   
  double         yRoot;   
  PuglMods       state;   
  uint32_t       keycode; 
  uint32_t       key;     
} PuglKeyEvent;

typedef struct {
  PuglEventType  type;      
  PuglEventFlags flags;     
  double         time;      
  double         x;         
  double         y;         
  double         xRoot;     
  double         yRoot;     
  PuglMods       state;     
  uint32_t       keycode;   
  uint32_t       character; 
  char           string[8]; 
} PuglTextEvent;

typedef struct {
  PuglEventType    type;  
  PuglEventFlags   flags; 
  double           time;  
  double           x;     
  double           y;     
  double           xRoot; 
  double           yRoot; 
  PuglMods         state; 
  PuglCrossingMode mode;  
} PuglCrossingEvent;

typedef struct {
  PuglEventType  type;   
  PuglEventFlags flags;  
  double         time;   
  double         x;      
  double         y;      
  double         xRoot;  
  double         yRoot;  
  PuglMods       state;  
  uint32_t       button; 
} PuglButtonEvent;

typedef struct {
  PuglEventType  type;  
  PuglEventFlags flags; 
  double         time;  
  double         x;     
  double         y;     
  double         xRoot; 
  double         yRoot; 
  PuglMods       state; 
} PuglMotionEvent;

typedef struct {
  PuglEventType       type;      
  PuglEventFlags      flags;     
  double              time;      
  double              x;         
  double              y;         
  double              xRoot;     
  double              yRoot;     
  PuglMods            state;     
  PuglScrollDirection direction; 
  double              dx;        
  double              dy;        
} PuglScrollEvent;

typedef struct {
  PuglEventType  type;  
  PuglEventFlags flags; 
  uintptr_t      data1; 
  uintptr_t      data2; 
} PuglClientEvent;

typedef struct {
  PuglEventType  type;  
  PuglEventFlags flags; 
  uintptr_t      id;    
} PuglTimerEvent;

typedef struct {
  PuglEventType  type;  
  PuglEventFlags flags; 
  double         time;  
} PuglDataOfferEvent;

typedef struct {
  PuglEventType  type;      
  PuglEventFlags flags;     
  double         time;      
  uint32_t       typeIndex; 
} PuglDataEvent;

typedef PuglAnyEvent PuglLoopEnterEvent;

typedef PuglAnyEvent PuglLoopLeaveEvent;

typedef union {
  PuglAnyEvent       any;       
  PuglEventType      type;      
  PuglButtonEvent    button;    
  PuglConfigureEvent configure; 
  PuglExposeEvent    expose;    
  PuglKeyEvent       key;       
  PuglTextEvent      text;      
  PuglCrossingEvent  crossing;  
  PuglMotionEvent    motion;    
  PuglScrollEvent    scroll;    
  PuglFocusEvent     focus;     
  PuglClientEvent    client;    
  PuglTimerEvent     timer;     
  PuglDataOfferEvent offer;     
  PuglDataEvent      data;      
} PuglEvent;


typedef enum {
  PUGL_SUCCESS,               
  PUGL_FAILURE,               
  PUGL_UNKNOWN_ERROR,         
  PUGL_BAD_BACKEND,           
  PUGL_BAD_CONFIGURATION,     
  PUGL_BAD_PARAMETER,         
  PUGL_BACKEND_FAILED,        
  PUGL_REGISTRATION_FAILED,   
  PUGL_REALIZE_FAILED,        
  PUGL_SET_FORMAT_FAILED,     
  PUGL_CREATE_CONTEXT_FAILED, 
  PUGL_UNSUPPORTED,           
  PUGL_NO_MEMORY,             
} PuglStatus;

PUGL_CONST_API
const char*
puglStrerror(PuglStatus status);


typedef struct PuglWorldImpl PuglWorld;

typedef void* PuglWorldHandle;

typedef enum {
  PUGL_PROGRAM, 
  PUGL_MODULE   
} PuglWorldType;

typedef enum {
  PUGL_WORLD_THREADS = 1u << 0u
} PuglWorldFlag;

typedef uint32_t PuglWorldFlags;

PUGL_API
PuglWorld*
puglNewWorld(PuglWorldType type, PuglWorldFlags flags);

PUGL_API
void
puglFreeWorld(PuglWorld* world);

PUGL_API
void
puglSetWorldHandle(PuglWorld* world, PuglWorldHandle handle);

PUGL_API
PuglWorldHandle
puglGetWorldHandle(PuglWorld* world);

PUGL_API
void*
puglGetNativeWorld(PuglWorld* world);

PUGL_API
PuglStatus
puglSetClassName(PuglWorld* world, const char* name);

PUGL_API
const char*
puglGetClassName(const PuglWorld* world);

PUGL_API
double
puglGetTime(const PuglWorld* world);

PUGL_API
PuglStatus
puglUpdate(PuglWorld* world, double timeout);


typedef struct PuglViewImpl PuglView;

typedef struct PuglBackendImpl PuglBackend;

typedef uintptr_t PuglNativeView;

typedef void* PuglHandle;

typedef enum {
  PUGL_USE_COMPAT_PROFILE,    
  PUGL_USE_DEBUG_CONTEXT,     
  PUGL_CONTEXT_VERSION_MAJOR, 
  PUGL_CONTEXT_VERSION_MINOR, 
  PUGL_RED_BITS,              
  PUGL_GREEN_BITS,            
  PUGL_BLUE_BITS,             
  PUGL_ALPHA_BITS,            
  PUGL_DEPTH_BITS,            
  PUGL_STENCIL_BITS,          
  PUGL_SAMPLES,               
  PUGL_DOUBLE_BUFFER,         
  PUGL_SWAP_INTERVAL,         
  PUGL_RESIZABLE,             
  PUGL_IGNORE_KEY_REPEAT,     
  PUGL_REFRESH_RATE,          
} PuglViewHint;

#define PUGL_NUM_VIEW_HINTS ((unsigned)PUGL_REFRESH_RATE + 1u)

typedef enum {
  PUGL_DONT_CARE = -1, 
  PUGL_FALSE     = 0,  
  PUGL_TRUE      = 1   
} PuglViewHintValue;

typedef enum {
  PUGL_DEFAULT_SIZE, 
  PUGL_MIN_SIZE,     
  PUGL_MAX_SIZE,     

  PUGL_FIXED_ASPECT,

  PUGL_MIN_ASPECT,

  PUGL_MAX_ASPECT
} PuglSizeHint;

#define PUGL_NUM_SIZE_HINTS ((unsigned)PUGL_MAX_ASPECT + 1u)

typedef PuglStatus (*PuglEventFunc)(PuglView* view, const PuglEvent* event);


PUGL_API
PuglView*
puglNewView(PuglWorld* world);

PUGL_API
void
puglFreeView(PuglView* view);

PUGL_API
PuglWorld*
puglGetWorld(PuglView* view);

PUGL_API
void
puglSetHandle(PuglView* view, PuglHandle handle);

PUGL_API
PuglHandle
puglGetHandle(PuglView* view);

PUGL_API
PuglStatus
puglSetBackend(PuglView* view, const PuglBackend* backend);

const PuglBackend*
puglGetBackend(const PuglView* view);

PUGL_API
PuglStatus
puglSetEventFunc(PuglView* view, PuglEventFunc eventFunc);

PUGL_API
PuglStatus
puglSetViewHint(PuglView* view, PuglViewHint hint, int value);

PUGL_API
int
puglGetViewHint(const PuglView* view, PuglViewHint hint);

PUGL_API
double
puglGetScaleFactor(const PuglView* view);


PUGL_API
PuglRect
puglGetFrame(const PuglView* view);

PUGL_API
PuglStatus
puglSetFrame(PuglView* view, PuglRect frame);

PUGL_API
PuglStatus
puglSetPosition(PuglView* view, int x, int y);

PUGL_API
PuglStatus
puglSetSize(PuglView* view, unsigned width, unsigned height);

PUGL_API
PuglStatus
puglSetSizeHint(PuglView*    view,
                PuglSizeHint hint,
                PuglSpan     width,
                PuglSpan     height);


PUGL_API
PuglStatus
puglSetWindowTitle(PuglView* view, const char* title);

PUGL_API
const char*
puglGetWindowTitle(const PuglView* view);

PUGL_API
PuglStatus
puglSetParentWindow(PuglView* view, PuglNativeView parent);

PUGL_API
PuglNativeView
puglGetParentWindow(const PuglView* view);

PUGL_API
PuglStatus
puglSetTransientParent(PuglView* view, PuglNativeView parent);

PUGL_API
PuglNativeView
puglGetTransientParent(const PuglView* view);

PUGL_API
PuglStatus
puglRealize(PuglView* view);

PUGL_API
PuglStatus
puglShow(PuglView* view);

PUGL_API
PuglStatus
puglHide(PuglView* view);

PUGL_API
bool
puglGetVisible(const PuglView* view);

PUGL_API
PuglNativeView
puglGetNativeView(PuglView* view);


PUGL_API
void*
puglGetContext(PuglView* view);

PUGL_API
PuglStatus
puglPostRedisplay(PuglView* view);

PUGL_API
PuglStatus
puglPostRedisplayRect(PuglView* view, PuglRect rect);


typedef enum {
  PUGL_CURSOR_ARROW,         
  PUGL_CURSOR_CARET,         
  PUGL_CURSOR_CROSSHAIR,     
  PUGL_CURSOR_HAND,          
  PUGL_CURSOR_NO,            
  PUGL_CURSOR_LEFT_RIGHT,    
  PUGL_CURSOR_UP_DOWN,       
  PUGL_CURSOR_DIAGONAL,      
  PUGL_CURSOR_ANTI_DIAGONAL, 
} PuglCursor;

#define PUGL_NUM_CURSORS ((unsigned)PUGL_CURSOR_ANTI_DIAGONAL + 1u)

PUGL_API
PuglStatus
puglGrabFocus(PuglView* view);

PUGL_API
bool
puglHasFocus(const PuglView* view);

PUGL_API
PuglStatus
puglPaste(PuglView* view);

PUGL_API
uint32_t
puglGetNumClipboardTypes(const PuglView* view);

PUGL_API
const char*
puglGetClipboardType(const PuglView* view, uint32_t typeIndex);

PUGL_API
PuglStatus
puglAcceptOffer(PuglView*                 view,
                const PuglDataOfferEvent* offer,
                uint32_t                  typeIndex);

PUGL_API
PuglStatus
puglSetClipboard(PuglView*   view,
                 const char* type,
                 const void* data,
                 size_t      len);

PUGL_API
const void*
puglGetClipboard(PuglView* view, uint32_t typeIndex, size_t* len);

PUGL_API
PuglStatus
puglSetCursor(PuglView* view, PuglCursor cursor);

PUGL_API
PuglStatus
puglRequestAttention(PuglView* view);

PUGL_API
PuglStatus
puglStartTimer(PuglView* view, uintptr_t id, double timeout);

PUGL_API
PuglStatus
puglStopTimer(PuglView* view, uintptr_t id);

PUGL_API
PuglStatus
puglSendEvent(PuglView* view, const PuglEvent* event);

 
#ifndef PUGL_DISABLE_DEPRECATED

 
PUGL_DEPRECATED_BY("PuglCreateEvent")
typedef PuglCreateEvent PuglEventCreate;
 
PUGL_DEPRECATED_BY("PuglDestroyEvent")
typedef PuglDestroyEvent PuglEventDestroy;
 
PUGL_DEPRECATED_BY("PuglConfigureEvent")
typedef PuglConfigureEvent PuglEventConfigure;
 
PUGL_DEPRECATED_BY("PuglMapEvent")
typedef PuglMapEvent PuglEventMap;
 
PUGL_DEPRECATED_BY("PuglUnmapEvent")
typedef PuglUnmapEvent PuglEventUnmap;
 
PUGL_DEPRECATED_BY("PuglUpdateEvent")
typedef PuglUpdateEvent PuglEventUpdate;
 
PUGL_DEPRECATED_BY("PuglExposeEvent")
typedef PuglExposeEvent PuglEventExpose;
 
PUGL_DEPRECATED_BY("PuglCloseEvent")
typedef PuglCloseEvent PuglEventClose;
 
PUGL_DEPRECATED_BY("PuglFocusEvent")
typedef PuglFocusEvent PuglEventFocus;
 
PUGL_DEPRECATED_BY("PuglKeyEvent")
typedef PuglKeyEvent PuglEventKey;
 
PUGL_DEPRECATED_BY("PuglTextEvent")
typedef PuglTextEvent PuglEventText;
 
PUGL_DEPRECATED_BY("PuglCrossingEvent")
typedef PuglCrossingEvent PuglEventCrossing;
 
PUGL_DEPRECATED_BY("PuglButtonEvent")
typedef PuglButtonEvent PuglEventButton;
 
PUGL_DEPRECATED_BY("PuglMotionEvent")
typedef PuglMotionEvent PuglEventMotion;
 
PUGL_DEPRECATED_BY("PuglScrollEvent")
typedef PuglScrollEvent PuglEventScroll;
 
PUGL_DEPRECATED_BY("PuglClientEvent")
typedef PuglClientEvent PuglEventClient;
 
PUGL_DEPRECATED_BY("PuglTimerEvent")
typedef PuglTimerEvent PuglEventTimer;
 
PUGL_DEPRECATED_BY("PuglLoopEnterEvent")
typedef PuglLoopEnterEvent PuglEventLoopEnter;
 
PUGL_DEPRECATED_BY("PuglLoopLeaveEvent")
typedef PuglLoopLeaveEvent PuglEventLoopLeave;

PUGL_DEPRECATED_BY("PuglNativeView")
typedef uintptr_t PuglNativeWindow;

static inline PUGL_DEPRECATED_BY("puglNewView")
PuglView*
puglInit(const int* pargc, char** argv)
{
  (void)pargc;
  (void)argv;
 
  return puglNewView(puglNewWorld(PUGL_MODULE, 0));
}

static inline PUGL_DEPRECATED_BY("puglFreeView")
void
puglDestroy(PuglView* view)
{
  PuglWorld* const world = puglGetWorld(view);
 
  puglFreeView(view);
  puglFreeWorld(world);
}

static inline PUGL_DEPRECATED_BY("puglSetClassName")
void
puglInitWindowClass(PuglView* view, const char* name)
{
  puglSetClassName(puglGetWorld(view), name);
}

static inline PUGL_DEPRECATED_BY("puglSetFrame")
void
puglInitWindowSize(PuglView* view, int width, int height)
{
  PuglRect frame = puglGetFrame(view);
 
  frame.width  = (PuglSpan)width;
  frame.height = (PuglSpan)height;
 
  puglSetFrame(view, frame);
}

static inline PUGL_DEPRECATED_BY("puglSetMinSize")
void
puglInitWindowMinSize(PuglView* view, int width, int height)
{
  puglSetSizeHint(view, PUGL_MIN_SIZE, (PuglSpan)width, (PuglSpan)height);
}

static inline PUGL_DEPRECATED_BY("puglSetAspectRatio")
void
puglInitWindowAspectRatio(PuglView* view,
                          int       minX,
                          int       minY,
                          int       maxX,
                          int       maxY)
{
  puglSetSizeHint(view, PUGL_MIN_ASPECT, (PuglSpan)minX, (PuglSpan)minY);
  puglSetSizeHint(view, PUGL_MAX_ASPECT, (PuglSpan)maxX, (PuglSpan)maxY);
}

static inline PUGL_DEPRECATED_BY("puglSetTransientParent")
void
puglInitTransientFor(PuglView* view, uintptr_t parent)
{
  puglSetTransientParent(view, (PuglNativeWindow)parent);
}

static inline PUGL_DEPRECATED_BY("puglSetTransientParent")
PuglStatus
puglSetTransientFor(PuglView* view, uintptr_t parent)
{
  return puglSetTransientParent(view, (PuglNativeWindow)parent);
}

static inline PUGL_DEPRECATED_BY("puglSetViewHint")
void
puglInitResizable(PuglView* view, bool resizable)
{
  puglSetViewHint(view, PUGL_RESIZABLE, resizable);
}

static inline PUGL_DEPRECATED_BY("puglGetFrame")
void
puglGetSize(PuglView* view, int* width, int* height)
{
  const PuglRect frame = puglGetFrame(view);
 
  *width  = (int)frame.width;
  *height = (int)frame.height;
}

static inline PUGL_DEPRECATED_BY("puglSetViewHint")
void
puglIgnoreKeyRepeat(PuglView* view, bool ignore)
{
  puglSetViewHint(view, PUGL_IGNORE_KEY_REPEAT, ignore);
}

static inline PUGL_DEPRECATED_BY("puglSetViewHint")
void
puglInitWindowHint(PuglView* view, PuglViewHint hint, int value)
{
  puglSetViewHint(view, hint, value);
}

static inline PUGL_DEPRECATED_BY("puglSetParentWindow")
void
puglInitWindowParent(PuglView* view, PuglNativeWindow parent)
{
  puglSetParentWindow(view, parent);
}

static inline PUGL_DEPRECATED_BY("puglSetBackend")
int
puglInitBackend(PuglView* view, const PuglBackend* backend)
{
  return (int)puglSetBackend(view, backend);
}

static inline PUGL_DEPRECATED_BY("puglRealize")
PuglStatus
puglCreateWindow(PuglView* view, const char* title)
{
  puglSetWindowTitle(view, title);
  return puglRealize(view);
}

PUGL_API
PUGL_DEPRECATED_BY("puglPollEvents")
PuglStatus
puglWaitForEvent(PuglView* view);

PUGL_API
PUGL_DEPRECATED_BY("puglDispatchEvents")
PuglStatus
puglProcessEvents(PuglView* view);

static inline PUGL_DEPRECATED_BY("puglUpdate")
PuglStatus
puglPollEvents(PuglWorld* world, double timeout)
{
  return puglUpdate(world, timeout);
}

static inline PUGL_DEPRECATED_BY("puglUpdate")
PuglStatus
puglDispatchEvents(PuglWorld* world)
{
  return puglUpdate(world, 0.0);
}
 
static inline PUGL_DEPRECATED_BY("puglShow")
PuglStatus
puglShowWindow(PuglView* view)
{
  return puglShow(view);
}
 
static inline PUGL_DEPRECATED_BY("puglHide")
PuglStatus
puglHideWindow(PuglView* view)
{
  return puglHide(view);
}

static inline PUGL_DEPRECATED_BY("puglSetSizeHint")
PuglStatus
puglSetDefaultSize(PuglView* view, int width, int height)
{
  return puglSetSizeHint(
    view, PUGL_DEFAULT_SIZE, (PuglSpan)width, (PuglSpan)height);
}

static inline PUGL_DEPRECATED_BY("puglSetSizeHint")
PuglStatus
puglSetMinSize(PuglView* view, int width, int height)
{
  return puglSetSizeHint(
    view, PUGL_MIN_SIZE, (PuglSpan)width, (PuglSpan)height);
}

static inline PUGL_DEPRECATED_BY("puglSetSizeHint")
PuglStatus
puglSetMaxSize(PuglView* view, int width, int height)
{
  return puglSetSizeHint(
    view, PUGL_MAX_SIZE, (PuglSpan)width, (PuglSpan)height);
}

static inline PUGL_DEPRECATED_BY("puglSetSizeHint")
PuglStatus
puglSetAspectRatio(PuglView* view, int minX, int minY, int maxX, int maxY)
{
  const PuglStatus st0 =
    puglSetSizeHint(view, PUGL_MIN_ASPECT, (PuglSpan)minX, (PuglSpan)minY);
 
  const PuglStatus st1 =
    puglSetSizeHint(view, PUGL_MAX_ASPECT, (PuglSpan)maxX, (PuglSpan)maxY);
 
  return st0 ? st0 : st1;
}

static inline PUGL_DEPRECATED_BY("puglGetNativeView")
PuglNativeView
puglGetNativeWindow(PuglView* view)
{
  return puglGetNativeView(view);
}
 
#endif // PUGL_DISABLE_DEPRECATED

 
PUGL_END_DECLS
 
#endif // PUGL_PUGL_H