tgi.h

浏览该文件的文档.

 
#ifndef TGI_H
#define TGI_H
 
#include <stdarg.h>
 
#define TGIAPI __stdcall
#define TGICB TGIAPI
 
typedef enum TGI_Backend
{
    TGI_BACKEND_GDI
} TGI_Backend;
 
typedef enum TGI_Encoding
{
    TGI_ENCODING_UTF8,
    TGI_ENCODING_ANSI
} TGI_Encoding;
 
typedef struct TGI_Application
{
    const struct vtable_TGI_Application_t *vptr;
} TGI_Application;
 
typedef struct TGI_Window
{
    const struct vtable_TGI_Window_t *vptr;
} TGI_Window;
typedef enum TGI_WindowStyle
{
    TGI_WINDOWSTYLE_WINDOW = 0,
    TGI_WINDOWSTYLE_BORDER = 1,
    TGI_WINDOWSTYLE_CAPTION = 2,
    TGI_WINDOWSTYLE_RESIZE = 4,
    TGI_WINDOWSTYLE_MINIMIZEBOX = 8,
    TGI_WINDOWSTYLE_MAXIMIZEBOX = 16,
    TGI_WINDOWSTYLE_DEFAULT = TGI_WINDOWSTYLE_WINDOW | TGI_WINDOWSTYLE_BORDER | TGI_WINDOWSTYLE_CAPTION |
                              TGI_WINDOWSTYLE_RESIZE | TGI_WINDOWSTYLE_MINIMIZEBOX | TGI_WINDOWSTYLE_MAXIMIZEBOX,
} TGI_WindowStyle;
 
typedef struct TGI_Graphics
{
    const struct vtable_TGI_Graphics_t *vptr;
} TGI_Graphics;
 
typedef struct TGI_Image
{
    const struct vtable_TGI_Image_t *vptr;
} TGI_Image;
 
typedef struct TGI_Font
{
    const struct vtable_TGI_Font_t *vptr;
} TGI_Font;
typedef enum TGI_FontStyle
{
    TGI_FONTSTYLE_REGULAR = 0,
    TGI_FONTSTYLE_BOLD = 1,
    TGI_FONTSTYLE_ITALIC = 2,
    TGI_FONTSTYLE_UNDERLINE = 4,
    TGI_FONTSTYLE_STRIKEOUT = 8
} TGI_FontStyle;
typedef enum TGI_TextAlign
{
    TGI_TEXTALIGN_LEFT = 0,
    TGI_TEXTALIGN_CENTER = 1,
    TGI_TEXTALIGN_RIGHT = 2,
    TGI_TEXTALIGN_TOP = TGI_TEXTALIGN_LEFT,
    TGI_TEXTALIGN_BOTTOM = TGI_TEXTALIGN_RIGHT
} TGI_TextAlign;
 
typedef struct TGI_Timer
{
    const struct vtable_TGI_Timer_t *vptr;
} TGI_Timer;
 
typedef unsigned int TGI_Color;
#define TGI_COLOR(a, r, g, b)                                                                                          \
    ((((TGI_Color)(a)) << 24) | (((TGI_Color)(r)) << 16) | (((TGI_Color)(g)) << 8) | ((TGI_Color)(b)))
static inline TGI_Color TGIAPI tgi_color(unsigned char a, unsigned char r, unsigned char g, unsigned char b)
{
    return TGI_COLOR(a, r, g, b);
}
 
typedef struct TGI_Point
{
    float x, y;
} TGI_Point;
 
typedef struct TGI_Rect
{
    float left, right, top, bottom;
} TGI_Rect;
 
