AG_Label *
AG_StatusbarAddLabel(AG_Statusbar *sbar, const char *fmt, ...)
{
AG_Label *lab;
va_list ap;
AG_ObjectLock(sbar);
#ifdef AG_DEBUG
if (sbar->nlabels+1 >= AG_STATUSBAR_MAX_LABELS)
AG_FatalError("AG_StatusbarAddLabel: Too many labels");
#endif
sbar->labels[sbar->nlabels] = Malloc(sizeof(AG_Label));
lab = sbar->labels[sbar->nlabels];
AG_ObjectInit(lab, &agLabelClass);
lab->type = AG_LABEL_STATIC;
va_start(ap, fmt);
Vasprintf(&lab->text, fmt, ap);
va_end(ap);
AG_ExpandHoriz(lab);
AG_ObjectAttach(&sbar->box, lab);
lab = sbar->labels[sbar->nlabels++];
AG_ObjectUnlock(sbar);
AG_Redraw(sbar);
return (lab);
}
static void
SDLGL_Close(void *obj)
{
AG_Driver *drv = obj;
AG_DriverSDLGL *sgl = obj;
#ifdef AG_DEBUG
if (nDrivers != 1) { AG_FatalError("Driver close without open"); }
#endif
AG_FreeCursors(AGDRIVER(sgl));
if (AG_CfgBool("view.full-screen")) {
SDL_WM_ToggleFullScreen(sgl->s);
}
if (initedSDLVideo) {
SDL_QuitSubSystem(SDL_INIT_VIDEO);
initedSDLVideo = 0;
}
AG_ObjectDetach(drv->mouse);
AG_ObjectDestroy(drv->mouse);
AG_ObjectDetach(drv->kbd);
AG_ObjectDestroy(drv->kbd);
drv->mouse = NULL;
drv->kbd = NULL;
if (sgl->outMode != AG_SDLGL_OUT_NONE) {
Free(sgl->outBuf);
sgl->outBuf = NULL;
sgl->outMode = AG_SDLGL_OUT_NONE;
}
nDrivers = 0;
}
static void
Init(void *obj)
{
AG_Driver *drv = obj;
drv->id = 0;
drv->flags = 0;
drv->sRef = AG_SurfaceRGBA(1,1, 32, 0,
#if AG_BYTEORDER == AG_BIG_ENDIAN
0xff000000, 0x00ff0000, 0x0000ff00, 0x000000ff
#else
0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000
#endif
);
if (drv->sRef == NULL) {
AG_FatalError(NULL);
}
drv->videoFmt = NULL;
drv->kbd = NULL;
drv->mouse = NULL;
drv->cursors = NULL;
drv->nCursors = 0;
drv->activeCursor = NULL;
drv->gl = NULL;
AG_TextInitGlyphCache(drv);
}
static void
SDLGL_BeginRendering(void *obj)
{
AG_DriverSDLGL *sgl = obj;
AG_GL_Context *gl = &sgl->gl;
glPushAttrib(GL_VIEWPORT_BIT|GL_TRANSFORM_BIT|GL_LIGHTING_BIT|
GL_ENABLE_BIT);
if (AGDRIVER_SW(sgl)->flags & AG_DRIVER_SW_OVERLAY) {
AG_Driver *drv = obj;
/* Reinitialize Agar's OpenGL context. */
if (drv->gl != NULL) {
AG_GL_DestroyContext(drv);
}
if (AG_GL_InitContext(drv, gl) == -1) {
AG_FatalError(NULL);
}
AG_GL_SetViewport(gl,
AG_RECT(0, 0, AGDRIVER_SW(sgl)->w, AGDRIVER_SW(sgl)->h));
} else {
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
}
gl->clipStates[0] = glIsEnabled(GL_CLIP_PLANE0); glEnable(GL_CLIP_PLANE0);
gl->clipStates[1] = glIsEnabled(GL_CLIP_PLANE1); glEnable(GL_CLIP_PLANE1);
gl->clipStates[2] = glIsEnabled(GL_CLIP_PLANE2); glEnable(GL_CLIP_PLANE2);
gl->clipStates[3] = glIsEnabled(GL_CLIP_PLANE3); glEnable(GL_CLIP_PLANE3);
}
static void
RenderTextPolled(VG_Text *vt, VG_View *vv)
{
char val[64], s[VG_TEXT_MAX], *c;
int argIdx = 0;
s[0] = '\0';
for (c = &vt->text[0]; *c != '\0'; ) {
if (c[0] != '%') {
val[0] = *c;
val[1] = '\0';
Strlcat(s, val, sizeof(s));
c++;
continue;
}
if (c[1] == '\0' || c[1] == '%') {
val[0] = '%';
val[1] = '\0';
Strlcat(s, val, sizeof(s));
c+=2;
continue;
}
if ((argIdx+1) >= vt->args->n) {
AG_FatalError("Argument inconsistency");
}
AG_PrintVariable(val, sizeof(val), &vt->args->v[argIdx]);
Strlcat(s, val, sizeof(s));
c += vt->argSizes[argIdx++];
}
RenderText(vt, s, vv);
}
static void
OnAttach(AG_Event *event)
{
AG_Widget *parent = AG_SENDER();
if (!(AGDRIVER_CLASS(parent->drv)->flags & AG_DRIVER_OPENGL))
AG_FatalError("AG_GLView requires a driver with GL support");
}
static void
Close(AG_NetSocket *ns)
{
if (ns->fd != -1) {
close(ns->fd);
ns->fd = -1;
}
if (InitSocket(ns) == -1)
AG_FatalError(NULL);
}
static void
Close(AG_NetSocket *ns)
{
AG_MutexLock(&agNetWin32Lock);
if (ns->fd != -1) {
closesocket(ns->fd);
ns->fd = -1;
}
if (InitSocket(ns) == -1)
AG_FatalError(NULL);
AG_MutexUnlock(&agNetWin32Lock);
}
/* Write the den mappings. */
void
AG_DenWriteMappings(AG_Den *den)
{
Uint32 i;
AG_Seek(den->buf, den->mapoffs, AG_SEEK_SET);
for (i = 0; i < den->nmembers; i++) {
AG_DenMember *memb = &den->members[i];
AG_WriteUint32(den->buf, (Uint32)sizeof(memb->name));
if (AG_Write(den->buf, memb->name, sizeof(memb->name), 1) != 0)
AG_FatalError(NULL);
AG_WriteUint32(den->buf, (Uint32)sizeof(memb->lang));
if (AG_Write(den->buf, memb->lang, sizeof(memb->lang), 1) != 0)
AG_FatalError(NULL);
AG_WriteUint32(den->buf, (Uint32)memb->offs);
AG_WriteUint32(den->buf, (Uint32)memb->size);
}
}
static void
SDLGL_PopClipRect(void *obj)
{
AG_DriverSDLGL *sgl = obj;
AG_ClipRect *cr;
#ifdef AG_DEBUG
if (sgl->nClipRects < 1)
AG_FatalError("PopClipRect() without PushClipRect()");
#endif
cr = &sgl->clipRects[sgl->nClipRects-2];
sgl->nClipRects--;
glClipPlane(GL_CLIP_PLANE0, (const GLdouble *)&cr->eqns[0]);
glClipPlane(GL_CLIP_PLANE1, (const GLdouble *)&cr->eqns[1]);
glClipPlane(GL_CLIP_PLANE2, (const GLdouble *)&cr->eqns[2]);
glClipPlane(GL_CLIP_PLANE3, (const GLdouble *)&cr->eqns[3]);
}
static void
SDLGL_Close(void *obj)
{
AG_Driver *drv = obj;
AG_DriverSw *dsw = obj;
AG_DriverSDLGL *sgl = obj;
AG_DelEventSpinner(sglEventSpinner); sglEventSpinner = NULL;
AG_DelEventEpilogue(sglEventEpilogue); sglEventEpilogue = NULL;
if (drv->gl != NULL)
AG_GL_DestroyContext(sgl);
#ifdef AG_DEBUG
if (nDrivers != 1) { AG_FatalError("Driver close without open"); }
#endif
AG_FreeCursors(AGDRIVER(sgl));
if (dsw->flags & AG_DRIVER_SW_FULLSCREEN) {
if (SDL_WM_ToggleFullScreen(sgl->s))
dsw->flags &= ~(AG_DRIVER_SW_FULLSCREEN);
}
if (initedSDLVideo) {
SDL_QuitSubSystem(SDL_INIT_VIDEO);
initedSDLVideo = 0;
}
AG_ObjectDelete(drv->mouse); drv->mouse = NULL;
AG_ObjectDelete(drv->kbd); drv->kbd = NULL;
if (sgl->outMode != AG_SDLGL_OUT_NONE) {
Free(sgl->outBuf);
sgl->outBuf = NULL;
sgl->outMode = AG_SDLGL_OUT_NONE;
}
nDrivers = 0;
}
static void
Init(void *obj)
{
AG_DriverSw *dsw = obj;
dsw->w = 0;
dsw->h = 0;
dsw->depth = 0;
dsw->flags = 0;
dsw->winop = AG_WINOP_NONE;
dsw->winSelected = NULL;
dsw->winLastKeydown = NULL;
dsw->rNom = 20;
dsw->rCur = 0;
dsw->windowXOutLimit = 32;
dsw->windowBotOutLimit = 32;
dsw->windowIconWidth = 32;
dsw->windowIconHeight = 32;
if ((dsw->Lmodal = AG_ListNew()) == NULL)
AG_FatalError(NULL);
AG_SetString(dsw, "bgColor", "rgb(0,0,0)");
}
static void
Bound(AG_Event *event)
{
AG_FatalError("Use AG_TextboxBindUTF8() or AG_TextboxBindASCII()");
}
float
AG_FloatMismatch(void)
{
AG_FatalError("AG_FLOAT mismatch");
return (0.0);
}
void *
AG_ObjectMismatch(const char *t1, const char *t2)
{
AG_FatalError("Object type mismatch (%s != %s)", t1, t2);
return (NULL);
}
int
AG_IntMismatch(void)
{
AG_FatalError("AG_INT mismatch");
return (0);
}
/*
* Raise fatal error condition due to a type access mismatch in an event
* handler routine.
*/
void *
AG_PtrMismatch(void)
{
AG_FatalError("AG_PTR mismatch");
return (NULL);
}
/*
* Initialize Agar with an existing SDL display. If the display surface has
* flags SDL_OPENGL / SDL_OPENGLBLIT set, the "sdlgl" driver is selected;
* otherwise, the "sdlfb" driver is used.
*/
int
AG_InitVideoSDL(void *pDisplay, Uint flags)
{
SDL_Surface *display = pDisplay;
AG_Driver *drv = NULL;
AG_DriverClass *dc = NULL;
int useGL = 0;
int i;
if (AG_InitGUIGlobals() == -1)
return (-1);
/* Enable OpenGL mode if the surface has SDL_OPENGL set. */
if (display->flags & (SDL_OPENGL|SDL_OPENGLBLIT)) {
if (flags & AG_VIDEO_SDL) {
AG_SetError("AG_VIDEO_SDL flag requested, but "
"display surface has SDL_OPENGL set");
goto fail;
}
useGL = 1;
} else {
if (flags & AG_VIDEO_OPENGL) {
AG_SetError("AG_VIDEO_OPENGL flag requested, but "
"display surface is missing SDL_OPENGL");
goto fail;
}
}
for (i = 0; i < agDriverListSize; i++) {
dc = agDriverList[i];
if (dc->wm == AG_WM_SINGLE &&
(dc->flags & AG_DRIVER_SDL) &&
(!useGL || (dc->flags & AG_DRIVER_OPENGL)) &&
(drv = AG_DriverOpen(dc)) != NULL)
break;
}
if (i == agDriverListSize) {
AG_SetError("No compatible SDL driver is available");
goto fail;
}
/* Open a video display. */
if (AGDRIVER_SW_CLASS(drv)->openVideoContext(drv, (void *)display,
flags) == -1) {
AG_DriverClose(drv);
goto fail;
}
if (drv->videoFmt == NULL)
AG_FatalError("Driver did not set video format");
/* Generic Agar-GUI initialization. */
if (AG_InitGUI(0) == -1) {
AG_DriverClose(drv);
goto fail;
}
agDriverOps = dc;
agDriverSw = AGDRIVER_SW(drv);
#ifdef AG_LEGACY
agView = drv;
#endif
return (0);
fail:
AG_DestroyGUIGlobals();
return (-1);
}
void *
M_MatrixRead_SP(AG_DataSource *buf)
{
AG_FatalError("Unimplemented function");
return (NULL);
}
void
M_MatrixWrite_SP(AG_DataSource *buf, const void *pA)
{
AG_FatalError("Unimplemented function");
}
