/* allocate a fontquerynode and fill in properties
*/
static struct FontQueryNode *
fnt_getfqnode(DFBDISPLAY *mod, TSTRPTR filename, TINT pxsize)
{
TAPTR exec = TGetExecBase(mod);
struct FontQueryNode *fqnode = TNULL;
/* allocate fquery node */
fqnode = TExecAlloc0(exec, mod->dfb_MemMgr, sizeof(struct FontQueryNode));
if (fqnode)
{
/* fquerynode ready - fill in attributes */
TSTRPTR myfname = TNULL;
TINT flen = strlen(filename)-4; /* discard '.ttf' */
if (flen > 0)
myfname = TExecAlloc0(exec, mod->dfb_MemMgr, flen + 1);
else
TDBPRINTF(TDB_ERROR,("found invalid font: '%s'\n", filename));
if (myfname)
{
TExecCopyMem(exec, filename, myfname, flen);
fqnode->tags[0].tti_Tag = TVisual_FontName;
fqnode->tags[0].tti_Value = (TTAG) myfname;
}
else
{
if (flen > 0)
TDBPRINTF(TDB_FAIL,("out of memory :(\n"));
}
if (fqnode->tags[0].tti_Value)
{
TINT i = 1;
fqnode->tags[i].tti_Tag = TVisual_FontPxSize;
fqnode->tags[i++].tti_Value = (TTAG) pxsize;
/* always true */
fqnode->tags[i].tti_Tag = TVisual_FontScaleable;
fqnode->tags[i++].tti_Value = (TTAG) TTRUE;
fqnode->tags[i].tti_Tag = TTAG_DONE;
}
else
{
TExecFree(exec, fqnode);
fqnode = TNULL;
}
} /* endif fqnode */
else
TDBPRINTF(TDB_FAIL,("out of memory :(\n"));
return fqnode;
}
LOCAL TAPTR
dfb_hostopenfont(DFBDISPLAY *mod, TTAGITEM *tags)
{
struct fnt_attr fattr;
struct FontNode *fn;
TAPTR font = TNULL;
TAPTR exec = TGetExecBase(mod);
/* fetch user specified attributes */
fattr.fname = (TSTRPTR) TGetTag(tags, TVisual_FontName, (TTAG) FNT_DEFNAME);
fattr.fpxsize = (TINT) TGetTag(tags, TVisual_FontPxSize, (TTAG) FNT_DEFPXSIZE);
/* not yet
fattr.fitalic = (TBOOL) TGetTag(tags, TVisual_FontItalic, (TTAG) TFALSE);
fattr.fbold = (TBOOL) TGetTag(tags, TVisual_FontBold, (TTAG) TFALSE);
fattr.fscale = (TBOOL) TGetTag(tags, TVisual_FontScaleable, (TTAG) TFALSE);
*/
if (fattr.fname)
{
fn = TExecAlloc0(exec, mod->dfb_MemMgr, sizeof(struct FontNode));
if (fn)
{
fn->handle.thn_Owner = mod;
if (hostopenfont(mod, fn, &fattr))
{
/* load succeeded, save font attributes */
fn->pxsize = fattr.fpxsize;
fn->font->GetHeight(fn->font, &fn->height);
fn->font->GetAscender(fn->font, &fn->ascent);
fn->font->GetDescender(fn->font, &fn->descent);
/* not yet
if (fattr.fitalic)
fn->attr = FNT_ITALIC;
if (fattr.fbold)
fn->attr |= FNT_BOLD;
*/
/* append to the list of open fonts */
TDBPRINTF(TDB_INFO, ("O '%s' %dpx\n", fattr.fname, fattr.fpxsize));
TAddTail(&mod->dfb_fm.openfonts, &fn->handle.thn_Node);
font = (TAPTR)fn;
}
else
{
/* load failed, free fontnode */
TDBPRINTF(TDB_INFO,("X unable to load '%s'\n", fattr.fname));
TExecFree(exec, fn);
}
}
else
TDBPRINTF(TDB_FAIL,("out of memory :(\n"));
}
else
TDBPRINTF(TDB_ERROR,("X invalid fontname '%s' specified\n", fattr.fname));
return font;
}
static TBOOL
hostopenfont(DFBDISPLAY *mod, struct FontNode *fn, struct fnt_attr *fattr)
{
TBOOL succ = TFALSE;
TAPTR exec = TGetExecBase(mod);
DFBFontDescription fdsc;
TSTRPTR fontfile = TExecAlloc0(exec, mod->dfb_MemMgr,
strlen(fattr->fname) + strlen(FNT_DEFDIR) + 5);
if (fontfile)
{
fdsc.flags = DFDESC_HEIGHT;
fdsc.height = fattr->fpxsize;
sprintf(fontfile, "%s%s.ttf", FNT_DEFDIR, fattr->fname);
TDBPRINTF(TDB_INFO,("? %s:%d\n", fontfile, fattr->fpxsize));
if (mod->dfb_DFB->CreateFont(mod->dfb_DFB, fontfile,
&fdsc, &fn->font) == DFB_OK)
succ = TTRUE;
TExecFree(exec, fontfile);
}
else
TDBPRINTF(TDB_FAIL,("out of memory :(\n"));
return succ;
}
/* parses a single fontname or a comma separated list of fontnames
** and returns a list of fontnames, spaces are NOT filtered, so
** "helvetica, fixed" will result in "helvetica" and " fixed"
*/
static void
fnt_getfnnodes(DFBDISPLAY *mod, struct TList *fnlist, TSTRPTR fname)
{
TINT i, p = 0;
TBOOL lastrun = TFALSE;
TINT fnlen = strlen(fname);
TAPTR exec = TGetExecBase(mod);
for (i = 0; i < fnlen; i++)
{
if (i == fnlen-1) lastrun = TTRUE;
if (fname[i] == ',' || lastrun)
{
TINT len = (i > p) ? (lastrun ? (i-p+1) : (i-p)) : fnlen+1;
TSTRPTR ts = TExecAlloc0(exec, mod->dfb_MemMgr, len+1);
if (ts)
{
struct fnt_node *fnn;
TExecCopyMem(exec, fname+p, ts, len);
fnn = TExecAlloc0(exec, mod->dfb_MemMgr, sizeof(struct fnt_node));
if (fnn)
{
/* add fnnode to fnlist */
fnn->fname = ts;
TAddTail(fnlist, &fnn->node);
}
else
{
TDBPRINTF(TDB_FAIL,("out of memory :(\n"));
break;
}
}
else
{
TDBPRINTF(TDB_FAIL,("out of memory :(\n"));
break;
}
p = i+1;
}
}
}
LOCAL TAPTR
dfb_hostqueryfonts(TMOD_DFB *mod, TTAGITEM *tags)
{
TSTRPTR fname = TNULL;
struct fnt_attr fattr;
struct TNode *node, *next;
struct FontQueryHandle *fqh = TNULL;
TAPTR exec = TGetExecBase(mod);
TDBPRINTF(10, ("***********************************************\n"));
/* init fontname list */
TInitList(&fattr.fnlist);
/* fetch and parse fname */
fname = (TSTRPTR) TGetTag(tags, TVisual_FontName, (TTAG) FNT_WILDCARD);
if (fname) fnt_getfnnodes(mod, &fattr.fnlist, fname);
/* fetch user specified attributes */
fattr.fpxsize = (TINT) TGetTag(tags, TVisual_FontPxSize, (TTAG) FNT_DEFPXSIZE);
fattr.fnum = (TINT) TGetTag(tags, TVisual_FontNumResults, (TTAG) INT_MAX);
/* not yet
fattr.fitalic = (TBOOL) TGetTag(tags, TVisual_FontItalic, (TTAG) FNTQUERY_UNDEFINED);
fattr.fbold = (TBOOL) TGetTag(tags, TVisual_FontBold, (TTAG) FNTQUERY_UNDEFINED);
*/
/* init result list */
fqh = TExecAlloc0(exec, mod->dfb_MemMgr, sizeof(struct FontQueryHandle));
if (fqh)
{
fqh->handle.thn_Owner = mod;
/* connect destructor */
TInitHook(&fqh->handle.thn_Hook, fqhdestroy, fqh);
TInitList(&fqh->reslist);
/* init list iterator */
fqh->nptr = &fqh->reslist.tlh_Head;
hostqueryfonts(mod, fqh, &fattr);
TDB(10,(fnt_dumplist(&fqh->reslist)));
TDBPRINTF(10, ("***********************************************\n"));
}
else
TDBPRINTF(20, ("out of memory :(\n"));
/* free memory of fnt_nodes */
for (node = fattr.fnlist.tlh_Head; (next = node->tln_Succ); node = next)
{
struct fnt_node *fnn = (struct fnt_node *)node;
TExecFree(exec, fnn->fname);
TRemove(&fnn->node);
TExecFree(exec, fnn);
}
return fqh;
}
/* examine filename according to the specified flags and set the
** corresponding bits in the flagfield the function returns
** at the moment only FNT_MATCH_NAME is suppported
*/
static TUINT
fnt_matchfont(DFBDISPLAY *mod, TSTRPTR filename, TSTRPTR fname,
struct fnt_attr *fattr, TUINT flag)
{
TUINT match = 0;
TAPTR exec = TGetExecBase(mod);
if (flag & FNT_MATCH_NAME)
{
TINT i;
TINT len = strlen(fname);
if (strncmp(fname, FNT_WILDCARD, len) == 0)
{
/* match all, but filter out invalid filenames like '.' or '..' */
if (strlen(filename) > 4)
match = FNT_MATCH_NAME;
}
else
{
TSTRPTR tempname = TNULL;
/* convert fontnames to lower case */
for (i = 0; i < len; i++)
fname[i] = tolower(fname[i]);
tempname = TExecAlloc0(exec, mod->dfb_MemMgr, len+1);
if (!tempname)
{
TDBPRINTF(TDB_FAIL,("out of memory :(\n"));
return -1;
}
for (i = 0; i < len; i++)
tempname[i] = tolower(filename[i]);
/* compare converted fontnames */
if (strncmp(fname, tempname, len) == 0)
match = FNT_MATCH_NAME;
TExecFree(exec, tempname);
}
}
/* not yet
if (flag & FNT_MATCH_SLANT) ;
if (flag & FNT_MATCH_WEIGHT) ;
*/
return match;
}
static TUINT fnt_matchfont(struct rfb_Display *mod, TSTRPTR filename,
TSTRPTR fname, struct fnt_attr *fattr, TUINT flag)
{
TUINT match = 0;
if (flag & FNT_MATCH_NAME)
{
TINT i;
TINT len = strlen(fname);
if (strncmp(fname, FNT_WILDCARD, len) == 0)
{
/* match all, but filter out invalid filenames like '.' or '..' */
if (strlen(filename) > 4)
match = FNT_MATCH_NAME;
}
else
{
TSTRPTR tempname = TNULL;
/* convert fontnames to lower case */
for (i = 0; i < len; i++)
fname[i] = tolower(fname[i]);
tempname =
TExecAlloc0(mod->rfb_ExecBase, mod->rfb_MemMgr, len + 1);
if (!tempname)
{
TDBPRINTF(20, ("out of memory :(\n"));
return -1;
}
for (i = 0; i < len; i++)
tempname[i] = tolower(filename[i]);
/* compare converted fontnames */
if (strncmp(fname, tempname, len) == 0)
match = FNT_MATCH_NAME;
TExecFree(mod->rfb_ExecBase, tempname);
}
}
return match;
}
LOCAL TAPTR rfb_hostopenfont(struct rfb_Display *mod, TTAGITEM *tags)
{
struct fnt_attr fattr;
struct rfb_FontNode *fn;
TAPTR font = TNULL;
/* fetch user specified attributes */
fattr.fname = (TSTRPTR) TGetTag(tags, TVisual_FontName,
(TTAG) FNT_DEFNAME);
fattr.fpxsize = (TINT) TGetTag(tags, TVisual_FontPxSize,
(TTAG) FNT_DEFPXSIZE);
if (fattr.fname)
{
fn = TExecAlloc0(mod->rfb_ExecBase, mod->rfb_MemMgr,
sizeof(struct rfb_FontNode));
if (fn)
{
fn->handle.thn_Owner = mod;
if (hostopenfont(mod, fn, &fattr))
{
/* load succeeded, save font attributes */
fn->pxsize = fattr.fpxsize;
fn->height = fn->face->size->metrics.height >> 6;
fn->ascent = fn->face->size->metrics.ascender >> 6;
fn->descent = fn->face->size->metrics.descender >> 6;
/* append to the list of open fonts */
TDBPRINTF(TDB_INFO, ("O '%s' %dpx\n", fattr.fname,
fattr.fpxsize));
TAddTail(&mod->rfb_FontManager.openfonts,
&fn->handle.thn_Node);
font = (TAPTR) fn;
}
else
{
LOCAL void
dfb_openvisual(DFBDISPLAY *mod, struct TVRequest *req)
{
TTAGITEM *tags = req->tvr_Op.OpenWindow.Tags;
TAPTR exec = TGetExecBase(mod);
DFBWINDOW *v;
DFBWindowDescription wdsc;
struct FontNode *fn;
v = TExecAlloc0(exec, mod->dfb_MemMgr, sizeof(DFBWINDOW));
req->tvr_Op.OpenWindow.Window = v;
if (v == TNULL) return;
v->userdata = TGetTag(tags, TVisual_UserData, TNULL);
v->eventmask = (TUINT) TGetTag(tags, TVisual_EventMask, 0);
TInitList(&v->penlist);
v->bgpen = TVPEN_UNDEFINED;
v->fgpen = TVPEN_UNDEFINED;
TInitList(&v->imsgqueue);
v->imsgport = req->tvr_Op.OpenWindow.IMsgPort;
v->title = (TSTRPTR)
TGetTag(tags, TVisual_Title, (TTAG) "TEKlib visual");
/* size/position calculation: */
v->winwidth = (TINT) TGetTag(tags,
TVisual_Width,
(TTAG) TMIN(mod->dfb_ScrWidth, DEF_WINWIDTH));
v->winheight = (TINT) TGetTag(tags,
TVisual_Height,
(TTAG) TMIN(mod->dfb_ScrHeight, DEF_WINHEIGHT));
if (TGetTag(tags, TVisual_Center, TFALSE))
{
v->winleft = (mod->dfb_ScrWidth - v->winwidth) / 2;
v->wintop = (mod->dfb_ScrHeight - v->winheight) / 2;
}
else if (TGetTag(tags, TVisual_FullScreen, TFALSE))
{
v->winwidth = mod->dfb_ScrWidth;
v->winheight = mod->dfb_ScrHeight;
v->winleft = 0;
v->wintop = 0;
}
else
{
v->winleft = (TINT) TGetTag(tags, TVisual_WinLeft, (TTAG) -1);
v->wintop = (TINT) TGetTag(tags, TVisual_WinTop, (TTAG) -1);
}
if (!TGetTag(tags, TVisual_Borderless, TFALSE))
{
v->wminwidth = (TINT) TGetTag(tags, TVisual_MinWidth, (TTAG) -1);
v->wminheight = (TINT) TGetTag(tags, TVisual_MinHeight, (TTAG) -1);
v->wmaxwidth = (TINT) TGetTag(tags, TVisual_MaxWidth, (TTAG) -1);
v->wmaxheight = (TINT) TGetTag(tags, TVisual_MaxHeight, (TTAG) -1);
if (v->wmaxwidth > 0)
v->winwidth = TMIN(v->winwidth, v->wmaxwidth);
if (v->wmaxheight > 0)
v->winheight = TMIN(v->winheight, v->wmaxheight);
if (v->wminwidth > 0)
v->winwidth = TMAX(v->winwidth, v->wminwidth);
if (v->wminheight > 0)
v->winheight = TMAX(v->winheight, v->wminheight);
v->wminwidth = v->wminwidth <= 0 ? 1 : v->wminwidth;
v->wminheight = v->wminheight <= 0 ? 1 : v->wminheight;
v->wmaxwidth = v->wmaxwidth <= 0 ? 1000000 : v->wmaxwidth;
v->wmaxheight = v->wmaxheight <= 0 ? 1000000 : v->wmaxheight;
}
v->winleft = TMAX(v->winleft, 0);
v->wintop = TMAX(v->wintop, 0);
if (TGetTag(tags, TVisual_Borderless, TFALSE))
v->borderless = TTRUE;
wdsc.flags = (DWDESC_POSX | DWDESC_POSY | DWDESC_WIDTH | DWDESC_HEIGHT);
wdsc.posx = v->winleft;
wdsc.posy = v->wintop;
wdsc.width = v->winwidth;
wdsc.height = v->winheight;
if (mod->dfb_Layer->CreateWindow(mod->dfb_Layer, &wdsc, &v->window) == DFB_OK)
{
v->window->GetSurface(v->window, &v->winsurface);
v->window->SetOpacity(v->window, 0xFF);
v->window->GetID(v->window, &v->winid);
v->window->AttachEventBuffer(v->window, mod->dfb_Events);
v->window->RequestFocus(v->window);
v->window->RaiseToTop(v->window);
if (!v->borderless)
{
/* generate focus events */
genimsg(mod, (DFBWINDOW *)mod->dfb_Focused, v, TITYPE_FOCUS);
mod->dfb_Focused = (TAPTR) v;
}
v->winsurface->SetColor(v->winsurface, 0x00, 0x00, 0xff, 0xff);
v->winsurface->DrawRectangle(v->winsurface, 0, 0, wdsc.width, wdsc.height);
v->winsurface->SetColor(v->winsurface, 0x80, 0x80, 0x80, 0xff);
v->winsurface->FillRectangle(v->winsurface, 1, 1, wdsc.width-2, wdsc.height-2);
v->winsurface->Flip(v->winsurface, NULL, 0);
/* init default font */
fn = mod->dfb_fm.deffont;
v->curfont = fn;
mod->dfb_fm.defref++;
if (v->winsurface->SetFont(v->winsurface, fn->font) == DFB_OK)
{
if (v->winsurface->SetFont(v->winsurface, fn->font) == DFB_OK)
{
TDBPRINTF(TDB_TRACE,("Add window: %p\n", v->window));
TAddHead(&mod->dfb_vlist, &v->node);
/* success: */
return;
}
}
}
TExecFree(exec, v);
/* failure: */
TDBPRINTF(TDB_ERROR,("Open failed\n"));
req->tvr_Op.OpenWindow.Window = TNULL;
}