typedef struct TGI_KeyEvent
{
    enum
    {
        TGI_KEYEVENT_DOWN,
        TGI_KEYEVENT_UP,
        TGI_KEYEVENT_INPUT,
    } type;
    char *key;
} TGI_KeyEvent;
typedef struct TGI_MouseEvent
{
    enum
    {
        TGI_MOUSEEVENT_DOWN,
        TGI_MOUSEEVENT_UP,
        TGI_MOUSEEVENT_DOUBLE,
        TGI_MOUSEEVENT_MOVE,
    } type;
    enum
    {
        TGI_MOUSEEVENT_LEFT,
        TGI_MOUSEEVENT_MIDDLE,
        TGI_MOUSEEVENT_RIGHT,
    } buttom;
    float x, y;
} TGI_MouseEvent;
 
struct vtable_TGI_Application_t
{
    void(TGIAPI *free)(TGI_Application *self);
    void(TGIAPI *exec)(TGI_Application *self);
    int(TGIAPI *exec_once)(TGI_Application *self);
    TGI_Window *(TGIAPI *create_window)(TGI_Application *self);
    TGI_Image *(TGIAPI *create_image)(TGI_Application *self, int width, int height);
    TGI_Image *(TGIAPI *create_image_from_file)(TGI_Application *self, const char *filename);
    TGI_Font *(TGIAPI *create_font)(TGI_Application *self, const char *name, float size, TGI_FontStyle style);
    TGI_Timer *(TGIAPI *create_timer)(TGI_Application *self, unsigned int delay, int type,
                                      void TGIAPI callback(TGI_Timer *timer));
};
static inline void TGIAPI tgi_application_free(TGI_Application *self)
{
    self->vptr->free(self);
}
static inline void TGIAPI tgi_application_exec(TGI_Application *self)
{
    self->vptr->exec(self);
}
static inline int TGIAPI tgi_application_exec_once(TGI_Application *self)
{
    return self->vptr->exec_once(self);
}
static inline TGI_Window *TGIAPI tgi_application_create_window(TGI_Application *self)
{
    return self->vptr->create_window(self);
}
static inline TGI_Image *TGIAPI tgi_application_create_image(TGI_Application *self, int width, int height)
{
    return self->vptr->create_image(self, width, height);
}
static inline TGI_Image *TGIAPI tgi_application_create_image_from_file(TGI_Application *self, const char *filename)
{
    return self->vptr->create_image_from_file(self, filename);
}
static inline TGI_Font *TGIAPI tgi_application_create_font(TGI_Application *self, const char *name, float size,
                                                           TGI_FontStyle style)
{
    return self->vptr->create_font(self, name, size, style);
}
static inline TGI_Timer *TGIAPI tgi_application_create_timer(TGI_Application *self, unsigned int delay, int type,
                                                             void TGIAPI callback(TGI_Timer *timer))
{
    return self->vptr->create_timer(self, delay, type, callback);
}
 
