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);
}
ffmpegPlayer *
ffmpegPlayerNew(void *parent, int w, int h, int flags, SDL_Surface *screen)
{
ffmpegPlayer *me;
assert(screen != NULL);
/* Create a new instance of the class */
me = malloc(sizeof(ffmpegPlayer));
AG_ObjectInit(me, &ffmpegPlayerClass);
/* Save the user-requested geometry */
me->w = w;
me->h = h;
me->flags = flags;
me->screen = screen;
if (flags & AG_FFMPEGPLAYER_HFILL)
AGWIDGET(me)->flags |= AG_WIDGET_HFILL;
if (flags & AG_FFMPEGPLAYER_VFILL)
AGWIDGET(me)->flags |= AG_WIDGET_VFILL;
/* Attach the object to the parent (no-op if parent is NULL) */
AG_ObjectAttach(parent, me);
return me;
}
AG_Titlebar *
AG_TitlebarNew(void *parent, Uint flags)
{
AG_Titlebar *tbar;
tbar = Malloc(sizeof(AG_Titlebar));
AG_ObjectInit(tbar, &agTitlebarClass);
tbar->flags |= flags;
AG_ObjectAttach(parent, tbar);
/*
* Manually update the window/driver pointers since AG_TitlebarNew()
* is called from the Window attach routine.
*/
AG_ObjectLock(tbar);
tbar->win = (AG_Window *)parent;
WIDGET(tbar)->window = tbar->win;
WIDGET(tbar)->drv = WIDGET(parent)->drv;
WIDGET(tbar)->drvOps = AGDRIVER_CLASS(WIDGET(tbar)->drv);
AG_ObjectUnlock(tbar);
if ((flags & AG_TITLEBAR_NO_MAXIMIZE) == 0)
CreateMaximizeButton(tbar);
if ((flags & AG_TITLEBAR_NO_MINIMIZE) == 0)
CreateMinimizeButton(tbar);
if ((flags & AG_TITLEBAR_NO_CLOSE) == 0)
CreateCloseButton(tbar);
return (tbar);
}
static void
Expand(AG_Event *event)
{
AG_UCombo *com = AG_PTR(1);
AG_Driver *drv = WIDGET(com)->drv;
int expand = AG_INT(2);
AG_SizeReq rList;
int x, y, w, h;
Uint wView, hView;
AG_ObjectLock(com);
if (expand) {
com->panel = AG_WindowNew(AG_WINDOW_POPUP|AG_WINDOW_MODAL|
AG_WINDOW_NOTITLE);
AG_ObjectSetName(com->panel, "_UComboPopup");
AG_WindowSetPadding(com->panel, 0,0,0,0);
AG_ObjectAttach(com->panel, com->list);
if (WIDGET(com)->window != NULL)
AG_WindowAttach(WIDGET(com)->window, com->panel);
if (com->wSaved > 0) {
w = com->wSaved;
h = com->hSaved;
} else {
if (com->wPreList != -1 && com->hPreList != -1) {
AG_TlistSizeHintPixels(com->list,
com->wPreList, com->hPreList);
}
AG_WidgetSizeReq(com->list, &rList);
w = rList.w + com->panel->wBorderSide*2;
h = rList.h + com->panel->wBorderBot;
}
x = WIDGET(com)->rView.x2 - w;
y = WIDGET(com)->rView.y1;
AG_GetDisplaySize(WIDGET(com)->drv, &wView, &hView);
if (x+w > wView) { w = wView - x; }
if (y+h > hView) { h = hView - y; }
if (AGDRIVER_CLASS(drv)->wm == AG_WM_MULTIPLE &&
WIDGET(com)->window != NULL) {
x += WIDGET(WIDGET(com)->window)->x;
y += WIDGET(WIDGET(com)->window)->y;
}
if (x < 0) { x = 0; }
if (y < 0) { y = 0; }
if (w < 4 || h < 4) {
Collapse(com);
return;
}
AG_SetEvent(com->panel, "window-modal-close",
ModalClose, "%p", com);
AG_WindowSetGeometry(com->panel, x,y, w,h);
AG_WindowShow(com->panel);
} else {
Collapse(com);
}
AG_ObjectUnlock(com);
}
AG_Textbox *
AG_TextboxNewS(void *parent, Uint flags, const char *label)
{
AG_Textbox *tb;
tb = Malloc(sizeof(AG_Textbox));
AG_ObjectInit(tb, &agTextboxClass);
if (flags & AG_TEXTBOX_HFILL)
AG_ExpandHoriz(tb);
if (flags & AG_TEXTBOX_VFILL)
AG_ExpandVert(tb);
if (flags & AG_TEXTBOX_READONLY) {
AG_WidgetDisable(tb);
AG_WidgetDisable(tb->ed);
}
if (flags & AG_TEXTBOX_PASSWORD)
tb->ed->flags |= AG_EDITABLE_PASSWORD;
if (flags & AG_TEXTBOX_ABANDON_FOCUS)
tb->ed->flags |= AG_EDITABLE_ABANDON_FOCUS;
if (flags & AG_TEXTBOX_INT_ONLY)
tb->ed->flags |= AG_EDITABLE_INT_ONLY;
if (flags & AG_TEXTBOX_FLT_ONLY)
tb->ed->flags |= AG_EDITABLE_FLT_ONLY;
if (flags & AG_TEXTBOX_CATCH_TAB) {
WIDGET(tb)->flags |= AG_WIDGET_CATCH_TAB;
WIDGET(tb->ed)->flags |= AG_WIDGET_CATCH_TAB;
}
if (flags & AG_TEXTBOX_NOEMACS)
tb->ed->flags |= AG_EDITABLE_NOEMACS;
if (flags & AG_TEXTBOX_NOWORDSEEK)
tb->ed->flags |= AG_EDITABLE_NOWORDSEEK;
if (flags & AG_TEXTBOX_NOLATIN1)
tb->ed->flags |= AG_EDITABLE_NOLATIN1;
if (flags & AG_TEXTBOX_MULTILINE) {
tb->ed->flags |= AG_EDITABLE_MULTILINE;
tb->vBar = AG_ScrollbarNew(tb, AG_SCROLLBAR_VERT,
AG_SCROLLBAR_AUTOHIDE);
AG_BindInt(tb->vBar, "value", &tb->ed->y);
AG_BindInt(tb->vBar, "max", &tb->ed->yMax);
AG_BindInt(tb->vBar, "visible", &tb->ed->yVis);
AG_SetEvent(tb->vBar, "scrollbar-drag-begin", BeginScrollbarDrag, "%p", tb);
AG_SetEvent(tb->vBar, "scrollbar-drag-end", EndScrollbarDrag, "%p", tb);
}
AG_TextboxSetStatic(tb, (flags & AG_TEXTBOX_STATIC));
AG_TextboxSetWordWrap(tb, (flags & AG_TEXTBOX_WORDWRAP));
tb->flags |= flags;
if (label != NULL) {
tb->lbl = AG_LabelNewS(tb, 0, label);
AG_LabelSetPadding(tb->lbl, -1, 10, -1, -1);
}
AG_ObjectAttach(parent, tb);
return (tb);
}
/*
* Constructor function. This is optional and only a convenience for
* developers who want to use our "Animal" API directly.
*/
Animal *
AnimalNew(void *parent)
{
Animal *animal;
animal = AG_Malloc(sizeof(Animal));
AG_ObjectInit(animal, &AnimalClass); /* Will invoke Init() */
AG_ObjectAttach(parent, animal);
return (animal);
}
AG_Statusbar *
AG_StatusbarNew(void *parent, Uint flags)
{
AG_Statusbar *sbar;
sbar = Malloc(sizeof(AG_Statusbar));
AG_ObjectInit(sbar, &agStatusbarClass);
sbar->flags |= flags;
if (flags & AG_STATUSBAR_HFILL) { AG_ExpandHoriz(sbar); }
if (flags & AG_STATUSBAR_VFILL) { AG_ExpandVert(sbar); }
AG_ObjectAttach(parent, sbar);
return (sbar);
}
AG_FontSelector *
AG_FontSelectorNew(void *parent, Uint flags)
{
AG_FontSelector *fs;
fs = Malloc(sizeof(AG_FontSelector));
AG_ObjectInit(fs, &agFontSelectorClass);
fs->flags |= flags;
if (flags & AG_FONTSELECTOR_HFILL) { AG_ExpandHoriz(fs); }
if (flags & AG_FONTSELECTOR_VFILL) { AG_ExpandVert(fs); }
AG_ObjectAttach(parent, fs);
return (fs);
}
/*
* This is a generic constructor function. It is completely optional, but
* customary of FooNew() functions to allocate, initialize and attach an
* instance of the class.
*/
formaText *
formaTextNew(void *parent)
{
formaText *my;
/* Create a new instance of the formaText class */
my = (formaText*)malloc(sizeof(formaText));
AG_ObjectInit(my, &formaTextClass);
/* Attach the object to the parent (no-op if parent is NULL) */
AG_ObjectAttach(parent, my);
return (my);
}
AG_GLView *
AG_GLViewNew(void *parent, Uint flags)
{
AG_GLView *glv;
glv = Malloc(sizeof(AG_GLView));
AG_ObjectInit(glv, &agGLViewClass);
glv->flags |= flags;
if (flags & AG_GLVIEW_HFILL) { AG_ExpandHoriz(glv); }
if (flags & AG_GLVIEW_VFILL) { AG_ExpandVert(glv); }
AG_ObjectAttach(parent, glv);
return (glv);
}
AG_HSVPal *
AG_HSVPalNew(void *parent, Uint flags)
{
AG_HSVPal *pal;
pal = Malloc(sizeof(AG_HSVPal));
AG_ObjectInit(pal, &agHSVPalClass);
pal->flags |= flags;
if (flags & AG_HSVPAL_HFILL) { AG_ExpandHoriz(pal); }
if (flags & AG_HSVPAL_VFILL) { AG_ExpandVert(pal); }
AG_ObjectAttach(parent, pal);
return (pal);
}
AG_MPane *
AG_MPaneNew(void *parent, enum ag_mpane_layout layout, Uint flags)
{
AG_MPane *mp;
mp = Malloc(sizeof(AG_MPane));
AG_ObjectInit(mp, &agMPaneClass);
mp->flags |= flags;
if (flags & AG_MPANE_HFILL) { AG_ExpandHoriz(mp); }
if (flags & AG_MPANE_VFILL) { AG_ExpandVert(mp); }
AG_MPaneSetLayout(mp, layout);
AG_ObjectAttach(parent, mp);
return (mp);
}
AG_Slider *
AG_SliderNew(void *parent, enum ag_slider_type type, Uint flags)
{
AG_Slider *sl;
sl = Malloc(sizeof(AG_Slider));
AG_ObjectInit(sl, &agSliderClass);
sl->type = type;
sl->flags |= flags;
if (flags & AG_SLIDER_HFILL) { AG_ExpandHoriz(sl); }
if (flags & AG_SLIDER_VFILL) { AG_ExpandVert(sl); }
AG_ObjectAttach(parent, sl);
return (sl);
}
static void
Expand(AG_Event *event)
{
AG_FileSelector *fs = AG_PTR(1);
AG_Driver *drv = WIDGET(fs)->drv;
int expand = AG_INT(2);
AG_SizeReq rFileDlg;
int x, y, w, h;
Uint wView, hView;
if (expand) { /* Expand */
fs->panel = AG_WindowNew(AG_WINDOW_MODAL|AG_WINDOW_NOTITLE);
AG_WindowSetPadding(fs->panel, 0, 0, 0, 0);
AG_ObjectAttach(fs->panel, fs->filedlg);
if (fs->wSaved > 0) {
w = fs->wSaved;
h = fs->hSaved;
} else {
AG_WidgetSizeReq(fs->filedlg, &rFileDlg);
w = rFileDlg.w + fs->panel->wBorderSide*2;
h = rFileDlg.h + fs->panel->wBorderBot;
}
x = WIDGET(fs)->rView.x2 - w;
y = WIDGET(fs)->rView.y1;
if (AGDRIVER_SINGLE(drv) &&
AG_GetDisplaySize(drv, &wView, &hView) == 0) {
if (x+w > wView) {
w = wView - x;
}
if (y+h > hView) {
h = hView - y;
}
}
if (w < 4 || h < 4) {
Collapse(fs);
return;
}
AG_SetEvent(fs->panel, "window-modal-close",
ModalClose, "%p", fs);
AG_WindowSetGeometry(fs->panel, x, y, w, h);
AG_WindowShow(fs->panel);
} else {
Collapse(fs);
}
}
AG_Box *
AG_BoxNew(void *parent, enum ag_box_type type, Uint flags)
{
AG_Box *box;
box = Malloc(sizeof(AG_Box));
AG_ObjectInit(box, &agBoxClass);
box->type = type;
box->flags |= flags;
if (flags & AG_BOX_HFILL) { AG_ExpandHoriz(box); }
if (flags & AG_BOX_VFILL) { AG_ExpandVert(box); }
AG_ObjectAttach(parent, box);
return (box);
}
AG_Separator *
AG_SpacerNew(void *parent, enum ag_separator_type type)
{
AG_Separator *sep;
sep = Malloc(sizeof(AG_Separator));
AG_ObjectInit(sep, &agSeparatorClass);
sep->type = type;
sep->visible = 0;
if (type == AG_SEPARATOR_HORIZ) {
AG_ExpandHoriz(sep);
} else {
AG_ExpandVert(sep);
}
AG_ObjectAttach(parent, sep);
return (sep);
}
AG_UCombo *
AG_UComboNew(void *parent, Uint flags)
{
AG_UCombo *com;
com = Malloc(sizeof(AG_UCombo));
AG_ObjectInit(com, &agUComboClass);
com->flags |= flags;
if (flags & AG_UCOMBO_HFILL) { AG_ExpandHoriz(com); }
if (flags & AG_UCOMBO_VFILL) { AG_ExpandVert(com); }
if (flags & AG_UCOMBO_SCROLLTOSEL)
com->list->flags |= AG_TLIST_SCROLLTOSEL;
AG_ObjectAttach(parent, com);
return (com);
}
/* Create a new driver instance. */
AG_Driver *
AG_DriverOpen(AG_DriverClass *dc)
{
AG_Driver *drv;
if ((drv = AG_ObjectNew(NULL, dc->name, AGCLASS(dc))) == NULL) {
return (NULL);
}
if (dc->open(drv, NULL) == -1) {
AG_ObjectDestroy(drv);
return (NULL);
}
for (drv->id = 1; ; drv->id++) {
if (AG_GetDriverByID(drv->id) == NULL)
break;
}
AG_ObjectSetName(drv, "%s%u", dc->name, drv->id);
AG_ObjectAttach(&agDrivers, drv);
return (drv);
}
AG_Button *
AG_ButtonNewS(void *parent, Uint flags, const char *label)
{
AG_Button *bu;
bu = Malloc(sizeof(AG_Button));
AG_ObjectInit(bu, &agButtonClass);
if (label != NULL) {
bu->lbl = AG_LabelNewS(bu, 0, label);
AG_LabelJustify(bu->lbl, bu->justify);
AG_LabelValign(bu->lbl, bu->valign);
}
bu->flags |= flags;
if (flags & AG_BUTTON_HFILL) { AG_ExpandHoriz(bu); }
if (flags & AG_BUTTON_VFILL) { AG_ExpandVert(bu); }
AG_ObjectAttach(parent, bu);
return (bu);
}
AG_FileSelector *
AG_FileSelectorNew(void *parent, Uint flags, const char *label)
{
AG_FileSelector *fs;
fs = Malloc(sizeof(AG_FileSelector));
AG_ObjectInit(fs, &agFileSelectorClass);
fs->flags |= flags;
if (label != NULL) {
AG_TextboxSetLabelS(fs->tbox, label);
}
if (flags & AG_FILE_SELECTOR_HFILL) {
AG_ExpandHoriz(fs);
}
if (flags & AG_FILE_SELECTOR_VFILL) {
AG_ExpandVert(fs);
}
AG_ObjectAttach(parent, fs);
return (fs);
}
AG_Combo *
AG_ComboNewS(void *parent, Uint flags, const char *label)
{
AG_Combo *com;
com = Malloc(sizeof(AG_Combo));
AG_ObjectInit(com, &agComboClass);
com->flags |= flags;
if (label != NULL) {
AG_TextboxSetLabelS(com->tbox, label);
}
if (flags & AG_COMBO_ANY_TEXT) { AG_WidgetDisable(com->tbox); }
if (flags & AG_COMBO_TREE) { com->list->flags |= AG_TLIST_TREE; }
if (flags & AG_COMBO_POLL) { com->list->flags |= AG_TLIST_POLL; }
if (flags & AG_COMBO_SCROLLTOSEL) {
com->list->flags |= AG_TLIST_SCROLLTOSEL;
}
if (flags & AG_COMBO_HFILL) { AG_ExpandHoriz(com); }
if (flags & AG_COMBO_VFILL) { AG_ExpandVert(com); }
AG_ObjectAttach(parent, com);
return (com);
}
void
AG_MPaneSetLayout(AG_MPane *mp, enum ag_mpane_layout layout)
{
AG_Pane *vp = NULL, *hp = NULL, *dp = NULL;
AG_ObjectLock(mp);
AG_ObjectFreeChildren(OBJECT(mp));
switch (layout) {
case AG_MPANE1:
AG_ObjectAttach(mp, mp->panes[0]);
WIDGET(mp->panes[0])->flags |= AG_WIDGET_EXPAND;
mp->npanes = 1;
break;
case AG_MPANE2H:
vp = AG_PaneNew(mp, AG_PANE_VERT, AG_PANE_EXPAND);
AG_PaneAttachBoxes(vp, mp->panes[0], mp->panes[1]);
mp->npanes = 2;
break;
case AG_MPANE2V:
hp = AG_PaneNew(mp, AG_PANE_HORIZ, AG_PANE_EXPAND);
AG_PaneAttachBoxes(hp, mp->panes[0], mp->panes[1]);
mp->npanes = 2;
break;
case AG_MPANE2L1R:
hp = AG_PaneNew(mp, AG_PANE_HORIZ, AG_PANE_EXPAND);
vp = AG_PaneNew(hp->div[0], AG_PANE_VERT, AG_PANE_EXPAND);
AG_PaneAttachBox(vp, 0, mp->panes[0]);
AG_PaneAttachBox(vp, 1, mp->panes[1]);
AG_PaneAttachBox(hp, 1, mp->panes[2]);
mp->npanes = 3;
break;
case AG_MPANE1L2R:
hp = AG_PaneNew(mp, AG_PANE_HORIZ, AG_PANE_EXPAND);
vp = AG_PaneNew(hp->div[1], AG_PANE_VERT, AG_PANE_EXPAND);
AG_PaneAttachBox(hp, 0, mp->panes[0]);
AG_PaneAttachBox(vp, 0, mp->panes[1]);
AG_PaneAttachBox(vp, 1, mp->panes[2]);
mp->npanes = 3;
break;
case AG_MPANE2T1B:
vp = AG_PaneNew(mp, AG_PANE_VERT, AG_PANE_EXPAND);
hp = AG_PaneNew(vp->div[0], AG_PANE_HORIZ, AG_PANE_EXPAND);
AG_PaneAttachBox(hp, 0, mp->panes[0]);
AG_PaneAttachBox(hp, 1, mp->panes[1]);
AG_PaneAttachBox(vp, 1, mp->panes[2]);
mp->npanes = 3;
break;
case AG_MPANE1T2B:
vp = AG_PaneNew(mp, AG_PANE_VERT, AG_PANE_EXPAND);
hp = AG_PaneNew(vp->div[1], AG_PANE_HORIZ, AG_PANE_EXPAND);
AG_PaneAttachBox(vp, 0, mp->panes[0]);
AG_PaneAttachBox(hp, 0, mp->panes[1]);
AG_PaneAttachBox(hp, 1, mp->panes[2]);
mp->npanes = 3;
break;
case AG_MPANE3L1R:
hp = AG_PaneNew(mp, AG_PANE_HORIZ, AG_PANE_EXPAND);
vp = AG_PaneNew(hp->div[0], AG_PANE_VERT, AG_PANE_EXPAND);
dp = AG_PaneNew(vp->div[1], AG_PANE_VERT, AG_PANE_EXPAND);
AG_PaneAttachBox(vp, 0, mp->panes[0]);
AG_PaneAttachBox(dp, 0, mp->panes[1]);
AG_PaneAttachBox(dp, 1, mp->panes[2]);
AG_PaneAttachBox(hp, 1, mp->panes[3]);
mp->npanes = 4;
break;
case AG_MPANE4:
hp = AG_PaneNew(mp, AG_PANE_VERT, AG_PANE_EXPAND);
vp = AG_PaneNew(hp->div[0], AG_PANE_HORIZ, AG_PANE_EXPAND);
dp = AG_PaneNew(hp->div[1], AG_PANE_HORIZ, AG_PANE_EXPAND);
AG_PaneAttachBox(vp, 0, mp->panes[0]);
AG_PaneAttachBox(vp, 1, mp->panes[1]);
AG_PaneAttachBox(dp, 0, mp->panes[2]);
AG_PaneAttachBox(dp, 1, mp->panes[3]);
mp->npanes = 4;
break;
default:
break;
}
if (mp->flags & AG_MPANE_FORCE_DIV) {
if (hp) {
AG_PaneMoveDividerPct(hp, 50);
AG_PaneResizeAction(hp, AG_PANE_DIVIDE_EVEN);
}
if (vp) {
AG_PaneMoveDividerPct(vp, 50);
AG_PaneResizeAction(vp, AG_PANE_DIVIDE_EVEN);
}
if (dp) {
AG_PaneMoveDividerPct(dp, 50);
AG_PaneResizeAction(dp, AG_PANE_DIVIDE_EVEN);
}
}
mp->layout = layout;
AG_ObjectUnlock(mp);
}
