Rtch/Lephisto
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
e4f76c9b08
Lephisto/src/toolkit.c

1670 lines
44 KiB
C
Raw Blame History

#include "lephisto.h"
#include "log.h"
#include "pause.h"
#include "opengl.h"
#include "input.h"
#include "toolkit.h"
#define INPUT_DELAY 500
#define INPUT_FREQ 100
typedef enum WidgetType_ {
WIDGET_NULL,
WIDGET_BUTTON,
WIDGET_TEXT,
WIDGET_IMAGE,
WIDGET_LIST,
WIDGET_RECT,
WIDGET_CUST,
WIDGET_INPUT
} WidgetType;
typedef enum WidgetStatus_ {
WIDGET_STATUS_NORMAL,
WIDGET_STATUS_MOUSEOVER,
WIDGET_STATUS_MOUSEDOWN
} WidgetStatus;
typedef struct Widget_ {
char* name; // Widget name.
WidgetType type; // type..
double x,y; // Position.
double w,h; // Dimensions.
WidgetStatus status;
union {
// Widget button.
struct {
void(*fptr) (char*); // Active callback.
char* display; // Stored text.
int disabled;
} btn;
// Widget text.
struct {
char* text; // Use printMid for centered printText if not.
glFont* font;
glColour* colour;
int centered;
} txt;
struct {
// Widget image.
glTexture* image;
glColour* colour;
int border;
} img;
struct {
// Widget list.
char** options; // Pointer to the options.
int noptions; // total number of options.
int selected; // Currently selected option.
int pos; // Current topmost option (in view).
void (*fptr) (char*); // Modify callback.
} lst;
// Widget rect.
struct {
glColour* colour; // Background colour.
int border; // Border.
} rct;
// Widget cust.
struct {
int border;
void(*render) (double bx, double by, double bw, double bh);
void(*mouse) (SDL_Event* event, double bx, double by);
} cst;
struct {
// Widget input.
char* input; // Input buffer.
int max; // Max length.
int oneline; // Is it a one-line? '\n' and co. if no.
int view, pos; // View and cursor position.
} inp;
} dat;
} Widget;
typedef struct Window_ {
unsigned int id; // Unique identifier.
char* name;
int hidden; // Is it hidden?
int focus; // Which window is focused.
// Pointer to a function to run if user hits 'enter' and no button is focused
// nor any other input thiny that catches 'enter'.
void(*def_fptr)(char*);
double x,y; // Position.
double w,h; // Dimensions.
Widget* widgets; // Widget storage.
int nwidgets; // Total number of widgets.
} Window;
static unsigned int genwid = 0; // Generate unique id > 0.
int toolkit = 0;
#define MIN_WINDOWS 3
static Window* windows = NULL;
static int nwindows = 0;
static int mwindows = 0;
// Default outline colours.
static glColour* toolkit_colLight = &cGrey90;
static glColour* toolkit_col = &cGrey70;
static glColour* toolkit_colDark = &cGrey30;
// Extern.
extern void main_loop(void); // lephisto.c
// Static.
static Widget* window_newWidget(Window* w);
static void widget_cleanup(Widget* widget);
static Window* window_wget(const unsigned int wid);
static Widget* window_getwgt(const unsigned int wid, char* name);
// Input.
static int toolkit_inputInput(Uint8 type, Widget* inp, SDLKey key);
static void toolkit_mouseEvent(SDL_Event* event);
static int toolkit_keyEvent(SDL_Event* event);
// Focus.
static void toolkit_nextFocus(void);
static int toolkit_isFocusable(Widget* wgt);
static void toolkit_triggerFocus(void);
static Widget* toolkit_getFocus(void);
static void toolkit_listScroll(Widget* wgt, int direction);
static void toolkit_listFocus(Widget* lst, double bx, double by);
// Render.
static void window_render(Window* w);
static void toolkit_renderButton(Widget* btn, double bx, double by);
static void toolkit_renderText(Widget* txt, double bx, double by);
static void toolkit_renderImage(Widget* img, double bx, double by);
static void toolkit_renderList(Widget* lst, double bx, double by);
static void toolkit_renderRect(Widget* rct, double bx, double by);
static void toolkit_renderCust(Widget* cst, double bx, double by);
static void toolkit_renderInput(Widget* inp, double bx, double by);
static void toolkit_drawOutline(double x, double y, double w,
double h, double b, glColour* c, glColour* lc);
static void toolkit_clip(double x, double y, double w, double h);
static void toolkit_unclip(void);
static void toolkit_drawRect(double x, double y, double w, double h,
glColour* c, glColour* lc);
// Dialogues..
static glFont* dialogue_getSize(char* msg, int* w, int* h);
static void dialogue_alertClose(char* str);
static void dialogue_msgClose(char* str);
static void dialogue_YesNoClose(char* str);
static void dialogue_inputClose(char* str);
// Secondary loop hack.
static int loop_done;
static int toolkit_loop(void);
// Add a button that when pressed will trigger call, passing it's name as the
// only parameter.
void window_addButton(const unsigned int wid, const int x, const int y,
const int w, const int h, char* name,
char* display, void (*call)(char*)) {
Window* wdw = window_wget(wid);
Widget* wgt = window_newWidget(wdw);
// Specific.
wgt->type = WIDGET_BUTTON;
wgt->name = strdup(name);
wgt->dat.btn.display = strdup(display);
wgt->dat.btn.disabled = 0; // Initially enabled.
// Set the properties.
wgt->w = (double) w;
wgt->h = (double) h;
if(x < 0) wgt->x = wdw->w - wgt->w + x;
else wgt->x = (double)x;
if(y < 0) wgt->y = wdw->h - wgt->h + y;
else wgt->y = (double)y;
wgt->dat.btn.fptr = call;
if(wdw->focus == -1) // Init the focus.
toolkit_nextFocus();
}
// Add text to the window.
void window_addText(const unsigned int wid, const int x, const int y,
const int w, const int h, const int centered, char* name,
glFont* font, glColour* colour, char* string) {
Window* wdw = window_wget(wid);
Widget* wgt = window_newWidget(wdw);
wgt->type = WIDGET_TEXT;
wgt->name = strdup(name); // Display the widgets name.
// Set the properties.
wgt->w = (double) w;
wgt->h = (double) h;
if(font == NULL) wgt->dat.txt.font = &gl_defFont;
else wgt->dat.txt.font = font;
if(x < 0) wgt->x = wdw->w - wgt->w + x;
else wgt->x = (double)x;
if(y < 0) wgt->y = wdw->h + y - h;
else wgt->y = (double) y;
if(colour == NULL) wgt->dat.txt.colour = &cBlack;
else wgt->dat.txt.colour = colour;
wgt->dat.txt.centered = centered;
if(string) wgt->dat.txt.text = strdup(string);
else wgt->dat.txt.text = NULL;
}
// Add a graphic to the window.
void window_addImage(const unsigned int wid, const int x, const int y,
char* name, glTexture* image, int border) {
Window* wdw = window_wget(wid);
Widget* wgt = window_newWidget(wdw);
wgt->type = WIDGET_IMAGE;
wgt->name = strdup(name);
// Set the properties.
wgt->dat.img.image = image;
wgt->dat.img.border = border;
wgt->dat.img.colour = NULL; // Normal colour.
wgt->w = (image == NULL) ? 0 : wgt->dat.img.image->sw;
wgt->h = (image == NULL) ? 0 : wgt->dat.img.image->sh;
if(x < 0) wgt->x = wdw->w - wgt->w + x;
else wgt->x = (double)x;
if(y < 0) wgt->y = wdw->h - wgt->h + y;
else wgt->y = (double)y;
}
void window_addList(const unsigned int wid, const int x, const int y,
const int w, const int h, char* name, char** items, int nitems,
int defitem, void(*call) (char*)) {
Window *wdw = window_wget(wid);
Widget* wgt = window_newWidget(wdw);
wgt->type = WIDGET_LIST;
wgt->name = strdup(name);
wgt->dat.lst.options = items;
wgt->dat.lst.noptions = nitems;
wgt->dat.lst.selected = defitem; // -1 would be none.
wgt->dat.lst.pos = 0;
wgt->dat.lst.fptr = call;
wgt->w = (double) w;
wgt->h = (double) h - ((h % (gl_defFont.h+2)) + 2);
if(x < 0) wgt->x = wdw->w - wgt->w + x;
else wgt->x = (double) x;
if(y < 0) wgt->y = wdw->h - wgt->h + y;
else wgt->y = (double) y;
if(wdw->focus == -1)
// Initialize the focus.
toolkit_nextFocus();
}
void window_addRect(const unsigned int wid, const int x, const int y,
const int w, const int h, char* name, glColour* colour, int border) {
Window* wdw = window_wget(wid);
Widget* wgt = window_newWidget(wdw);
wgt->type = WIDGET_RECT;
wgt->name = strdup(name);
wgt->dat.rct.colour = colour;
wgt->dat.rct.border = border;
wgt->w = (double)w;
wgt->h = (double)h;
if(x < 0) wgt->x = wdw->w - wgt->w + x;
else wgt->x = (double)x;
if(y < 0) wgt->y = wdw->h - wgt->h + y;
else wgt->y = (double)y;
}
void window_addCust(const unsigned int wid, const int x, const int y,
const int w, const int h, char* name, const int border,
void(*render) (double x, double y, double w, double h),
void(*mouse) (SDL_Event* event, double x, double y)) {
Window* wdw = window_wget(wid);
Widget* wgt = window_newWidget(wdw);
// Generic.
wgt->type = WIDGET_CUST;
wgt->name = strdup(name);
// Specific.
wgt->dat.cst.border = border;
wgt->dat.cst.render = render;
wgt->dat.cst.mouse = mouse;
// Position/size.
wgt->w = (double)w;
wgt->h = (double)h;
if(x < 0) wgt->x = wdw->w - wgt->w + x;
else wgt->x = (double) x;
if(y < 0) wgt->y = wdw->h - wgt->h + y;
else wgt->y = (double) y;
}
// Add an input widget.
void window_addInput(const unsigned int wid,
const int x, const int y,
const int w, const int h,
char* name, const int max, const int oneline) {
Window* wdw = window_wget(wid);
Widget* wgt = window_newWidget(wdw);
// Generic.
wgt->type = WIDGET_INPUT;
wgt->name = strdup(name);
// Specific.
wgt->dat.inp.max = max+1;
wgt->dat.inp.oneline = oneline;
wgt->dat.inp.pos = 0;
wgt->dat.inp.view = 0;
wgt->dat.inp.input = malloc(sizeof(char)*wgt->dat.inp.max);
memset(wgt->dat.inp.input, 0, wgt->dat.inp.max*sizeof(char));
// Position/Size.
wgt->w = (double)w;
wgt->h = (double)h;
if(x < 0) wgt->x = wdw->w - wgt->w + x;
else wgt->x = (double)x;
if(y < 0) wgt->y = wdw->h - wgt->h + y;
else wgt->y = (double)y;
}
// Return pointer to newly allocated widget.
static Widget* window_newWidget(Window* w) {
Widget* wgt = NULL;
w->nwidgets++;
w->widgets = realloc(w->widgets, sizeof(Widget)*w->nwidgets);
if(w->widgets == NULL) WARN("Out of memory");
wgt = &w->widgets[w->nwidgets - 1];
wgt->type = WIDGET_NULL;
wgt->status = WIDGET_STATUS_NORMAL;
return wgt;
}
// Return the window of id wid.
static Window* window_wget(const unsigned int wid) {
int i;
for(i = 0; i < nwindows; i++)
if(windows[i].id == wid)
return &windows[i];
DEBUG("Window '%d' not found in windows stack", wid);
return NULL;
}
static Widget* window_getwgt(const unsigned int wid, char* name) {
int i;
Window* wdw = window_wget(wid);
for(i = 0; i < wdw->nwidgets; i++)
if(strcmp(wdw->widgets[i].name, name)==0)
return &wdw->widgets[i];
return NULL;
}
void window_modifyText(const unsigned int wid, char* name, char* newstring) {
Widget* wgt = window_getwgt(wid, name);
if(wgt->dat.txt.text) free(wgt->dat.txt.text);
wgt->dat.txt.text = (newstring) ? strdup(newstring) : NULL;
}
// Disable a button.
void window_disableButton(const unsigned int wid, char* name) {
Widget* wgt = window_getwgt(wid, name);
if(wgt->type != WIDGET_BUTTON) {
DEBUG("Trying to disable a non-button widget '%s'", name);
return;
}
wgt->dat.btn.disabled = 1;
}
// Enable a button.
void window_enableButton(const unsigned int wid, char* name) {
Widget* wgt = window_getwgt(wid, name);
if(wgt->type != WIDGET_BUTTON) {
DEBUG("Trying to enable a non-button widget '%s'", name);
return;
}
wgt->dat.btn.disabled = 0;
}
void window_modifyImage(const unsigned int wid, char* name, glTexture* image) {
Widget* wgt = window_getwgt(wid, name);
wgt->dat.img.image = image;
}
void window_imgColour(const unsigned int wid, char* name, glColour* colour) {
Widget* wgt = window_getwgt(wid, name);
wgt->dat.img.colour = colour;
}
glTexture* window_getImage(const unsigned int wid, char* name) {
Widget* wgt = window_getwgt(wid, name);
return (wgt) ? wgt->dat.img.image : NULL;
}
// Get the input from an input widget.
char* window_getInput(const unsigned int wid, char* name) {
Widget* wgt = window_getwgt(wid, name);
return(wgt) ? wgt->dat.inp.input : NULL;
}
// Check if a window exists.
int window_exists(const char* wdwname) {
int i;
for(i = 0; i < nwindows; i++)
if(strcmp(windows[i].name, wdwname)==0)
return 1; // Exists.
return 0; // Does not exits!
}
// Return the id of a window.
unsigned int window_get(const char* wdwname) {
int i;
for(i = 0; i < nwindows; i++)
if(strcmp(windows[i].name, wdwname)==0)
return windows[i].id;
DEBUG("Window '%s' not found in windows stack", wdwname);
return 0;
}
// Create a window.
unsigned int window_create(char* name, const int x, const int y,
const int w, const int h) {
Window* wdw;
if(nwindows >= mwindows) {
// We have reached our memory limit.
windows = realloc(windows, sizeof(Window)*(++mwindows));
if(windows == NULL) WARN("Out of memory");
}
const int wid = (++genwid); // Unique id
wdw = &windows[nwindows];
wdw->id = wid;
wdw->name = strdup(name);
wdw->hidden = 0;
wdw->focus = -1;
wdw->def_fptr = NULL;
wdw->w = (double)w;
wdw->h = (double)h;
// x pos.
if(x == -1)
// Center.
wdw->x = gl_screen.w/2. - windows[nwindows].w/2.;
else if(x < 0)
wdw->x = gl_screen.w - windows[nwindows].w + (double)x;
else windows[nwindows].x = (double)x;
// y pos.
if(y == -1)
// Center.
wdw->y = gl_screen.h/2. - windows[nwindows].h/2.;
else if(y < 0)
wdw->x = gl_screen.h - windows[nwindows].h + (double)y;
else wdw->y = (double)y;
wdw->widgets = NULL;
wdw->nwidgets = 0;
nwindows++;
if(toolkit == 0) {
// Toolkit is enabled.
SDL_ShowCursor(SDL_ENABLE);
toolkit = 1; // Enable it.
pause_game();
}
return wid;
}
// Sets the window's default function.
void window_setFptr(const unsigned int wid, void(*fptr)(char*)) {
Window* wdw;
wdw = window_wget(wid);
if(wdw != NULL) wdw->def_fptr = fptr;
}
// Destroy a widget.
static void widget_cleanup(Widget* widget) {
int i;
if(widget->name) free(widget->name);
switch(widget->type) {
case WIDGET_BUTTON: // Must clear the button display text.
if(widget->dat.btn.display) free(widget->dat.btn.display);
break;
case WIDGET_TEXT: // Must clear the text.
if(widget->dat.txt.text) free(widget->dat.txt.text);
break;
case WIDGET_LIST: // Must clear the list.
if(widget->dat.lst.options) {
for(i = 0; i < widget->dat.lst.noptions; i++)
if(widget->dat.lst.options[i])
free(widget->dat.lst.options[i]);
free(widget->dat.lst.options);
}
break;
case WIDGET_INPUT:
free(widget->dat.inp.input); // Free the input buffer.
break;
default:
break;
}
}
// Destroy a window.
void window_destroy(const unsigned int wid) {
int i, j;
// Destroy the window.
for(i = 0; i < nwindows; i++)
if(windows[i].id == wid) {
if(windows[i].name) free(windows[i].name);
for(j = 0; j < windows[i].nwidgets; j++)
widget_cleanup(&windows[i].widgets[j]);
free(windows[i].widgets);
break;
}
// Move the other windows down a layer.
for(; i<(nwindows-1); i++)
windows[i] = windows[i+1];
nwindows--;
if(nwindows == 0) {
// No windows left.
SDL_ShowCursor(SDL_DISABLE);
toolkit = 0; // Disable the toolkit.
if(paused) unpause_game();
}
}
void window_destroyWidget(unsigned int wid, const char* wgtname) {
Window* w = window_wget(wid);
int i;
if(w == NULL) {
WARN("Window %d does not exist", wid);
return;
}
for(i = 0; i < w->nwidgets; i++)
if(strcmp(wgtname, w->widgets[i].name)==0)
break;
if(i >= w->nwidgets) {
DEBUG("Widget '%s' not found in window '%d'", wgtname, wid);
return;
}
if(w->focus == i) w->focus = -1;
widget_cleanup(&w->widgets[i]);
if(i < w->nwidgets-1)
// This isn't the last widget.
memmove(&w->widgets[i], &w->widgets[i+1],
sizeof(Widget) * (w->nwidgets-i-1));
(w->nwidgets)--; // Not that we don't actually realloc the space..
}
static void toolkit_drawOutline(double x, double y, double w, double h,
double b, glColour* c, glColour* lc) {
glShadeModel((lc == NULL) ? GL_FLAT : GL_SMOOTH);
if(!lc) COLOUR(*c);
glBegin(GL_LINE_LOOP);
// Left.
if(lc) COLOUR(*lc);
glVertex2d(x-b, y);
if(lc) COLOUR(*c);
glVertex2d(x-b, y+h);
// Top.
glVertex2d(x, y+h+b);
glVertex2d(x+w, y+h+b);
// Right.
glVertex2d(x+w+b, y+h);
if(lc) COLOUR(*lc);
glVertex2d(x+w+b, y);
// Bottom.
glVertex2d(x+w, y-b);
glVertex2d(x, y-b);
glVertex2d(x-b, y);
glEnd();
}
static void toolkit_drawRect(double x, double y, double w, double h,
glColour* c, glColour* lc) {
glShadeModel((lc) ? GL_SMOOTH : GL_FLAT);
glBegin(GL_QUADS);
COLOUR(*c);
glVertex2d(x, y);
glVertex2d(x+w, y);
COLOUR((lc) ? *lc : *c);
glVertex2d(x+w, y+h);
glVertex2d(x, y+h);
glEnd();
}
// Set up 2d clipping planes around a rectangle.
static void toolkit_clip(double x, double y, double w, double h) {
GLdouble ctop[4] = { 0., 1., 0., -y };
GLdouble cbot[4] = { 0., -1., 0., y+h };
GLdouble clef[4] = { 1., 0., 0., -x };
GLdouble crig[4] = { -1., 0., 0, x+w };
glClipPlane(GL_CLIP_PLANE0, ctop);
glClipPlane(GL_CLIP_PLANE1, cbot);
glClipPlane(GL_CLIP_PLANE2, clef);
glClipPlane(GL_CLIP_PLANE3, crig);
glEnable(GL_CLIP_PLANE0);
glEnable(GL_CLIP_PLANE1);
glEnable(GL_CLIP_PLANE2);
glEnable(GL_CLIP_PLANE3);
}
static void toolkit_unclip(void) {
glDisable(GL_CLIP_PLANE0);
glDisable(GL_CLIP_PLANE1);
glDisable(GL_CLIP_PLANE2);
glDisable(GL_CLIP_PLANE3);
}
// Render a window.
static void window_render(Window* w) {
int i;
double x, y, wid, hei;
glColour *lc, *c, *dc, *oc;
// Position.
x = w->x - (double)gl_screen.w/2.;
y = w->y - (double)gl_screen.h/2.;
// Colours.
lc = &cGrey90;
c = &cGrey70;
dc = &cGrey50;
oc = &cGrey30;
// Window shaded background.
// Main body.
toolkit_drawRect(x+21, y, w->w-42., 0.6*w->h, dc, c);
toolkit_drawRect(x+21, y+0.6*w->h, w->w-42., 0.4*w->h, c, NULL);
glShadeModel(GL_SMOOTH);
// Left side.
glBegin(GL_POLYGON);
COLOUR(*c);
glVertex2d(x+21., y+0.6*w->h); // Center.
COLOUR(*dc);
glVertex2d(x+21., y);
glVertex2d(x+15., y+1.);
glVertex2d(x+10., y+3.);
glVertex2d(x+6., y+6.);
glVertex2d(x+3., y+10.);
glVertex2d(x+1., y+15.);
glVertex2s(x, y+21.);
COLOUR(*c);
glVertex2d(x, y+0.6*w->h); // Front of center.
glVertex2d(x, y+w->h-21.);
glVertex2d(x+1., y+w->h-15.);
glVertex2d(x+3., y+w->h-10.);
glVertex2d(x+6., y+w->h-6.);
glVertex2d(x+10., y+w->h-3.);
glVertex2d(x+15., y+w->h-1.);
glVertex2d(x+21., y+w->h);
glEnd();
// Right side.
glBegin(GL_POLYGON);
COLOUR(*c);
glVertex2d(x+w->w-21., y+0.6*w->h); // Center.
COLOUR(*dc);
glVertex2d(x+w->w-21., y);
glVertex2d(x+w->w-15., y+1.);
glVertex2d(x+w->w-10., y+3.);
glVertex2d(x+w->w-6., y+6.);
glVertex2d(x+w->w-3., y+10.);
glVertex2d(x+w->w-1., y+15.);
glVertex2d(x+w->w, y+21.);
COLOUR(*c);
glVertex2d(x+w->w, y+0.6*w->h); // Front of center.
glVertex2d(x+w->w, y+w->h-21.);
glVertex2d(x+w->w-1., y+w->h-15.);
glVertex2d(x+w->w-3., y+w->h-10.);
glVertex2d(x+w->w-6., y+w->h-6.);
glVertex2d(x+w->w-10., y+w->h-3.);
glVertex2d(x+w->w-15., y+w->h-1.);
glVertex2d(x+w->w-21., y+w->h);
glEnd();
// Inner outline.
glShadeModel(GL_SMOOTH);
glBegin(GL_LINE_LOOP);
// Left side.
COLOUR(*c);
glVertex2d(x+21.+1., y);
glVertex2d(x+15.+1., y+1.+1.);
glVertex2d(x+10.+1., y+3.+1.);
glVertex2d(x+6.+1., y+6.+1.);
glVertex2d(x+3.+1., y+10.+1.);
glVertex2d(x+1.+1., y+15.+1.);
glVertex2d(x+1., y+21.+1.);
COLOUR(*lc);
glVertex2d(x+1., y+0.6*w->h); // Front of center.
glVertex2d(x+1., y+w->h-21.-1.);
glVertex2d(x+1.+1., y+w->h-15.-1.);
glVertex2d(x+3.+1., y+w->h-10.-1.);
glVertex2d(x+6.+1., y+w->h-6.-1.);
glVertex2d(x+10.+1., y+w->h-2.-1.);
glVertex2d(x+15.+1., y+w->h-1.-1.);
glVertex2d(x+21.+1., y+w->h-1.);
// Switch to right via top.
glVertex2d(x+w->w-21.-1., y+w->h);
glVertex2d(x+w->w-15.-1., y+w->h-1.-1.);
glVertex2d(x+w->w-10.-1., y+w->h-3.-1.);
glVertex2d(x+w->w-6.-1., y+w->h-6.-1.);
glVertex2d(x+w->w-2.-1., y+w->h-10.-1.);
glVertex2d(x+w->w-1.-1., y+w->h-15.-1.);
glVertex2d(x+w->w-.1, y+w->h-21.-1.);
glVertex2d(x+w->w-1., y+0.6*w->h); // Front of center.
COLOUR(*c);
glVertex2d(x+w->w-1., y+21.+1.);
glVertex2d(x+w->w-1.-1., y+15.+1.);
glVertex2d(x+w->w-3.-1., y+10.+1.);
glVertex2d(x+w->w-6.-1., y+6.+1.);
glVertex2d(x+w->w-10.-1., y+3.+1.);
glVertex2d(x+w->w-15.-1., y+1.+1.);
glVertex2d(x+w->w-21.-1., y+1.);
glVertex2d(x+21.+1., y+1.);
glEnd();
// Outter outline.
glShadeModel(GL_FLAT);
glBegin(GL_LINE_LOOP);
// Left side.
COLOUR(*oc);
glVertex2d(x+21., y);
glVertex2d(x+15., y+1.);
glVertex2d(x+10., y+3.);
glVertex2d(x+6., y+6.);
glVertex2d(x+3., y+10.);
glVertex2d(x+1., y+15.);
glVertex2d(x, y+21.);
glVertex2d(x, y+0.6*w->h); // Front of center.
glVertex2d(x, y+w->h-21.);
glVertex2d(x+1., y+w->h-15.);
glVertex2d(x+3., y+w->h-10.);
glVertex2d(x+6., y+w->h-6.);
glVertex2d(x+10., y+w->h-3.);
glVertex2d(x+15., y+w->h-1.);
glVertex2d(x+21., y+w->h);
// Switch to right via top.
glVertex2d(x+w->w-21., y+w->h);
glVertex2d(x+w->w-15., y+w->h-1.);
glVertex2d(x+w->w-10., y+w->h-3.);
glVertex2d(x+w->w-6., y+w->h-6.);
glVertex2d(x+w->w-3., y+w->h-10.);
glVertex2d(x+w->w-1., y+w->h-15.);
glVertex2d(x+w->w, y+w->h-21.);
glVertex2d(x+w->w, y+0.6*w->h); // Front of center.
glVertex2d(x+w->w, y+21.);
glVertex2d(x+w->w-1., y+15.);
glVertex2d(x+w->w-3., y+10.);
glVertex2d(x+w->w-6., y+6.);
glVertex2d(x+w->w-10., y+3.);
glVertex2d(x+w->w-15., y+1.);
glVertex2d(x+w->w-21., y);
glVertex2d(x+21., y); // Back to beginning.
glEnd();
// Render the window name.
gl_printMid(&gl_defFont, w->w,
x + (double)gl_screen.w/2.,
y + w->h - 20. + (double)gl_screen.h/2.,
&cBlack, w->name);
// Widgets.
for(i = 0; i < w->nwidgets; i++) {
switch(w->widgets[i].type) {
case WIDGET_NULL:
break;
case WIDGET_BUTTON:
toolkit_renderButton(&w->widgets[i], x, y);
break;
case WIDGET_TEXT:
toolkit_renderText(&w->widgets[i], x, y);
break;
case WIDGET_IMAGE:
toolkit_renderImage(&w->widgets[i], x, y);
break;
case WIDGET_LIST:
toolkit_renderList(&w->widgets[i], x, y);
break;
case WIDGET_RECT:
toolkit_renderRect(&w->widgets[i], x, y);
break;
case WIDGET_CUST:
toolkit_renderCust(&w->widgets[i], x, y);
break;
case WIDGET_INPUT:
toolkit_renderInput(&w->widgets[i], x, y);
break;
}
}
// Focus widget.
if(w->focus != -1) {
x += w->widgets[w->focus].x;
y += w->widgets[w->focus].y;
wid = w->widgets[w->focus].w;
hei = w->widgets[w->focus].h;
toolkit_drawOutline(x, y, wid, hei, 3, &cBlack, NULL);
}
}
// Renders a button.
static void toolkit_renderButton(Widget* btn, double bx, double by) {
glColour* c, *dc, *lc;
double x, y;
x = bx + btn->x;
y = by + btn->y;
if(btn->dat.btn.disabled == 1) {
lc = &cGrey60;
c = &cGrey20;
dc = &cGrey40;
} else {
switch(btn->status) {
// Set the color.
case WIDGET_STATUS_NORMAL:
lc = &cGrey80;
c = &cGrey60;
dc = &cGrey40;
break;
case WIDGET_STATUS_MOUSEOVER:
lc = &cWhite;
c = &cGrey80;
dc = &cGrey60;
break;
case WIDGET_STATUS_MOUSEDOWN:
lc = &cGreen;
c = &cGreen;
dc = &cGrey40;
break;
default:
break;
}
}
// Shaded base.
if(btn->dat.btn.disabled == 1) {
toolkit_drawRect(x, y, btn->w, 0.4*btn->h, dc, NULL);
toolkit_drawRect(x, y+0.4*btn->h, btn->w, 0.6*btn->h, dc, c);
} else {
toolkit_drawRect(x, y, btn->w, 0.6*btn->h, dc, c);
toolkit_drawRect(x, y+0.6*btn->h, btn->w, 0.4*btn->h, c, NULL);
}
// Inner outline.
toolkit_drawOutline(x, y, btn->w, btn->h, 0., lc, c);
// Outter outline.
toolkit_drawOutline(x, y, btn->w, btn->h, 1., &cBlack, NULL);
gl_printMid(NULL, (int)btn->w,
bx + (double)gl_screen.w/2. + btn->x,
by + (double)gl_screen.h/2. + btn->y + (btn->h - gl_defFont.h)/2.,
&cDarkRed, btn->dat.btn.display);
}
static void toolkit_renderText(Widget* txt, double bx, double by) {
if(txt->dat.txt.text == NULL) return;
if(txt->dat.txt.centered)
gl_printMid(txt->dat.txt.font, txt->w,
bx + (double)gl_screen.w/2. + txt->x,
by + (double)gl_screen.h/2. + txt->y,
txt->dat.txt.colour, txt->dat.txt.text);
else
gl_printText(txt->dat.txt.font, txt->w, txt->h,
bx + (double)gl_screen.w/2. + txt->x,
by + (double)gl_screen.h/2. + txt->y,
txt->dat.txt.colour, txt->dat.txt.text);
}
// Render the image.
static void toolkit_renderImage(Widget* img, double bx, double by) {
double x, y;
if(img->dat.img.image == NULL) return;
x = bx + img->x;
y = by + img->y;
// Image.
gl_blitStatic(img->dat.img.image,
x + (double)gl_screen.w/2.,
y + (double)gl_screen.h/2.,
img->dat.img.colour);
if(img->dat.img.border) {
// Inner outline (outwards).
toolkit_drawOutline(x, y+1, img->dat.img.image->sw-1,
img->dat.img.image->sh-1, 1., toolkit_colLight,
toolkit_col);
// Outter outline.
toolkit_drawOutline(x, y+1, img->dat.img.image->sw-1,
img->dat.img.image->sh-1, 2., toolkit_colDark, NULL);
}
}
// Render the list.
static void toolkit_renderList(Widget* lst, double bx, double by) {
int i;
double x, y, tx, ty;
x = bx + lst->x;
y = by + lst->y;
// List bg.
toolkit_drawRect(x, y, lst->w, lst->h, &cWhite, NULL);
// Inner outline.
toolkit_drawOutline(x, y, lst->w, lst->h, 0., toolkit_colLight, toolkit_col);
// Outter outline.
toolkit_drawOutline(x, y, lst->w, lst->h, 1., toolkit_colDark, NULL);
// Draw selected.
toolkit_drawRect(x,
y-1.+lst->h-(1+lst->dat.lst.selected-lst->dat.lst.pos)*(gl_defFont.h+2.),
lst->w, gl_defFont.h+2., &cHilight, NULL);
// Draw content.
tx = (double)gl_screen.w/2. + x+2.;
ty = (double)gl_screen.h/2. + y+lst->h - 2. - gl_defFont.h;
y = ty-2.;
for(i = lst->dat.lst.pos; i < lst->dat.lst.noptions; i++) {
gl_printMax(&gl_defFont, (int)lst->w-4,
tx, ty, &cBlack, lst->dat.lst.options[i]);
ty -= 2 + gl_defFont.h;
if(ty-y > lst->h) break;
}
}
// Render a rectangle.
static void toolkit_renderRect(Widget* rct, double bx, double by) {
double x, y;
x = bx + rct->x;
y = by + rct->y;
if(rct->dat.rct.colour)
// Draw rect only if it exists.
toolkit_drawRect(x, y, rct->w, rct->h, rct->dat.rct.colour, NULL);
if(rct->dat.rct.border) {
// Inner outline.
toolkit_drawOutline(x, y, rct->w, rct->h, 0., toolkit_colLight, toolkit_col);
// Outter outline.
toolkit_drawOutline(x, y, rct->w, rct->h, 1., toolkit_colDark, NULL);
}
}
// Render a custom widget.
static void toolkit_renderCust(Widget* cst, double bx, double by) {
double x, y;
x = bx + cst->x;
y = by + cst->y;
if(cst->dat.cst.border) {
// Inner outline.
toolkit_drawOutline(x-1, y+1, cst->w+1, cst->h+1, 0.,
toolkit_colLight, toolkit_col);
// Outter outline.
toolkit_drawOutline(x-1, y, cst->w+1, cst->h+1, 1.,
toolkit_colDark, NULL);
}
toolkit_clip(x, y, cst->w, cst->h);
(*cst->dat.cst.render) (x, y, cst->w, cst->h);
toolkit_unclip();
}
// Render an input widget.
static void toolkit_renderInput(Widget* inp, double bx, double by) {
double x, y, ty;
x = bx + inp->x;
y = by + inp->y;
// Main background.
toolkit_drawRect(x, y, inp->w, inp->h, &cWhite, NULL);
// Center vertically.
if(inp->dat.inp.oneline) ty = y - (inp->h - gl_smallFont.h)/2.;
gl_printText(&gl_smallFont, inp->w-10., inp->h,
x+5. + gl_screen.w/2., ty + gl_screen.h/2.,
&cBlack, inp->dat.inp.input+inp->dat.inp.view);
// Inner outline.
toolkit_drawOutline(x, y, inp->w, inp->h, 0.,
toolkit_colLight, toolkit_col);
// Outter outline.
toolkit_drawOutline(x, y, inp->w, inp->h, 1.,
toolkit_colDark, NULL);
}
// Handle input for input widget.
static int toolkit_inputInput(Uint8 type, Widget* inp, SDLKey key) {
int n;
SDLMod mods;
if(inp->type != WIDGET_INPUT) return 0;
mods = SDL_GetModState();
if(inp->dat.inp.oneline && isascii(key)) {
// Backspace -> delete text.
if((type == SDL_KEYDOWN) && (key == '\b') && (inp->dat.inp.pos > 0)) {
inp->dat.inp.input[--inp->dat.inp.pos] = '\0';
if(inp->dat.inp.view > 0) {
n = gl_printWidth(&gl_smallFont,
inp->dat.inp.input + inp->dat.inp.view - 1);
if(n+10 < inp->w)
inp->dat.inp.view--;
}
}
else if((type == SDL_KEYDOWN) && (inp->dat.inp.pos < inp->dat.inp.max-1)) {
if((key == SDLK_RETURN) && !inp->dat.inp.oneline)
inp->dat.inp.input[inp->dat.inp.pos++] = '\n';
// Uppder case characters.
else if(isalpha(key) && (mods & (KMOD_LSHIFT | KMOD_RSHIFT)))
inp->dat.inp.input[inp->dat.inp.pos++] = toupper(key);
// Rest.
else if(!iscntrl(key))
inp->dat.inp.input[inp->dat.inp.pos++] = key;
// Didn't get a useful key.
else return 0;
n = gl_printWidth(&gl_smallFont, inp->dat.inp.input+inp->dat.inp.view);
if(n + 10 > inp->w) inp->dat.inp.view++;
return 1;
}
}
return 0;
}
// Render the window.
void toolkit_render(void) {
int i;
if(gl_has(OPENGL_AA_LINE)) glEnable(GL_LINE_SMOOTH);
if(gl_has(OPENGL_AA_POLYGON)) glEnable(GL_POLYGON_SMOOTH);
for(i = 0; i < nwindows; i++)
window_render(&windows[i]);
if(gl_has(OPENGL_AA_LINE)) glDisable(GL_LINE_SMOOTH);
if(gl_has(OPENGL_AA_POLYGON)) glDisable(GL_POLYGON_SMOOTH);
}
// Toolkit input is handled here.
// If we return 1, the input isn't passed.
int toolkit_input(SDL_Event* event) {
switch(event->type) {
case SDL_MOUSEMOTION:
case SDL_MOUSEBUTTONDOWN:
case SDL_MOUSEBUTTONUP:
toolkit_mouseEvent(event);
return 1; // Block input.
case SDL_KEYDOWN:
case SDL_KEYUP:
return toolkit_keyEvent(event);
}
return 0; // Don't block unput.
}
// Input.
static int mouse_down = 0;
static void toolkit_mouseEvent(SDL_Event* event) {
int i;
double x, y;
Window* w;
Widget* wgt, *wgt_func;
// Set mouse button status.
if(event->type == SDL_MOUSEBUTTONDOWN) mouse_down = 1;
else if(event->type == SDL_MOUSEBUTTONUP) mouse_down = 0;
// Absolute positions.
if(event->type == SDL_MOUSEMOTION) {
x = (double)event->motion.x;
y = gl_screen.h - (double)event->motion.y;
}
else if((event->type == SDL_MOUSEBUTTONDOWN) || (event->type == SDL_MOUSEBUTTONUP)) {
x = (double)event->button.x;
y = gl_screen.h - (double)event->motion.y;
}
w = &windows[nwindows-1];
// Always treat button ups to stop hanging states.
if((event->type != SDL_MOUSEBUTTONUP) &&
((x < w->x) || (x > (w->x + w->w)) || (y < w->y) || (y > (w->y + w->h))))
return; // Not in current window.
// Relative positions.
x -= w->x;
y -= w->y;
wgt_func = NULL;
for(i = 0; i < w->nwidgets; i++) {
wgt = &w->widgets[i];
// Widget in range?
if((x > wgt->x) && (x < (wgt->x + wgt->w)) &&
(y > wgt->y) && (y < (wgt->y + wgt->h))) {
// Custom widgets take it from here.
if((wgt->type == WIDGET_CUST) && wgt->dat.cst.mouse)
(*wgt->dat.cst.mouse)(event, x-wgt->x, y-wgt->y);
else
switch(event->type) {
case SDL_MOUSEMOTION:
if(!mouse_down)
wgt->status = WIDGET_STATUS_MOUSEOVER;
break;
case SDL_MOUSEBUTTONDOWN:
wgt->status = WIDGET_STATUS_MOUSEDOWN;
if(toolkit_isFocusable(wgt))
w->focus = i;
if(wgt->type == WIDGET_LIST)
toolkit_listFocus(wgt, x-wgt->x, y-wgt->y);
break;
case SDL_MOUSEBUTTONUP:
if(wgt->status == WIDGET_STATUS_MOUSEDOWN) {
if((wgt->type == WIDGET_BUTTON) &&
(wgt->dat.btn.disabled==0)) {
if(wgt->dat.btn.fptr == NULL)
DEBUG("Toolkit: Button '%s' of Window '%s'"
"Does not have a function trigger",
wgt->name, w->name);
else
wgt_func = wgt; // Run it at the end in case of close.
}
}
wgt->status = WIDGET_STATUS_NORMAL;
break;
}
}
else if((wgt->type == WIDGET_CUST) &&
(event->type == SDL_MOUSEBUTTONUP) && wgt->dat.cst.mouse)
(*wgt->dat.cst.mouse) (event, x-wgt->x, y-wgt->y);
else if(!mouse_down)
wgt->status = WIDGET_STATUS_NORMAL;
}
if(wgt_func) (*wgt_func->dat.btn.fptr)(wgt_func->name);
}
// Handle the key events.
static SDLKey input_key;
static unsigned int input_keyTime;
static int input_keyCounter;
static void toolkit_regKey(SDLKey key) {
if((input_key == 0) && (input_keyTime == 0)) {
input_key = key;
input_keyTime = SDL_GetTicks();
input_keyCounter = 0;
}
}
static void toolkit_unregKey(SDLKey key) {
if(input_key == key) {
input_key = 0;
input_keyTime = 0;
input_keyCounter = 0;
}
}
static int toolkit_keyEvent(SDL_Event* event) {
Window* wdw;
Widget* wgt;
SDLKey key;
if(nwindows <= 0) return 0;
wdw = &windows[nwindows-1];
wgt = (wdw->focus != -1) ? &wdw->widgets[wdw->focus] : NULL;
key = event->key.keysym.sym;
// Hack to simulate key repetition.
if((key == SDLK_BACKSPACE) || isalnum(key)) {
if(event->type == SDL_KEYDOWN) toolkit_regKey(key);
else if(event->type == SDL_KEYUP) toolkit_unregKey(key);
}
// Handle input widgets.
if(wgt && (wgt->type == WIDGET_INPUT))
// Grab all the events it wants.
if(toolkit_inputInput(event->type, wgt, key)) return 1;
switch(key) {
case SDLK_TAB:
if(event->type == SDL_KEYDOWN)
toolkit_nextFocus();
return 1;
case SDLK_RETURN:
if(event->type == SDL_KEYDOWN)
toolkit_triggerFocus();
return 1;
case SDLK_UP:
if(event->type == SDL_KEYDOWN) {
toolkit_regKey(SDLK_UP);
toolkit_listScroll(toolkit_getFocus(), +1);
}
else if(event->type == SDL_KEYUP)
toolkit_unregKey(SDLK_UP);
return 0;
case SDLK_DOWN:
if(event->type == SDL_KEYDOWN) {
toolkit_regKey(SDLK_DOWN);
toolkit_listScroll(toolkit_getFocus(), -1);
}
else if(event->type == SDL_KEYUP)
toolkit_unregKey(SDLK_DOWN);
return 0;
default:
return 0;
}
}
void toolkit_update(void) {
unsigned int t;
Window* wdw;
Widget* wgt;
t = SDL_GetTicks();
if(input_key == 0) return;
if(input_keyTime + INPUT_DELAY + input_keyCounter*INPUT_FREQ > t)
return;
input_keyCounter++;
if(nwindows > 0) {
wdw = &windows[nwindows-1];
wgt = (wdw->focus >= 0) ? &wdw->widgets[wdw->focus] : NULL;
if(wgt && (wgt->type == WIDGET_INPUT) &&
(input_key == SDLK_BACKSPACE || isalnum(input_key)))
toolkit_inputInput(SDL_KEYDOWN, wgt, input_key);
}
switch(input_key) {
case SDLK_UP:
toolkit_listScroll(toolkit_getFocus(), +1);
break;
case SDLK_DOWN:
toolkit_listScroll(toolkit_getFocus(), -1);
break;
default:
break;
}
}
// Focus next widget.
static void toolkit_nextFocus(void) {
Window* wdw = &windows[nwindows-1]; // Get active window.
if(wdw->nwidgets==0)
wdw->focus = -1;
else if(wdw->focus >= wdw->nwidgets)
wdw->focus = -1;
else if((++wdw->focus+1) && // Just increment.
toolkit_isFocusable(&wdw->widgets[wdw->focus]))
return;
else
toolkit_nextFocus();
}
// Return 1 if the window is focusable.
static int toolkit_isFocusable(Widget* wgt) {
if(wgt == NULL) return 0;
switch(wgt->type) {
case WIDGET_BUTTON:
if(wgt->dat.btn.disabled == 1) return 0;
case WIDGET_LIST:
case WIDGET_INPUT:
return 1;
default:
return 0;
}
}
static void toolkit_triggerFocus(void) {
Window* wdw;
Widget* wgt;
wdw = &windows[nwindows-1];
if(wdw->focus == -1) return;
wgt = &wdw->widgets[wdw->focus];
switch(wgt->type) {
case WIDGET_BUTTON:
if(wgt->dat.btn.fptr)(*wgt->dat.btn.fptr)(wgt->name);
else DEBUG("Toolkit: Button '%s' of Window '%s'"
"Doesn't have a function trigger",
wgt->name, wdw->name);
break;
default:
if(wdw->def_fptr)(*wdw->def_fptr)(wgt->name);
break;
}
}
// Try to scroll up/down by direction.
static void toolkit_listScroll(Widget* wgt, int direction) {
if(wgt == NULL) return;
switch(wgt->type) {
case WIDGET_LIST:
wgt->dat.lst.selected -= direction;
wgt->dat.lst.selected = MAX(0, wgt->dat.lst.selected);
wgt->dat.lst.selected = MIN(wgt->dat.lst.selected, wgt->dat.lst.noptions-1);
if(wgt->dat.lst.fptr) (*wgt->dat.lst.fptr)(wgt->name);
break;
default:
break;
}
}
// List mouse even focus.
static void toolkit_listFocus(Widget* lst, double bx, double by) {
(void)bx;
int i;
i = (lst->h - by) / (gl_defFont.h + 2.);
if(i< lst->dat.lst.noptions) {
// Should not be out of boundaries.
lst->dat.lst.selected = i;
toolkit_listScroll(lst, 0); // Check boundaries and trigger callback.
}
}
// Get what is selected currently in a list.
char* toolkit_getList(const unsigned int wid, char* name) {
Widget* wgt = window_getwgt(wid, name);
if((wgt->type != WIDGET_LIST) || (wgt->dat.lst.selected == -1))
return NULL;
return wgt->dat.lst.options[wgt->dat.lst.selected];
}
// Get the position of current item in the list.
int toolkit_getListPos(const unsigned int wid, char* name) {
Widget* wgt = window_getwgt(wid, name);
if((wgt->type != WIDGET_LIST) || (wgt->dat.lst.selected == -1))
return -1;
return wgt->dat.lst.selected;
}
// Return the focused widget.
static Widget* toolkit_getFocus(void) {
Window* wdw;
wdw = &windows[nwindows-1];
if(wdw->focus == -1) return NULL;
return &wdw->widgets[wdw->focus];
}
void dialogue_alert(const char* fmt, ...) {
char msg[512];
va_list ap;
unsigned int wdw;
int h;
if(window_exists("Warning")) return;
if(fmt == NULL) return;
else {
// Get the message.
va_start(ap, fmt);
vsprintf(msg, fmt, ap);
va_end(ap);
}
h = gl_printHeight(&gl_smallFont, 260, msg);
// Create window.
wdw = window_create("Warning", -1, -1, 300, 90+h);
window_addText(wdw, 20, -30, 260, h, 0, "txtAlert",
&gl_smallFont, &cBlack, msg);
window_addButton(wdw, 135, 20, 50, 30, "btnOK", "OK",
dialogue_alertClose);
}
static void dialogue_alertClose(char* str) {
(void)str;
if(window_exists("Warning"))
window_destroy(window_get("Warning"));
}
static glFont* dialogue_getSize(char* msg, int* w, int* h) {
glFont* font;
font = &gl_smallFont; // Try to use smallfont.
(*h) = gl_printHeight(font, (*w)-40, msg);
if(strlen(msg) > 100) {
// Make font bigger for large text area's.
font = &gl_defFont;
(*h) = gl_printHeight(font, (*w)-40, msg);
if((*h) > 200) (*w) += MIN((*h)-200, 600); // Too big, so we make it wider.
(*h) = gl_printHeight(font, (*w)-40, msg);
}
return font;
}
// Display an alert popup with only an OK button and a message.
static unsigned int msg_wid = 0;
void dialogue_msg(char* caption, const char* fmt, ...) {
char msg[4096];
va_list ap;
int w, h;
glFont* font;
if(msg_wid) return;
if(fmt == NULL) return;
else {
// Get the message.
va_start(ap, fmt);
vsprintf(msg, fmt, ap);
va_end(ap);
}
w = 300; // Default width.
font = dialogue_getSize(msg, &w, &h);
// Create the window.
msg_wid = window_create(caption, -1, -1, w, 110+h);
window_addText(msg_wid, 20, -40, w-40, h, 0, "txtMsg",
font, &cBlack, msg);
window_addButton(msg_wid, (w-50)/2, 20, 50, 30, "btnOK", "OK",
dialogue_msgClose);
toolkit_loop();
}
static void dialogue_msgClose(char* str) {
(void)str;
window_destroy(msg_wid);
msg_wid = 0;
loop_done = 1;
}
// Runs a dialogue with a Yes No button, return 1 if yes.
static int yesno_result;
static unsigned int yesno_wid = 0;
int dialogue_YesNo(char* caption, const char* fmt, ...) {
char msg[4096];
va_list ap;
int w, h;
glFont* font;
if(yesno_wid) return -1;
if(fmt == NULL) return -1;
else {
// Get the message.
va_start(ap, fmt);
vsprintf(msg, fmt, ap);
va_end(ap);
}
w = 300;
font = dialogue_getSize(msg, &w, &h);
// Create window.
yesno_wid = window_create(caption, -1, -1, w, h+110);
// Text.
window_addText(yesno_wid, 20, -40, w-40, h, 0, "txtYesNo",
font, &cBlack, msg);
// Buttons.
window_addButton(yesno_wid, w/2-50-10, 20, 50, 30, "btnYes", "Yes",
dialogue_YesNoClose);
window_addButton(yesno_wid, w/2+50+10, 20, 50, 30, "btnNo", "No",
dialogue_YesNoClose);
// Tricky secondary loop.
toolkit_loop();
// Return the result.
return yesno_result;
}
static void dialogue_YesNoClose(char* str) {
// Store the result.
if(strcmp(str, "btnYes")==0) yesno_result = 1;
else if(strcmp(str, "btnNo")==0) yesno_result = 0;
// Destroy the window.
window_destroy(yesno_wid);
yesno_wid = 0;
loop_done = 1;
}
// Toolkit input boxes, return input.
static unsigned int input_wid = 0;
char* dialogue_input(char* title, int min, int max, const char* fmt, ...) {
char msg[512], *input;
va_list ap;
int h;
if(input_wid) return NULL;
if(fmt == NULL) return NULL;
else {
// Get the message.
va_start(ap, fmt);
vsprintf(msg, fmt, ap);
va_end(ap);
}
// Get text height.
h = gl_printHeight(&gl_smallFont, 200, msg);
// Create the window.
input_wid = window_create(title, -1, -1, 240, h+140);
window_setFptr(input_wid, dialogue_inputClose);
// Text.
window_addText(input_wid, 30, -30, 200, h, 0, "txtInput",
&gl_smallFont, &cDConsole, msg);
// Input.
window_addInput(input_wid, 20, -50-h, 200, 20, "inpInput", max, 1);
//Button.
window_addButton(input_wid, -20, 20, 80, 30,
"btnClose", "Done", dialogue_inputClose);
// Tricky secondary loop.
input = NULL;
while(!input || ((int)strlen(input) < min)) {
// Must be longer than min.
if(input) {
dialogue_alert("Input must be at least %d characters long!", min);
free(input);
input = NULL;
}
if(toolkit_loop()) // Error in loop -> quit.
return NULL;
// Save the input.
input = strdup(window_getInput(input_wid, "inpInput"));
}
// Cleanup.
window_destroy(input_wid);
input_wid = 0;
return input;
}
static void dialogue_inputClose(char* str) {
(void)str;
// Break the loop.
loop_done = 1;
}
// Init.
int toolkit_init(void) {
windows = malloc(sizeof(Window)*MIN_WINDOWS);
nwindows = 0;
mwindows = MIN_WINDOWS;
SDL_ShowCursor(SDL_DISABLE);
return 0;
}
// Exit the toolkit.
void toolkit_exit(void) {
int i;
for(i = 0; i < nwindows; i++) {
window_destroy(windows[i].id);
free(windows);
}
}
// Spawns a secondary loop that only works until the toolkit dies.
// A lot like the main while loop in lephisto.c.
static int toolkit_loop(void) {
SDL_Event event, quit = { .type = SDL_QUIT };
loop_done = 0;
while(!loop_done && toolkit) {
while(SDL_PollEvent(&event)) {
// Event loopz.
if(event.type == SDL_QUIT) {
// Pass quit event to main engine.
loop_done = 1;
SDL_PushEvent(&quit);
return 1;
}
// Handles all the events and player keybinds.
input_handle(&event);
}
main_loop();
}
return 0;
}
Reference in New Issue View Git Blame Copy Permalink