struct vtable_TGI_Window_t
{
    void(TGIAPI *free)(TGI_Window *self);
    void(TGIAPI *on_close)(TGI_Window *self, int TGIAPI callback(TGI_Window *self));
    void(TGIAPI *on_paint)(TGI_Window *self, void TGIAPI callback(TGI_Window *self));
    void(TGIAPI *on_size)(TGI_Window *self, void TGIAPI callback(TGI_Window *self, float new_width, float new_height));
    void(TGIAPI *on_key)(TGI_Window *self, void TGIAPI callback(TGI_Window *self, TGI_KeyEvent *event));
    void(TGIAPI *on_mouse)(TGI_Window *self, void TGIAPI callback(TGI_Window *self, TGI_MouseEvent *event));
    int(TGIAPI *is_key_down)(TGI_Window *self, char key);
    void(TGIAPI *show)(TGI_Window *self);
    void(TGIAPI *paint)(TGI_Window *self);
    int(TGIAPI *set_style)(TGI_Window *self, TGI_WindowStyle style);
    int(TGIAPI *set_size)(TGI_Window *self, int width, int height);
    int(TGIAPI *get_size)(TGI_Window *self, TGI_Rect *rect);
    int(TGIAPI *set_min_size)(TGI_Window *self, int width, int height);
    int(TGIAPI *set_max_size)(TGI_Window *self, int width, int height);
    int(TGIAPI *set_title)(TGI_Window *self, const char *title);
    TGI_Graphics *(TGIAPI *create_graphics)(TGI_Window *self);
    TGI_Image *(TGIAPI *create_image)(TGI_Window *self);
};
static inline void TGIAPI tgi_window_free(TGI_Window *self)
{
    self->vptr->free(self);
}
static inline void TGIAPI tgi_window_on_close(TGI_Window *self, int TGIAPI callback(TGI_Window *self))
{
    self->vptr->on_close(self, callback);
}
static inline void TGIAPI tgi_window_on_paint(TGI_Window *self, void TGIAPI callback(TGI_Window *self))
{
    self->vptr->on_paint(self, callback);
}
static inline void TGIAPI tgi_window_on_size(TGI_Window *self,
                                             void TGIAPI callback(TGI_Window *self, float new_width, float new_height))
{
    self->vptr->on_size(self, callback);
}
static inline void TGIAPI tgi_window_on_key(TGI_Window *self,
                                            void TGIAPI callback(TGI_Window *self, TGI_KeyEvent *event))
{
    self->vptr->on_key(self, callback);
}
static inline void TGIAPI tgi_window_on_mouse(TGI_Window *self,
                                              void TGIAPI callback(TGI_Window *self, TGI_MouseEvent *event))
{
    self->vptr->on_mouse(self, callback);
}
static inline int TGIAPI tgi_window_is_key_down(TGI_Window *self, char key)
{
    return self->vptr->is_key_down(self, key);
}
static inline void TGIAPI tgi_window_show(TGI_Window *self)
{
    self->vptr->show(self);
}
static inline void TGIAPI tgi_window_paint(TGI_Window *self)
{
    self->vptr->paint(self);
}
static inline int TGIAPI tgi_window_set_style(TGI_Window *self, TGI_WindowStyle style)
{
    return self->vptr->set_style(self, style);
}
static inline int TGIAPI tgi_window_set_size(TGI_Window *self, int width, int height)
{
    return self->vptr->set_size(self, width, height);
}
static inline int TGIAPI tgi_window_get_size(TGI_Window *self, TGI_Rect *rect)
{
    return self->vptr->get_size(self, rect);
}
static inline int TGIAPI tgi_window_set_min_size(TGI_Window *self, int width, int height)
{
    return self->vptr->set_min_size(self, width, height);
}
static inline int TGIAPI tgi_window_set_max_size(TGI_Window *self, int width, int height)
{
    return self->vptr->set_max_size(self, width, height);
}
static inline int TGIAPI tgi_window_set_title(TGI_Window *self, const char *title)
{
    return self->vptr->set_title(self, title);
}
static inline TGI_Graphics *TGIAPI tgi_window_create_graphics(TGI_Window *self)
{
    return self->vptr->create_graphics(self);
}
static inline TGI_Image *TGIAPI tgi_window_create_image(TGI_Window *self)
{
    return self->vptr->create_image(self);
}
 
