static void
Draw(void *obj)
{
AG_Slider *sl = obj;
int x;
if (GetPosition(sl, &x) == -1) {
return;
}
switch (sl->type) {
case AG_SLIDER_VERT:
AG_DrawBox(sl, AG_RECT(0,0,WIDTH(sl),HEIGHT(sl)), -1, WCOLOR(sl,0));
AG_DrawBox(sl,
AG_RECT(0, x, WIDTH(sl), sl->wControl),
sl->ctlPressed ? -1 : 1,
WCOLOR(sl,0));
break;
case AG_SLIDER_HORIZ:
AG_DrawBox(sl, AG_RECT(0,0,WIDTH(sl),HEIGHT(sl)), -1, WCOLOR(sl,0));
AG_DrawBox(sl,
AG_RECT(x, 0, sl->wControl, HEIGHT(sl)),
sl->ctlPressed ? -1 : 1,
WCOLOR(sl,0));
break;
}
}
static void
Draw(void *p)
{
AG_Button *bu = p;
AG_Variable *binding;
void *pState;
int pressed;
binding = AG_GetVariable(bu, "state", &pState);
pressed = GetState(bu, binding, pState);
AG_UnlockVariable(binding);
if (AG_WidgetEnabled(bu)) {
AG_DrawBox(bu,
AG_RECT(0, 0, WIDTH(bu), HEIGHT(bu)),
pressed ? -1 : 1,
WCOLOR(bu,0));
} else {
AG_DrawBoxDisabled(bu,
AG_RECT(0, 0, WIDTH(bu), HEIGHT(bu)),
pressed ? -1 : 1,
WCOLOR_DEF(bu,0),
WCOLOR_DIS(bu,0));
}
if (bu->lbl != NULL) {
AG_WidgetDraw(bu->lbl);
} else if (bu->surface != -1) {
int w = WSURFACE(bu,bu->surface)->w;
int h = WSURFACE(bu,bu->surface)->h;
int x = 0, y = 0;
switch (bu->justify) {
case AG_TEXT_LEFT: x = bu->lPad; break;
case AG_TEXT_CENTER: x = WIDTH(bu)/2 - w/2; break;
case AG_TEXT_RIGHT: x = WIDTH(bu) - w - bu->rPad; break;
}
switch (bu->valign) {
case AG_TEXT_TOP: y = bu->tPad; break;
case AG_TEXT_MIDDLE: y = HEIGHT(bu)/2 - h/2; break;
case AG_TEXT_BOTTOM: y = HEIGHT(bu) - h - bu->bPad; break;
}
if (pressed) {
x++;
y++;
}
AG_WidgetBlitSurface(bu, bu->surface, x, y);
}
}
AG_Surface *
AG_SDL_ShadowSurface(SDL_Surface *ss)
{
AG_PixelFormat *pf;
AG_Surface *ds;
if ((pf = AG_SDL_GetPixelFormat(ss)) == NULL) {
return (NULL);
}
if (pf->palette != NULL) {
AG_SetError("Indexed formats not supported");
AG_PixelFormatFree(pf);
return (NULL);
}
if ((ds = AG_SurfaceNew(AG_SURFACE_PACKED, 0, 0, pf, 0))
== NULL) {
goto out;
}
if (ss->flags & SDL_SRCCOLORKEY) { ds->flags |= AG_SRCCOLORKEY; }
if (ss->flags & SDL_SRCALPHA) { ds->flags |= AG_SRCALPHA; }
ds->pixels = ss->pixels;
ds->w = ss->w;
ds->h = ss->h;
ds->pitch = ds->w * pf->BytesPerPixel;
ds->clipRect = AG_RECT(0,0,ds->w,ds->h);
out:
AG_PixelFormatFree(pf);
return (ds);
}
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
SDLGL_BeginRendering(void *obj)
{
AG_DriverSDLGL *sgl = obj;
#if defined(AG_THREADS) && defined(HAVE_GETTIMEOFDAY) && \
defined(HAVE_CLOCK_GETTIME) && !defined(HAVE_CYGWIN)
{
extern AG_Cond agCondBeginRender;
/* Suspend any AG_Delay()'ed threads. */
AG_CondBroadcast(&agCondBeginRender);
}
#endif
glPushAttrib(GL_VIEWPORT_BIT|GL_TRANSFORM_BIT|GL_LIGHTING_BIT|
GL_ENABLE_BIT);
if (AGDRIVER_SW(sgl)->flags & AG_DRIVER_SW_OVERLAY) {
AG_GL_InitContext(
AG_RECT(0, 0, AGDRIVER_SW(sgl)->w, AGDRIVER_SW(sgl)->h));
} else {
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
}
sgl->clipStates[0] = glIsEnabled(GL_CLIP_PLANE0);
glEnable(GL_CLIP_PLANE0);
sgl->clipStates[1] = glIsEnabled(GL_CLIP_PLANE1);
glEnable(GL_CLIP_PLANE1);
sgl->clipStates[2] = glIsEnabled(GL_CLIP_PLANE2);
glEnable(GL_CLIP_PLANE2);
sgl->clipStates[3] = glIsEnabled(GL_CLIP_PLANE3);
glEnable(GL_CLIP_PLANE3);
}
/* Resize an animation; pixels are left uninitialized. */
int
AG_AnimResize(AG_Anim *a, Uint w, Uint h)
{
Uint8 *pixelsNew;
int i;
int pitchNew;
AG_MutexLock(&a->lock);
pitchNew = w*a->format->BytesPerPixel;
for (i = 0; i < a->n; i++) {
AG_AnimFrame *af = &a->f[i];
if ((pixelsNew = TryRealloc(af->pixels, h*pitchNew)) == NULL) {
for (i--; i >= 0; i--) {
Free(af->pixels);
}
goto fail;
}
af->pixels = pixelsNew;
}
a->pitch = pitchNew;
a->w = w;
a->h = h;
a->clipRect = AG_RECT(0,0,w,h);
AG_MutexUnlock(&a->lock);
return (0);
fail:
AG_MutexUnlock(&a->lock);
return (-1);
}
static void
Init(void *obj)
{
AG_Textbox *tb = obj;
WIDGET(tb)->flags |= AG_WIDGET_TABLE_EMBEDDABLE;
tb->ed = AG_EditableNew(tb, 0);
tb->lbl = NULL;
tb->boxPadX = 2;
tb->boxPadY = 2;
tb->flags = 0;
tb->hBar = NULL;
tb->vBar = NULL;
tb->r = AG_RECT(0,0,0,0);
tb->font = NULL;
AG_SetEvent(tb, "mouse-button-down", MouseButtonDown, NULL);
AG_SetEvent(tb, "widget-disabled", Disabled, NULL);
AG_SetEvent(tb, "widget-enabled", Enabled, NULL);
AG_SetEvent(tb->ed, "editable-prechg", EditablePreChg, "%p", tb);
AG_SetEvent(tb->ed, "editable-postchg", EditablePostChg, "%p", tb);
AG_SetEvent(tb->ed, "editable-return", EditableReturn, "%p", tb);
AG_WidgetForwardFocus(tb, tb->ed);
#ifdef AG_DEBUG
AG_BindUint(tb, "flags", &tb->flags);
AG_BindInt(tb, "boxPadX", &tb->boxPadX);
AG_BindInt(tb, "boxPadY", &tb->boxPadY);
AG_SetEvent(tb, "bound", Bound, NULL);
#endif /* AG_DEBUG */
}
/* Initialize the clipping rectangle stack. */
static int
InitClipRects(AG_DriverSDLGL *sgl, int wView, int hView)
{
AG_ClipRect *cr;
int i;
for (i = 0; i < 4; i++)
sgl->clipStates[i] = 0;
/* Rectangle 0 always covers the whole view. */
if ((sgl->clipRects = TryMalloc(sizeof(AG_ClipRect))) == NULL)
return (-1);
cr = &sgl->clipRects[0];
cr->r = AG_RECT(0, 0, wView, hView);
cr->eqns[0][0] = 1.0; cr->eqns[0][1] = 0.0;
cr->eqns[0][2] = 0.0; cr->eqns[0][3] = 0.0;
cr->eqns[1][0] = 0.0; cr->eqns[1][1] = 1.0;
cr->eqns[1][2] = 0.0; cr->eqns[1][3] = 0.0;
cr->eqns[2][0] = -1.0; cr->eqns[2][1] = 0.0;
cr->eqns[2][2] = 0.0; cr->eqns[2][3] = (double)wView;
cr->eqns[3][0] = 0.0; cr->eqns[3][1] = -1.0;
cr->eqns[3][2] = 0.0; cr->eqns[3][3] = (double)hView;
sgl->nClipRects = 1;
return (0);
}
/* Create a new animation of the specified pixel format. */
AG_Anim *
AG_AnimNew(enum ag_anim_type type, Uint w, Uint h, const AG_PixelFormat *pf,
Uint flags)
{
AG_Anim *a;
if ((a = TryMalloc(sizeof(AG_Anim))) == NULL) {
return (NULL);
}
if ((a->format = AG_PixelFormatDup(pf)) == NULL) {
Free(a);
return (NULL);
}
a->type = type;
a->flags = flags;
a->w = w;
a->h = h;
a->n = 0;
a->pitch = w*pf->BytesPerPixel;
a->clipRect = AG_RECT(0,0,w,h);
a->f = NULL;
a->fpsOrig = 30.0;
AG_MutexInitRecursive(&a->lock);
return (a);
}
static void
Draw(void *obj)
{
AG_Titlebar *tbar = obj;
AG_DrawBox(tbar,
AG_RECT(0, 0, WIDTH(tbar), HEIGHT(tbar)),
tbar->pressed ? -1 : 1,
AG_WindowIsFocused(tbar->win) ? WCOLOR(tbar,0) : WCOLOR_DIS(tbar,0));
WIDGET_SUPER_OPS(tbar)->draw(tbar);
}
static void
Draw(void *p)
{
AG_Textbox *tb = p;
STYLE(tb)->TextboxBackground(tb, tb->r, (tb->flags & AG_TEXTBOX_COMBO));
if (tb->lbl != NULL)
AG_WidgetDraw(tb->lbl);
AG_PushClipRect(tb, tb->r);
if (tb->flags & AG_TEXTBOX_MULTILINE) {
int d;
if (tb->vBar != NULL && AG_ScrollbarVisible(tb->vBar)) {
d = WIDTH(tb->vBar);
AG_DrawBox(tb,
AG_RECT(WIDTH(tb)-d, HEIGHT(tb)-d, d, d), -1,
agColors[TEXTBOX_COLOR]);
} else if (tb->hBar != NULL && AG_ScrollbarVisible(tb->hBar)) {
d = HEIGHT(tb->hBar);
AG_DrawBox(tb,
AG_RECT(WIDTH(tb)-d, HEIGHT(tb)-d, d, d), -1,
agColors[TEXTBOX_COLOR]);
}
AG_WidgetUpdate(tb);
}
/* Render the Editable widget, inheriting our Font. */
tb->ed->font = tb->font;
AG_WidgetDraw(tb->ed);
if (tb->hBar != NULL)
AG_WidgetDraw(tb->hBar);
if (tb->vBar != NULL)
AG_WidgetDraw(tb->vBar);
AG_PopClipRect(tb);
}
void osdCheckbox(void *cbox, int state, int size) {
AG_Rect r = AG_RECT(0, 0, size, size);
AG_DrawBox(cbox, r, 1, agColors[CHECKBOX_COLOR]);
if (state) {
float a = 3;
r.x += a; r.y += a; r.w -= a * 2; r.h -= a * 2;
AG_DrawBox(cbox, r, 1, AG_ColorRGB(255, 255, 255));
}
}
static int
SDLGL_OpenVideoContext(void *obj, void *ctx, Uint flags)
{
AG_DriverSDLGL *sgl = obj;
AG_DriverSw *dsw = obj;
AG_Driver *drv = obj;
SDL_Surface *ctxSu = (SDL_Surface *)ctx;
if (!(ctxSu->flags & SDL_OPENGL)) {
AG_SetError("Given display surface is not SDL_OPENGL");
return (-1);
}
/* Set the requested display options. */
if (flags & AG_VIDEO_OVERLAY)
dsw->flags |= AG_DRIVER_SW_OVERLAY;
if (flags & AG_VIDEO_BGPOPUPMENU)
dsw->flags |= AG_DRIVER_SW_BGPOPUP;
/* Use the given display surface. */
sgl->s = (SDL_Surface *)ctx;
if ((drv->videoFmt = AG_SDL_GetPixelFormat(sgl->s)) == NULL) {
goto fail;
}
dsw->w = sgl->s->w;
dsw->h = sgl->s->h;
dsw->depth = (Uint)drv->videoFmt->BitsPerPixel;
Verbose(_("SDLGL: Using existing display (%ux%ux%d bpp)\n"),
dsw->w, dsw->h, (int)drv->videoFmt->BitsPerPixel);
/* Initialize our OpenGL context and viewport. */
if (AG_GL_InitContext(sgl, &sgl->gl) == -1) {
goto fail;
}
AG_GL_SetViewport(&sgl->gl, AG_RECT(0, 0, dsw->w, dsw->h));
/* Create the cursors. */
if (AG_SDL_InitDefaultCursor(sgl) == -1 ||
AG_InitStockCursors(drv) == -1)
goto fail;
return (0);
fail:
if (drv->videoFmt) {
AG_PixelFormatFree(drv->videoFmt);
drv->videoFmt = NULL;
}
return (-1);
}
static void
Draw(void *obj)
{
AG_Box *box = obj;
AG_Widget *chld;
if (box->flags & AG_BOX_FRAME) {
AG_DrawBox(box,
AG_RECT(0, 0, WIDTH(box), HEIGHT(box)),
box->depth, WCOLOR(box,AG_COLOR));
}
OBJECT_FOREACH_CHILD(chld, box, ag_widget)
AG_WidgetDraw(chld);
}
static void
Init(void *obj)
{
AG_FontSelector *fs = obj;
fs->flags = AG_FONTSELECTOR_UPDATE;
fs->hPane = AG_PaneNewHoriz(fs, AG_PANE_EXPAND);
fs->tlFaces = AG_TlistNew(fs->hPane->div[0], AG_TLIST_EXPAND);
fs->hPane2 = AG_PaneNewHoriz(fs->hPane->div[1], AG_PANE_EXPAND);
fs->tlStyles = AG_TlistNew(fs->hPane2->div[0], AG_TLIST_EXPAND);
fs->sizeBox = AG_BoxNewVert(fs->hPane2->div[1], AG_BOX_EXPAND);
fs->tlSizes = AG_TlistNew(fs->sizeBox, AG_TLIST_EXPAND);
fs->font = NULL;
fs->curFace[0] = '\0';
fs->curStyle = 0;
fs->curSize = 0;
fs->rPreview = AG_RECT(0,0,0,64);
fs->sPreview = -1;
AG_TlistSizeHint(fs->tlFaces, "XXXXXXXXXXXXXXX", 8);
AG_TlistSizeHint(fs->tlStyles, "XXXXXXXXX", 8);
AG_TlistSizeHint(fs->tlSizes, "100", 8);
AG_BindPointer(fs, "font", (void *)&fs->font);
AG_SetEvent(fs, "bound", Bound, NULL);
AG_AddEvent(fs, "widget-shown", UpdateFaces, NULL);
AG_SetEvent(fs->tlFaces, "tlist-selected", SelectedFace, "%p", fs);
AG_SetEvent(fs->tlStyles, "tlist-selected", SelectedStyle, "%p", fs);
AG_SetEvent(fs->tlSizes, "tlist-selected", SelectedSize, "%p", fs);
#ifdef AG_DEBUG
AG_BindUint(fs, "flags", &fs->flags);
/* AG_BindString(fs, "curFace", fs->curFace, sizeof(fs->curFace)); */
AG_BindUint(fs, "curStyle", &fs->curStyle);
AG_BindInt(fs, "curSize", &fs->curSize);
AG_BindInt(fs, "sPreview", &fs->sPreview);
#endif
}
static void
Draw(void *obj)
{
AG_HSVPal *pal = obj;
float cur_h, cur_s, cur_v;
Uint8 r, g, b, a;
int x, y;
if (pal->surface == NULL) {
if ((pal->surface = AG_SurfaceStdGL(WIDTH(pal), HEIGHT(pal)))
== NULL) {
return;
}
pal->surfaceId = AG_WidgetMapSurface(pal, pal->surface);
}
if (pal->flags & AG_HSVPAL_DIRTY) {
pal->flags &= ~(AG_HSVPAL_DIRTY);
RenderPalette(pal);
AG_WidgetUpdateSurface(pal, pal->surfaceId);
}
cur_h = (AG_GetFloat(pal, "hue") / 360.0) * 2*AG_PI;
cur_s = AG_GetFloat(pal, "saturation");
cur_v = AG_GetFloat(pal, "value");
a = (Uint8)(AG_GetFloat(pal, "alpha")*255);
AG_WidgetBlitFrom(pal, pal, pal->surfaceId, NULL, 0, 0);
/* Indicate the current selection. */
AG_DrawCircle(pal,
pal->circle.x + (pal->circle.rin + pal->circle.width/2)*Cos(cur_h),
pal->circle.y + (pal->circle.rin + pal->circle.width/2)*Sin(cur_h),
pal->selcircle_r,
AG_ColorRGB(0,0,0));
/* The rendering routine uses (v = 1 - x/h), so (x = -v*h + h). */
y = (int)((1.0 - cur_s) * (float)pal->triangle.h);
x = (int)(-(cur_v*(float)pal->triangle.h - (float)pal->triangle.h));
if (x < 0) { x = 0; }
if (x > y) { x = y; }
AG_DrawCircle(pal,
pal->triangle.x + x - y/2,
pal->triangle.y + y,
pal->selcircle_r,
AG_ColorRGB(0,0,0));
x = a*pal->rAlpha.w/255;
if (x > pal->rAlpha.w-3) { x = pal->rAlpha.w-3; }
AG_HSV2RGB((cur_h*360.0)/(2*AG_PI), cur_s, cur_v, &r, &g, &b);
/* Draw the color preview. */
if (!(pal->flags & AG_HSVPAL_NOPREVIEW)) {
AG_DrawRectFilled(pal,
AG_RECT(pal->rAlpha.x, pal->rAlpha.y, pal->rAlpha.w, 8),
AG_ColorRGB(r,g,b));
}
/* Draw the transparency color preview. */
if (!(pal->flags & AG_HSVPAL_NOALPHA)) {
AG_DrawLineV(pal,
pal->rAlpha.x + x,
pal->rAlpha.y + 1,
pal->rAlpha.y + pal->rAlpha.h,
AG_ColorRGBA(0,0,0,0));
AG_DrawLineV(pal,
pal->rAlpha.x + x + 1,
pal->rAlpha.y + 1,
pal->rAlpha.y + pal->rAlpha.h,
AG_ColorRGBA(240,240,240,0));
AG_DrawLineV(pal,
pal->rAlpha.x + x + 2,
pal->rAlpha.y + 1,
pal->rAlpha.y + pal->rAlpha.h,
AG_ColorRGBA(0,0,0,0));
}
/* Display RGB/HSV values */
if (pal->flags & (AG_HSVPAL_SHOW_RGB|AG_HSVPAL_SHOW_HSV)) {
AG_Surface *s;
/* XXX inefficient */
AG_PushTextState();
AG_TextBGColorRGB(0,0,0);
AG_TextColorRGB(255,255,255);
if ((pal->flags & AG_HSVPAL_SHOW_RGB) &&
(pal->flags & AG_HSVPAL_SHOW_HSV)) {
s = AG_TextRenderf(
"RGB: %u,%u,%u\n"
"HSV: %.02f,%.02f,%.02f",
r, g, b,
(cur_h*360.0)/(2.0*AG_PI),
cur_s, cur_v);
} else if (pal->flags & AG_HSVPAL_SHOW_RGB) {
s = AG_TextRenderf("RGB: %u,%u,%u", r, g, b);
} else {
s = AG_TextRenderf("HSV: %.01f,%.02f,%.02f",
(cur_h*360.0)/(2.0*AG_PI),
cur_s, cur_v);
}
AG_WidgetBlit(pal, s,
WIDTH(pal)/2 - s->w/2,
pal->rAlpha.y + pal->rAlpha.h/2 - s->h/2);
AG_SurfaceFree(s);
AG_PopTextState();
}
}
static int
SDLGL_OpenVideo(void *obj, Uint w, Uint h, int depth, Uint flags)
{
char buf[16];
AG_Driver *drv = obj;
AG_DriverSw *dsw = obj;
AG_DriverSDLGL *sgl = obj;
Uint32 sFlags = SDL_OPENGL;
int newDepth;
/* Set the requested display options. */
if (flags & AG_VIDEO_RESIZABLE) { sFlags |= SDL_RESIZABLE; }
if (flags & AG_VIDEO_ANYFORMAT) { sFlags |= SDL_ANYFORMAT; }
if (flags & AG_VIDEO_HWPALETTE) { sFlags |= SDL_HWPALETTE; }
if (flags & AG_VIDEO_DOUBLEBUF) { sFlags |= SDL_DOUBLEBUF; }
if (flags & AG_VIDEO_FULLSCREEN) { sFlags |= SDL_FULLSCREEN; }
if (flags & AG_VIDEO_NOFRAME) { sFlags |= SDL_NOFRAME; }
if (flags & AG_VIDEO_OVERLAY)
dsw->flags |= AG_DRIVER_SW_OVERLAY;
if (flags & AG_VIDEO_BGPOPUPMENU)
dsw->flags |= AG_DRIVER_SW_BGPOPUP;
/* Apply the output capture settings. */
if (AG_Defined(drv, "out")) {
char *ext;
AG_GetString(drv, "out", buf, sizeof(buf));
if ((ext = strrchr(buf, '.')) != NULL &&
ext[1] != '\0') {
if (Strcasecmp(&ext[1], "jpeg") == 0 ||
Strcasecmp(&ext[1], "jpg") == 0) {
sgl->outMode = AG_SDLGL_OUT_JPEG;
if ((sgl->outPath = TryStrdup(buf)) == NULL)
return (-1);
} else if (Strcasecmp(&ext[1], "png") == 0) {
sgl->outMode = AG_SDLGL_OUT_PNG;
if ((sgl->outPath = TryStrdup(buf)) == NULL)
return (-1);
} else {
AG_SetError("Invalid out= argument: `%s'", buf);
return (-1);
}
if (AG_Defined(drv, "outFirst")) {
AG_GetString(drv, "outFirst", buf, sizeof(buf));
sgl->outFrame = atoi(buf);
} else {
sgl->outFrame = 0;
}
if (AG_Defined(drv, "outLast")) {
AG_GetString(drv, "outLast", buf, sizeof(buf));
sgl->outLast = atoi(buf);
}
}
}
/* Apply the default resolution settings. */
if (w == 0 && AG_Defined(drv, "width")) {
AG_GetString(drv, "width", buf, sizeof(buf));
w = atoi(buf);
}
if (h == 0 && AG_Defined(drv, "height")) {
AG_GetString(drv, "height", buf, sizeof(buf));
h = atoi(buf);
}
if (depth == 0 && AG_Defined(drv, "depth")) {
AG_GetString(drv, "depth", buf, sizeof(buf));
depth = atoi(buf);
}
/* Set the video mode. Force hardware palette in 8bpp. */
Verbose(_("SDLGL: Setting mode %dx%d (%d bpp)\n"), w, h, depth);
newDepth = SDL_VideoModeOK(w, h, depth, sFlags);
if (newDepth == 8) {
Verbose(_("Enabling hardware palette"));
sFlags |= SDL_HWPALETTE;
}
if ((sgl->s = SDL_SetVideoMode((int)w, (int)h, newDepth, sFlags))
== NULL) {
AG_SetError("Setting %dx%dx%d mode: %s", w, h, newDepth,
SDL_GetError());
return (-1);
}
SDL_EnableUNICODE(1);
if ((drv->videoFmt = AG_SDL_GetPixelFormat(sgl->s)) == NULL) {
goto fail;
}
dsw->w = sgl->s->w;
dsw->h = sgl->s->h;
dsw->depth = (Uint)drv->videoFmt->BitsPerPixel;
Verbose(_("SDLGL: New display (%dbpp)\n"),
(int)drv->videoFmt->BitsPerPixel);
/* Initialize clipping rectangles. */
if (InitClipRects(sgl, dsw->w, dsw->h) == -1)
goto fail;
/* Create the cursors. */
if (AG_SDL_InitDefaultCursor(sgl) == -1 ||
AG_InitStockCursors(drv) == -1)
goto fail;
/* Initialize the GL viewport. */
AG_GL_InitContext(
AG_RECT(0, 0, AGDRIVER_SW(sgl)->w, AGDRIVER_SW(sgl)->h));
if (!(dsw->flags & AG_DRIVER_SW_OVERLAY)) {
ClearBackground();
}
/* Initialize the output capture buffer. */
Free(sgl->outBuf);
if ((sgl->outBuf = AG_TryMalloc(dsw->w*dsw->h*4)) == NULL) {
AG_Verbose("Out of memory for buffer; disabling capture\n");
sgl->outMode = AG_SDLGL_OUT_NONE;
}
/* Toggle fullscreen if requested. */
if (AG_CfgBool("view.full-screen")) {
if (!SDL_WM_ToggleFullScreen(sgl->s))
AG_SetCfgBool("view.full-screen", 0);
}
return (0);
fail:
if (drv->videoFmt) {
AG_PixelFormatFree(drv->videoFmt);
drv->videoFmt = NULL;
}
return (-1);
}
int
main(int argc, char *argv[])
{
#ifdef HAVE_SDL
AG_Window *win;
SDL_Surface *screen, *bmp, *tex1, *tex2, *avatar;
AG_Surface *agbmp, *agavatar;
int c, useGL = 0;
Uint32 sdlFlags = 0;
char *optArg;
Uint32 rmask, gmask, bmask, amask;
if (AG_InitCore("agar-sdl-demo", 0) == -1) {
fprintf(stderr, "AG_InitCore: %s\n", AG_GetError());
goto fail;
}
while ((c = AG_Getopt(argc, argv, "?g", &optArg, NULL)) != -1) {
switch (c) {
case 'g':
useGL = 1;
break;
default:
printf("Usage: %s [-g]\n", agProgName);
break;
}
}
/* Set up SDL */
if (SDL_Init(SDL_INIT_VIDEO) == -1) {
fprintf(stderr, "SDL_Init: %s\n", SDL_GetError());
return (1);
}
if (useGL) {
sdlFlags = SDL_RESIZABLE|SDL_OPENGL;
} else {
sdlFlags = SDL_RESIZABLE|SDL_SWSURFACE;
}
if ((screen = SDL_SetVideoMode(320, 240, 32, sdlFlags)) == NULL) {
fprintf(stderr, "SDL_SetVideoMode: %s\n", SDL_GetError());
goto fail;
}
if (useGL) {
/* Set up OpenGL viewport and projection. */
AG_GL_InitContext(AG_RECT(0,0,320,240));
}
/* Initialize Agar-GUI to reuse display */
if (AG_InitVideoSDL(screen, 0) == -1) {
fprintf(stderr, "%s\n", AG_GetError());
AG_Destroy();
goto fail;
}
AG_BindGlobalKey(AG_KEY_ESCAPE, AG_KEYMOD_ANY, AG_QuitGUI);
/* Display some test widgets. */
win = AG_WindowNew(AG_WINDOW_PLAIN);
AG_LabelNew(win, 0, "Attached to existing %s display",
useGL ? "SDL/OpenGL" : "SDL");
/* Test conversion from SDL_Surface to AG_Surface. */
if ((bmp = SDL_LoadBMP("agar.bmp")) != NULL) {
if ((agbmp = AG_SurfaceFromSDL(bmp)) != NULL) {
AG_PixmapFromSurface(win, 0, agbmp);
} else {
AG_LabelNewS(win, 0, AG_GetError());
}
}
#ifdef HAVE_SDL_IMAGE
if ((tex1 = IMG_Load("test1.png")) == NULL ||
(tex2 = IMG_Load("test2.png")) == NULL) {
fprintf(stderr, "IMG_Load() failed\n");
goto fail;
}
# if SDL_BYTEORDER == SDL_BIG_ENDIAN
rmask = 0xff000000;
gmask = 0x00ff0000;
bmask = 0x0000ff00;
amask = 0x000000ff;
# else
rmask = 0x000000ff;
gmask = 0x0000ff00;
bmask = 0x00ff0000;
amask = 0xff000000;
# endif
avatar = SDL_CreateRGBSurface(SDL_SWSURFACE|SDL_SRCALPHA, 64, 128,
tex1->format->BitsPerPixel, rmask, gmask, bmask, amask);
SDL_SetAlpha(tex1, 0, 0);
SDL_BlitSurface(tex1, NULL, avatar, NULL);
SDL_SetAlpha(tex2, SDL_SRCALPHA, 0);
SDL_BlitSurface(tex2, NULL, avatar, NULL);
if ((agavatar = AG_SurfaceFromSDL(avatar)) != NULL) {
AG_PixmapFromSurface(win, 0, agavatar);
} else {
AG_LabelNewS(win, 0, AG_GetError());
}
#endif /* HAVE_SDL_IMAGE */
AG_WindowShow(win);
AG_EventLoop();
AG_Destroy();
SDL_Quit();
return (0);
fail:
SDL_Quit();
return (1);
#else
fprintf(stderr, "Agar was compiled without SDL support\n");
return (1);
#endif /* HAVE_SDL */
}
void
AG_GLViewDraw(void *obj)
{
AG_GLView *glv = obj;
AG_Driver *drv = WIDGET(glv)->drv;
Uint hView;
if (glv->flags & AG_GLVIEW_BGFILL) {
AG_DrawRect(glv,
AG_RECT(0,0, WIDTH(glv), HEIGHT(glv)),
glv->bgColor);
}
if (glv->underlay_ev != NULL)
glv->underlay_ev->handler(glv->underlay_ev);
glPushAttrib(GL_TRANSFORM_BIT | GL_VIEWPORT_BIT);
if (glv->flags & AG_GLVIEW_INIT_MATRICES) {
glv->flags &= ~(AG_GLVIEW_INIT_MATRICES);
SetIdentity(glv->mProjection, GL_PROJECTION);
SetIdentity(glv->mModelview, GL_MODELVIEW);
SetIdentity(glv->mTexture, GL_TEXTURE);
}
if (glv->flags & AG_GLVIEW_RESHAPE) {
glv->flags &= ~(AG_GLVIEW_RESHAPE);
AG_GLViewReshape(glv);
}
if (AGDRIVER_SINGLE(drv)) {
hView = AGDRIVER_SW(drv)->h;
} else {
hView = HEIGHT(WIDGET(glv)->window);
}
glViewport(WIDGET(glv)->rView.x1,
hView - WIDGET(glv)->rView.y2,
WIDTH(glv), HEIGHT(glv));
glMatrixMode(GL_TEXTURE);
glPushMatrix();
glLoadMatrixf(glv->mTexture);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadMatrixf(glv->mProjection);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadMatrixf(glv->mModelview);
glDisable(GL_CLIP_PLANE0);
glDisable(GL_CLIP_PLANE1);
glDisable(GL_CLIP_PLANE2);
glDisable(GL_CLIP_PLANE3);
if (glv->draw_ev != NULL)
glv->draw_ev->handler(glv->draw_ev);
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_TEXTURE);
glPopMatrix();
/* restore transform and viewport */
glPopAttrib();
if (glv->overlay_ev != NULL) {
glPushAttrib(GL_TRANSFORM_BIT);
glv->overlay_ev->handler(glv->overlay_ev);
glPopAttrib();
}
}