struct vtable_TGI_Graphics_t
{
    void(TGIAPI *free)(TGI_Graphics *self);
    int(TGIAPI *clear)(TGI_Graphics *self, TGI_Color color);
    int(TGIAPI *set_color)(TGI_Graphics *self, TGI_Color color);
    int(TGIAPI *set_width)(TGI_Graphics *self, float width);
    int(TGIAPI *draw_line)(TGI_Graphics *self, float x1, float y1, float x2, float y2);
    int(TGIAPI *draw_arc)(TGI_Graphics *self, float x, float y, float width, float height, float start_angle,
                          float sweep_angle);
    int(TGIAPI *draw_rect)(TGI_Graphics *self, float x, float y, float width, float height);
    int(TGIAPI *draw_ellipse)(TGI_Graphics *self, float x, float y, float width, float height);
    int(TGIAPI *draw_pie)(TGI_Graphics *self, float x, float y, float width, float height, float start_angle,
                          float sweep_angle);
    int(TGIAPI *draw_polygon)(TGI_Graphics *self, const TGI_Point *points, int count);
    int(TGIAPI *fill_rect)(TGI_Graphics *self, float x, float y, float width, float height);
    int(TGIAPI *fill_ellipse)(TGI_Graphics *self, float x, float y, float width, float height);
    int(TGIAPI *fill_pie)(TGI_Graphics *self, float x, float y, float width, float height, float start_angle,
                          float sweep_angle);
    int(TGIAPI *fill_polygon)(TGI_Graphics *self, const TGI_Point *points, int count);
    int(TGIAPI *draw_image)(TGI_Graphics *self, const TGI_Image *image, float x, float y);
    int(TGIAPI *draw_image_rect)(TGI_Graphics *self, const TGI_Image *image, float x, float y, float width,
                                 float height);
    int(TGIAPI *draw_image_ex)(TGI_Graphics *self, const TGI_Image *image, float x, float y, float src_x, float src_y,
                               float src_width, float src_height);
    int(TGIAPI *draw_image_rect_ex)(TGI_Graphics *self, const TGI_Image *image, float x, float y, float width,
                                    float height, float src_x, float src_y, float src_width, float src_height);
    int(TGIAPI *draw_text)(TGI_Graphics *self, const char *text, const TGI_Font *font, float x, float y);
    int(TGIAPI *draw_text_rect)(TGI_Graphics *self, const char *text, const TGI_Font *font, float x, float y,
                                float width, float height);
};
static inline void TGIAPI tgi_graphics_free(TGI_Graphics *self)
{
    self->vptr->free(self);
}
static inline int TGIAPI tgi_graphics_clear(TGI_Graphics *self, TGI_Color color)
{
    return self->vptr->clear(self, color);
}
static inline int TGIAPI tgi_graphics_set_color(TGI_Graphics *self, TGI_Color color)
{
    return self->vptr->set_color(self, color);
}
static inline int TGIAPI tgi_graphics_set_width(TGI_Graphics *self, float width)
{
    return self->vptr->set_width(self, width);
}
static inline int TGIAPI tgi_graphics_draw_line(TGI_Graphics *self, float x1, float y1, float x2, float y2)
{
    return self->vptr->draw_line(self, x1, y1, x2, y2);
}
static inline int TGIAPI tgi_graphics_draw_arc(TGI_Graphics *self, float x, float y, float width, float height,
                                               float start_angle, float sweep_angle)
{
    return self->vptr->draw_arc(self, x, y, width, height, start_angle, sweep_angle);
}
static inline int TGIAPI tgi_graphics_draw_rect(TGI_Graphics *self, float x, float y, float width, float height)
{
    return self->vptr->draw_rect(self, x, y, width, height);
}
static inline int TGIAPI tgi_graphics_draw_ellipse(TGI_Graphics *self, float x, float y, float width, float height)
{
    return self->vptr->draw_ellipse(self, x, y, width, height);
}
static inline int TGIAPI tgi_graphics_draw_pie(TGI_Graphics *self, float x, float y, float width, float height,
                                               float start_angle, float sweep_angle)
{
    return self->vptr->draw_pie(self, x, y, width, height, start_angle, sweep_angle);
}
static inline int TGIAPI tgi_graphics_draw_polygon(TGI_Graphics *self, const TGI_Point *points, int count)
{
    return self->vptr->draw_polygon(self, points, count);
}
static inline int TGIAPI tgi_graphics_fill_rect(TGI_Graphics *self, float x, float y, float width, float height)
{
    return self->vptr->fill_rect(self, x, y, width, height);
}
static inline int TGIAPI tgi_graphics_fill_ellipse(TGI_Graphics *self, float x, float y, float width, float height)
{
    return self->vptr->fill_ellipse(self, x, y, width, height);
}
static inline int TGIAPI tgi_graphics_fill_pie(TGI_Graphics *self, float x, float y, float width, float height,
                                               float start_angle, float sweep_angle)
{
    return self->vptr->fill_pie(self, x, y, width, height, start_angle, sweep_angle);
}
static inline int TGIAPI tgi_graphics_fill_polygon(TGI_Graphics *self, const TGI_Point *points, int count)
{
    return self->vptr->fill_polygon(self, points, count);
}
static inline int TGIAPI tgi_graphics_draw_image(TGI_Graphics *self, const TGI_Image *image, float x, float y)
{
    return self->vptr->draw_image(self, image, x, y);
}
static inline int TGIAPI tgi_graphics_draw_image_rect(TGI_Graphics *self, const TGI_Image *image, float x, float y,
                                                      float width, float height)
{
    return self->vptr->draw_image_rect(self, image, x, y, width, height);
}
static inline int TGIAPI tgi_graphics_draw_image_ex(TGI_Graphics *self, const TGI_Image *image, float x, float y,
                                                    float src_x, float src_y, float src_width, float src_height)
{
    return self->vptr->draw_image_ex(self, image, x, y, src_x, src_y, src_width, src_height);
}
static inline int TGIAPI tgi_graphics_draw_image_rect_ex(TGI_Graphics *self, const TGI_Image *image, float x, float y,
                                                         float width, float height, float src_x, float src_y,
                                                         float src_width, float src_height)
{
    return self->vptr->draw_image_rect_ex(self, image, x, y, width, height, src_x, src_y, src_width, src_height);
}
static inline int TGIAPI tgi_graphics_draw_text(TGI_Graphics *self, const char *text, const TGI_Font *font, float x,
                                                float y)
{
    return self->vptr->draw_text(self, text, font, x, y);
}
static inline int TGIAPI tgi_graphics_draw_text_rect(TGI_Graphics *self, const char *text, const TGI_Font *font,
                                                     float x, float y, float width, float height)
{
    return self->vptr->draw_text_rect(self, text, font, x, y, width, height);
}
 
struct vtable_TGI_Image_t
{
    void(TGIAPI *free)(TGI_Image *self);
    TGI_Image *(TGIAPI *clone)(TGI_Image *self);
    int(TGIAPI *get_size)(TGI_Image *self, TGI_Rect *rect);
    TGI_Graphics *(TGIAPI *create_graphics)(TGI_Image *self);
};
static inline void TGIAPI tgi_image_free(TGI_Image *self)
{
    self->vptr->free(self);
}
static inline TGI_Image *TGIAPI tgi_image_clone(TGI_Image *self)
{
    return self->vptr->clone(self);
}
static inline int TGIAPI tgi_image_get_size(TGI_Image *self, TGI_Rect *rect)
{
    return self->vptr->get_size(self, rect);
}
static inline TGI_Graphics *TGIAPI tgi_image_create_graphics(TGI_Image *self)
{
    return self->vptr->create_graphics(self);
}
 
struct vtable_TGI_Font_t
{
    void(TGIAPI *free)(TGI_Font *self);
    int(TGIAPI *set_align)(TGI_Font *self, TGI_TextAlign align);
    int(TGIAPI *set_vertical_align)(TGI_Font *self, TGI_TextAlign align);
};
static inline void TGIAPI tgi_font_free(TGI_Font *self)
{
    self->vptr->free(self);
}
static inline int TGIAPI tgi_font_set_align(TGI_Font *self, TGI_TextAlign align)
{
    return self->vptr->set_align(self, align);
}
static inline int TGIAPI tgi_font_set_vertical_align(TGI_Font *self, TGI_TextAlign align)
{
    return self->vptr->set_vertical_align(self, align);
}
 
struct vtable_TGI_Timer_t
{
    void(TGIAPI *free)(TGI_Timer *self);
};
static inline void tgi_timer_free(TGI_Timer *self)
{
    self->vptr->free(self);
}
 
#ifdef __cplusplus
extern "C"
{
#endif
    TGI_Application *TGIAPI tgi_application_create(TGI_Backend backend, TGI_Encoding encoding);
 
#ifdef __cplusplus
}
#endif
 
#endif