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
exec_init(TEXECBASE *exec, TTAGITEM *tags)
{
TAPTR *halp, hal;
halp = (TAPTR *) TGetTag(tags, TExecBase_HAL, TNULL);
if (!halp)
return TFALSE;
hal = *halp;
THALFillMem(hal, exec, sizeof(TEXECBASE), 0);
exec->texb_HALBase = hal;
if (THALInitLock(hal, &exec->texb_Lock))
{
if (exec_initmm(exec, &exec->texb_MsgMemManager, TNULL, TMMT_Message,
TNULL))
{
if (exec_initmm(exec, &exec->texb_BaseMemManager, TNULL,
TMMT_MemManager, TNULL))
{
exec->texb_Module.tmd_Handle.thn_Hook.thk_Data = exec;
exec->texb_Module.tmd_Handle.thn_Name = TMODNAME_EXEC;
exec->texb_Module.tmd_Handle.thn_Owner =
(struct TModule *) exec;
exec->texb_Module.tmd_ModSuper = (struct TModule *) exec;
exec->texb_Module.tmd_InitTask = TNULL; /* inserted later */
exec->texb_Module.tmd_HALMod = TNULL; /* inserted later */
exec->texb_Module.tmd_NegSize =
EXEC_NUMVECTORS * sizeof(TAPTR);
exec->texb_Module.tmd_PosSize = sizeof(TEXECBASE);
exec->texb_Module.tmd_RefCount = 1;
exec->texb_Module.tmd_Flags =
TMODF_INITIALIZED | TMODF_VECTORTABLE;
TInitList(&exec->texb_IntModList);
exec->texb_InitModNode.tmin_Modules = (struct TInitModule *)
TGetTag(tags, TExecBase_ModInit, TNULL);
if (exec->texb_InitModNode.tmin_Modules)
{
TAddTail(&exec->texb_IntModList,
&exec->texb_InitModNode.tmin_Node);
}
TInitList(&exec->texb_AtomList);
TInitList(&exec->texb_TaskList);
TInitList(&exec->texb_TaskInitList);
TInitList(&exec->texb_TaskExitList);
TInitList(&exec->texb_ModList);
TAddHead(&exec->texb_ModList, (struct TNode *) exec);
TAddHead(&exec->texb_ModList, (struct TNode *) hal);
return TTRUE;
}
TDESTROY(&exec->texb_MsgMemManager);
}
THALDestroyLock(hal, &exec->texb_Lock);
}
return TFALSE;
}
LOCAL TBOOL
hal_init(struct THALBase *hal, TTAGITEM *tags)
{
struct HALSpecific *specific;
specific = malloc(sizeof(struct HALSpecific));
if (specific)
{
memset(specific, 0, sizeof(struct HALSpecific));
specific->hsp_TLSIndex = TlsAlloc();
if (specific->hsp_TLSIndex != 0xffffffff)
{
InitializeCriticalSection(&specific->hsp_DevLock);
specific->hsp_SysDir =
(TSTRPTR) TGetTag(tags, TExecBase_SysDir, TNULL);
specific->hsp_ModDir =
(TSTRPTR) TGetTag(tags, TExecBase_ModDir, TNULL);
specific->hsp_ProgDir =
(TSTRPTR) TGetTag(tags, TExecBase_ProgDir, TNULL);
specific->hsp_Tags[0].tti_Tag = TExecBase_SysDir;
specific->hsp_Tags[0].tti_Value = (TTAG) specific->hsp_SysDir;
specific->hsp_Tags[1].tti_Tag = TExecBase_ModDir;
specific->hsp_Tags[1].tti_Value = (TTAG) specific->hsp_ModDir;
specific->hsp_Tags[2].tti_Tag = TExecBase_ProgDir;
specific->hsp_Tags[2].tti_Value = (TTAG) specific->hsp_ProgDir;
specific->hsp_Tags[3].tti_Tag = TTAG_DONE;
/* get performance counter frequency, if available */
#ifdef USE_PERFCOUNTER
specific->hsp_UsePerfCounter =
QueryPerformanceFrequency((LARGE_INTEGER *)
&specific->hsp_PerfCFreq);
if (specific->hsp_UsePerfCounter)
{
union { LARGE_INTEGER li; FILETIME ft; } filet;
LONGLONG t;
/* get performance counter start */
QueryPerformanceCounter((LARGE_INTEGER *)
&specific->hsp_PerfCStart);
/* calibrate perfcounter to 1.1.1970 */
GetSystemTimeAsFileTime(&filet.ft);
t = filet.li.QuadPart / 10; /* microseconds */
t -= 11644473600000000ULL; /* 1.1.1601 -> 1.1.1970 */
specific->hsp_PerfCStartDate = t;
}
#endif
hal->hmb_Specific = specific;
return TTRUE;
}
free(specific);
}
return TFALSE;
}
static TBOOL rfb_inittask(struct TTask *task)
{
TAPTR TExecBase = TGetExecBase(task);
RFBDISPLAY *mod = TGetTaskData(task);
for (;;)
{
TTAGITEM *opentags = mod->rfb_OpenTags;
TSTRPTR subname;
/* Initialize rectangle pool */
region_initpool(&mod->rfb_RectPool, TExecBase);
/* list of free input messages: */
TInitList(&mod->rfb_IMsgPool);
/* list of all open visuals: */
TInitList(&mod->rfb_VisualList);
/* init fontmanager and default font */
TInitList(&mod->rfb_FontManager.openfonts);
/* Instance lock (currently needed for async VNC) */
mod->rfb_InstanceLock = TCreateLock(TNULL);
if (mod->rfb_InstanceLock == TNULL)
break;
/* Open sub device, if one is requested: */
subname = (TSTRPTR) TGetTag(opentags, TVisual_DriverName,
(TTAG) SUBDEVICE_NAME);
if (subname)
{
TTAGITEM subtags[2];
subtags[0].tti_Tag = TVisual_IMsgPort;
subtags[0].tti_Value = TGetTag(opentags, TVisual_IMsgPort, TNULL);
subtags[1].tti_Tag = TTAG_DONE;
mod->rfb_RndRPort = TCreatePort(TNULL);
if (mod->rfb_RndRPort == TNULL)
break;
mod->rfb_RndDevice = TOpenModule(subname, 0, subtags);
if (mod->rfb_RndDevice == TNULL)
break;
mod->rfb_RndRequest = TAllocMsg(sizeof(struct TVRequest));
if (mod->rfb_RndRequest == TNULL)
break;
mod->rfb_RndIMsgPort = TCreatePort(TNULL);
if (mod->rfb_RndIMsgPort == TNULL)
break;
}
TDBPRINTF(TDB_TRACE,("Instance init successful\n"));
return TTRUE;
}
rfb_exittask(mod);
return TFALSE;
}
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;
}
LOCAL void
fb_drawstrip(WINDISPLAY *mod, struct TVRequest *req)
{
TINT i;
WINWINDOW *win = req->tvr_Op.Strip.Window;
TINT *array = req->tvr_Op.Strip.Array;
TINT num = req->tvr_Op.Strip.Num;
TTAGITEM *tags = req->tvr_Op.Strip.Tags;
TVPEN *penarray = (TVPEN *) TGetTag(tags, TVisual_PenArray, TNULL);
POINT points[3];
if (num < 3) return;
if (penarray)
{
SelectObject(win->fbv_HDC, ((struct FBPen *) penarray[2])->pen);
SelectObject(win->fbv_HDC, ((struct FBPen *) penarray[2])->brush);
}
else
{
TVPEN pen = (TVPEN) TGetTag(tags, TVisual_Pen, TVPEN_UNDEFINED);
SelectObject(win->fbv_HDC, ((struct FBPen *) pen)->pen);
SelectObject(win->fbv_HDC, ((struct FBPen *) pen)->brush);
}
Polygon(win->fbv_HDC, (LPPOINT) array, 3);
if (num > 3)
{
points[0].x = array[0];
points[0].y = array[1];
points[1].x = array[2];
points[1].y = array[3];
points[2].x = array[4];
points[2].y = array[5];
for (i = 3; i < num; ++i)
{
if (penarray)
{
SelectObject(win->fbv_HDC, ((struct FBPen *) penarray[i])->pen);
SelectObject(win->fbv_HDC, ((struct FBPen *) penarray[i])->brush);
}
points[0].x = points[1].x;
points[0].y = points[1].y;
points[1].x = points[2].x;
points[1].y = points[2].y;
points[2].x = array[i * 2];
points[2].y = array[i * 2 + 1];
Polygon(win->fbv_HDC, points, 3);
}
}
win->fbv_Dirty = TTRUE;
}
LOCAL TAPTR fb_hostopenfont(WINDISPLAY *mod, TTAGITEM *tags)
{
TSTRPTR name = (TSTRPTR) TGetTag(tags, TVisual_FontName, TNULL);
TUINT sz = (TUINT) TGetTag(tags, TVisual_FontPxSize, 0);
HFONT font;
TBOOL italic = (TBOOL) TGetTag(tags, TVisual_FontItalic, (TTAG) TFALSE);
TBOOL bold = (TBOOL) TGetTag(tags, TVisual_FontBold, (TTAG) TFALSE);
/* check availability: */
TAPTR fqh = fb_hostqueryfonts(mod, tags);
if (fqh)
{
TBOOL have_font = fb_hostgetnextfont(mod, fqh) != TNULL;
TDestroy(fqh);
if (!have_font)
{
TDBPRINTF(TDB_INFO,("Failed to open font '%s':%d\n", name, sz));
return TNULL;
}
}
else
return TNULL;
font = CreateFont(
sz,
0,
0,
0,
bold ? FW_BOLD : FW_NORMAL,
italic,
0, /* underline */
0, /* strikeout */
ANSI_CHARSET, /* charset */
OUT_DEFAULT_PRECIS, /* precision */
CLIP_DEFAULT_PRECIS,
DEFAULT_QUALITY,
FF_DONTCARE | DEFAULT_PITCH,
name);
TDBPRINTF(TDB_INFO,("CreateFont %s:%d => %p\n", name, sz, font));
return font;
}
LOCAL void
dfb_drawstrip(DFBDISPLAY *mod, struct TVRequest *req)
{
TINT i, x0, y0, x1, y1, x2, y2;
DFBWINDOW *v = req->tvr_Op.Strip.Window;
TINT *array = req->tvr_Op.Strip.Array;
TINT num = req->tvr_Op.Strip.Num;
TTAGITEM *tags = req->tvr_Op.Strip.Tags;
TVPEN pen = (TVPEN) TGetTag(tags, TVisual_Pen, TVPEN_UNDEFINED);
TVPEN *penarray = (TVPEN *) TGetTag(tags, TVisual_PenArray, TNULL);
if (num < 3) return;
if (penarray)
setfgpen(mod, v, penarray[2]);
else
setfgpen(mod, v, pen);
x0 = array[0];
y0 = array[1];
x1 = array[2];
y1 = array[3];
x2 = array[4];
y2 = array[5];
v->winsurface->FillTriangle(v->winsurface, x0, y0, x1, y1, x2, y2);
for (i = 3; i < num; i++)
{
x0 = x1;
y0 = y1;
x1 = x2;
y1 = y2;
x2 = array[i*2];
y2 = array[i*2+1];
if (penarray)
setfgpen(mod, v, penarray[i]);
v->winsurface->FillTriangle(v->winsurface, x0, y0, x1, y1, x2, y2);
}
}
static TBOOL
init_appatoms(struct TEKlibInit *init, TTAGITEM *tags)
{
TAPTR exec = init->tli_ExecBase;
TINT error;
error = init_addatomfromtag(exec, &init->tli_AtomInitMods,
"sys.imods", TGetTag(tags, TExecBase_ModInit, TNULL));
error += init_addatomfromtag(exec, &init->tli_AtomArgV,
"sys.argv", TGetTag(tags, TExecBase_ArgV, TNULL));
error += init_addatomfromtag(exec, &init->tli_AtomArgs,
"sys.arguments", TGetTag(tags, TExecBase_Arguments, TNULL));
error += init_addatomfromtag(exec, &init->tli_AtomProgName,
"sys.progname", TGetTag(tags, TExecBase_ProgName, TNULL));
error += init_addatomfromtag(exec, &init->tli_AtomRetValP,
"sys.returnvalue", TGetTag(tags, TExecBase_RetValP, TNULL));
error += ((init->tli_AtomUnique =
init_newatom(exec, "sys.uniqueid", &init->tli_UniqueID)) == TNULL);
return (TBOOL) (error == 0);
}
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
{
static struct TInitModule *
host_lookupmodule(TSTRPTR modname, TTAGITEM *tags)
{
struct TInitModule *imod =
(struct TInitModule *) TGetTag(tags, TExecBase_ModInit, TNULL);
if (imod)
{
while (imod->tinm_Name)
{
if (!strcmp(imod->tinm_Name, modname))
return imod;
imod++;
}
}
return TNULL;
}
TLIBAPI TSTRPTR
TEKlib_GetModDir(TAPTR boot, TTAGITEM *tags)
{
TSTRPTR sysdir;
TSTRPTR s;
TINT l;
s = (TSTRPTR) TGetTag(tags, TExecBase_ModDir, (TTAG) TEKHOST_MODDIR);
l = strlen(s);
sysdir = TEKlib_Alloc(boot, l + 1);
if (sysdir)
strcpy(sysdir, s);
return sysdir;
}
static TAPTR
init_openexecmodule(struct TEKlibInit *init, TTAGITEM *usertags)
{
/* load exec module */
init->tli_ExecMod = TEKlib_LoadModule(init->tli_BootHnd,
init->tli_ProgDir, init->tli_ModDir, "exec", usertags);
if (init->tli_ExecMod)
{
/* get exec module entrypoint */
init->tli_ExecEntry = TEKlib_GetEntry(init->tli_BootHnd,
init->tli_ExecMod, "tek_init_exec");
if (init->tli_ExecEntry)
{
TUINT psize, nsize;
TUINT16 version;
struct TExecBase *execbase;
/* get version and size */
version = (TUINT16) TGetTag(init->tli_HALTags,
TExecBase_Version, 0);
psize = TEKlib_CallModule(init->tli_BootHnd, init->tli_ExecMod,
init->tli_ExecEntry, TNULL, TNULL, version, init->tli_HALTags);
nsize = TEKlib_CallModule(init->tli_BootHnd, init->tli_ExecMod,
init->tli_ExecEntry, TNULL, TNULL, 0xffff, init->tli_HALTags);
/* get memory for the exec module */
execbase = TEKlib_Alloc(init->tli_BootHnd, nsize + psize);
if (execbase)
{
/* initialize execbase */
execbase = (struct TExecBase *) (((TINT8 *) execbase) + nsize);
if (TEKlib_CallModule(init->tli_BootHnd, init->tli_ExecMod,
init->tli_ExecEntry, TNULL, execbase, 0,
init->tli_HALTags))
{
init->tli_ExecBase = execbase;
return execbase;
}
TEKlib_Free(init->tli_BootHnd, ((TINT8 *) execbase) - nsize,
nsize + psize);
}
}
TEKlib_CloseModule(init->tli_BootHnd, init->tli_ExecMod);
}
init->tli_ExecBase = TNULL;
return TNULL;
}
LOCAL TCALLBACK struct TTimeRequest *
hal_open(struct THALBase *hal, struct TTask *task, TTAGITEM *tags)
{
struct HALSpecific *hws = hal->hmb_Specific;
TAPTR exec = (TAPTR) TGetTag(tags, THalBase_Exec, TNULL);
struct TTimeRequest *req;
hws->hsp_ExecBase = exec;
req = TExecAllocMsg0(exec, sizeof(struct TTimeRequest));
if (req)
{
EnterCriticalSection(&hws->hsp_DevLock);
if (!hws->hsp_Timer)
{
if (timeBeginPeriod(1) == TIMERR_NOERROR)
{
g_hws = hws;
g_hal = hal;
TInitList(&g_ReplyList);
TInitList(&hws->hsp_ReqList);
hws->hsp_Timer =
timeSetEvent(1, 1, hal_timeproc, TNULL, TIME_PERIODIC);
}
}
if (hws->hsp_Timer)
{
hws->hsp_RefCount++;
req->ttr_Req.io_Device = (struct TModule *) hal;
}
else
{
TExecFree(exec, req);
req = TNULL;
}
LeaveCriticalSection(&hws->hsp_DevLock);
}
return req;
}
TLIBAPI TTAG
TGetTag(struct TTagItem *taglist, TUINT tag, TTAG defvalue)
{
TUINT listtag;
while (taglist)
{
listtag = taglist->tti_Tag;
switch (listtag)
{
case TTAG_DONE:
return defvalue;
case TTAG_MORE:
taglist = (struct TTagItem *) taglist->tti_Value;
break;
case TTAG_SKIP:
taglist += 1 + (TINT) taglist->tti_Value;
break;
case TTAG_GOSUB:
{
TTAG res = TGetTag((struct TTagItem *) taglist->tti_Value,
tag,defvalue);
if (res != defvalue)
return res;
taglist++;
break;
}
default:
if (tag == listtag)
return taglist->tti_Value;
case TTAG_IGNORE:
taglist++;
break;
}
}
return defvalue;
}
static TAPTR rfb_modopen(struct rfb_Display *mod, TTAGITEM *tags)
{
TBOOL success = TTRUE;
TExecLock(mod->rfb_ExecBase, mod->rfb_Lock);
if (mod->rfb_RefCount == 0)
success = rfb_init(mod, tags);
if (success)
mod->rfb_RefCount++;
TExecUnlock(mod->rfb_ExecBase, mod->rfb_Lock);
if (success)
{
/* Attributes that can be queried during open: */
TTAG p = TGetTag(tags, TVisual_HaveWindowManager, TNULL);
if (p)
*((TBOOL *) p) = TFALSE;
return mod;
}
return TNULL;
}
LOCAL void
fb_copyarea(WINDISPLAY *mod, struct TVRequest *req)
{
WINWINDOW *win = req->tvr_Op.CopyArea.Window;
struct THook *exposehook = (struct THook *)
TGetTag(req->tvr_Op.CopyArea.Tags, TVisual_ExposeHook, TNULL);
TINT *sr = req->tvr_Op.CopyArea.Rect;
TINT dx = req->tvr_Op.CopyArea.DestX - sr[0];
TINT dy = req->tvr_Op.CopyArea.DestY - sr[1];
RECT r;
r.left = sr[4];
r.top = sr[5];
r.right = sr[4] + sr[2];
r.bottom = sr[5] + sr[3];
if (exposehook)
{
RGNDATAHEADER *rdh = (RGNDATAHEADER *) win->fbv_RegionData;
RECT *rd = (RECT *) (rdh + 1);
HRGN updateregion = CreateRectRgn(0, 0, 0, 0);
ScrollDC(win->fbv_HDC, dx, dy, &r, &r, updateregion, NULL);
if (GetRegionData(updateregion, 1024, (LPRGNDATA) rdh))
{
TUINT i;
for (i = 0; i < rdh->nCount; ++i)
TCallHookPkt(exposehook, win, (TTAG) (rd + i));
}
else
{
TDBPRINTF(TDB_WARN,("Regiondata buffer too small\n"));
InvalidateRgn(win->fbv_HWnd, updateregion, FALSE);
}
DeleteObject(updateregion);
}
else
ScrollDC(win->fbv_HDC, dx, dy, &r, &r, NULL, NULL);
win->fbv_Dirty = TTRUE;
}
LOCAL TCALLBACK struct TTimeRequest *
hal_open(struct THALBase *hal, struct TTask *task, TTAGITEM *tags)
{
struct HALSpecific *hws = hal->hmb_Specific;
TAPTR exec = (TAPTR) TGetTag(tags, THalBase_Exec, TNULL);
struct TTimeRequest *req;
hws->hsp_ExecBase = exec;
req = TExecAllocMsg0(exec, sizeof(struct TTimeRequest));
if (req)
{
EnterCriticalSection(&hws->hsp_DevLock);
if (!hws->hsp_DevTask)
{
TTAGITEM tasktags[2];
tasktags[0].tti_Tag = TTask_Name; /* set task name */
tasktags[0].tti_Value = (TTAG) TTASKNAME_HALDEV;
tasktags[1].tti_Tag = TTAG_DONE;
TInitList(&hws->hsp_ReqList);
hws->hsp_DevTask = TExecCreateSysTask(exec, hal_devfunc, tasktags);
}
if (hws->hsp_DevTask)
{
hws->hsp_RefCount++;
req->ttr_Req.io_Device = (struct TModule *) hal;
}
else
{
TExecFree(exec, req);
req = TNULL;
}
LeaveCriticalSection(&hws->hsp_DevLock);
}
return req;
}
static struct TVisualBase *
vis_modopen(struct TVisualBase *mod, TTAGITEM *tags)
{
struct TExecBase *TExecBase = TGetExecBase(mod);
struct TVisualBase *inst = TNULL;
TBOOL success = TTRUE;
TLock(mod->vis_Lock);
if (mod->vis_RefCount == 0)
success = vis_init(mod);
if (success)
mod->vis_RefCount++;
TUnlock(mod->vis_Lock);
if (success)
{
struct TVisualBase *base =
(struct TVisualBase *) TGetTag(tags, TVisual_Attach, TNULL);
if (TGetTag(tags, TVisual_NewInstance, TFALSE)) base = mod;
if (base)
{
inst = (struct TVisualBase *) TNewInstance((struct TModule *) base,
base->vis_Module.tmd_PosSize, base->vis_Module.tmd_NegSize);
if (inst)
{
TInitList(&inst->vis_ReqPool);
TInitList(&inst->vis_WaitList);
inst->vis_IMsgPort = (struct TMsgPort *)
TGetTag(tags, TVisual_IMsgPort, TNULL);
if (inst->vis_IMsgPort == TNULL)
{
inst->vis_IMsgPort = TCreatePort(TNULL);
inst->vis_Flags |= TVISFL_IMSGPORT_OWNER;
}
inst->vis_CmdRPort = (struct TMsgPort *)
TGetTag(tags, TVisual_CmdRPort, TNULL);
if (inst->vis_CmdRPort == TNULL)
{
inst->vis_CmdRPort = TCreatePort(TNULL);
inst->vis_Flags |= TVISFL_CMDRPORT_OWNER;
}
if (inst->vis_IMsgPort == TNULL || inst->vis_CmdRPort == TNULL)
{
vis_destroyports(inst);
TFreeInstance(&inst->vis_Module);
inst = TNULL;
}
}
if (inst == TNULL)
vis_modclose(mod);
}
else
inst = mod;
}
return inst;
}
TLIBAPI TSTRPTR
TEKlib_GetProgDir(TAPTR boot, TTAGITEM *tags)
{
TSTRPTR progdir = TNULL;
TSTRPTR *argv;
TINT argc;
progdir = (TSTRPTR) TGetTag(tags, TExecBase_ProgDir, TEKHOST_PROGDIR);
if (progdir)
{
TINT l = strlen(progdir);
TSTRPTR p = TEKlib_Alloc(boot, l + 1);
if (p)
{
strcpy(p, progdir);
return p;
}
return TNULL;
}
argc = (TINT) TGetTag(tags, TExecBase_ArgC, 0);
argv = (TSTRPTR *) TGetTag(tags, TExecBase_ArgV, TNULL);
if (argc >= 1 && argv)
{
TSTRPTR olddir = TEKlib_Alloc(boot, MAX_PATH_LEN);
if (olddir)
{
if (getcwd(olddir, MAX_PATH_LEN))
{
progdir = TEKlib_Alloc(boot, MAX_PATH_LEN + 1);
if (progdir)
{
TBOOL success = TFALSE;
TINT l = 0;
TSTRPTR s = argv[0];
TINT c;
while (*s)
{
s++;
l++;
}
if (l > 0)
{
success = TTRUE;
while ((c = *(--s)))
{
if (c == '/')
break;
l--;
}
if (l > 0)
{
TSTRPTR d, pathpart = TEKlib_Alloc(boot, l + 1);
success = TFALSE;
if (pathpart)
{
s = argv[0];
d = pathpart;
while (l--)
*d++ = *s++;
*d = 0;
success = (chdir(pathpart) == 0);
TEKlib_FreeVec(boot, pathpart);
}
}
}
if (success)
success = (getcwd(progdir, MAX_PATH_LEN) != TNULL);
if (!(chdir(olddir) == 0))
success = TFALSE;
if (success)
strcat(progdir, "/");
else
{
TEKlib_FreeVec(boot, progdir);
progdir = TNULL;
}
}
}
TEKlib_FreeVec(boot, olddir);
}
}
return progdir;
}
LOCAL void x11_taskfunc(struct TTask *task)
{
TAPTR TExecBase = TGetExecBase(task);
struct X11Display *inst = TGetTaskData(task);
TUINT sig = 0;
fd_set rset;
struct TVRequest *req;
TIMSG *imsg;
char buf[256];
struct timeval tv, *ptv;
struct TMsgPort *cmdport = TGetUserPort(task);
TUINT cmdportsignal = TGetPortSignal(cmdport);
TUINT ireplysignal = TGetPortSignal(inst->x11_IReplyPort);
TUINT waitsigs = cmdportsignal | ireplysignal | TTASK_SIG_ABORT;
/* interval time: 1/50s: */
TTIME intt = { 20000 };
/* next absolute time to send interval message: */
TTIME nextt;
TTIME waitt, nowt;
TDBPRINTF(TDB_INFO, ("Device instance running\n"));
TGetSystemTime(&nowt);
nextt = nowt;
TAddTime(&nextt, &intt);
do
{
if (sig & ireplysignal)
{
while ((imsg = TGetMsg(inst->x11_IReplyPort)))
{
/* returned input message */
if (imsg->timsg_Type == TITYPE_REQSELECTION)
{
XSelectionEvent *reply =
(XSelectionEvent *) imsg->timsg_Requestor;
struct TTagItem *replytags =
(struct TTagItem *) imsg->timsg_ReplyData;
size_t len =
TGetTag(replytags, TIMsgReply_UTF8SelectionLen, 0);
TUINT8 *xdata = (TUINT8 *) TGetTag(replytags,
TIMsgReply_UTF8Selection, TNULL);
XChangeProperty(inst->x11_Display, reply->requestor,
reply->property, XA_ATOM, 8, PropModeReplace,
(unsigned char *) xdata, len);
XSendEvent(inst->x11_Display, reply->requestor, 0,
NoEventMask, (XEvent *) reply);
XSync(inst->x11_Display, False);
TFree((TAPTR) imsg->timsg_Requestor);
TFree(xdata);
/* reqselect roundtrip ended */
}
TFree(imsg);
}
}
if (sig & cmdportsignal)
{
while (inst->x11_RequestInProgress == TNULL &&
(req = TGetMsg(cmdport)))
{
x11_docmd(inst, req);
if (inst->x11_RequestInProgress)
break;
TReplyMsg(req);
}
}
XFlush(inst->x11_Display);
FD_ZERO(&rset);
FD_SET(inst->x11_fd_display, &rset);
FD_SET(inst->x11_fd_sigpipe_read, &rset);
TGetSystemTime(&nowt);
if (inst->x11_NumInterval > 0 || inst->x11_RequestInProgress)
{
if (TCmpTime(&nowt, &nextt) >= 0)
{
/* expired; send interval: */
struct TNode *next, *node = inst->x11_vlist.tlh_Head.tln_Succ;
for (; (next = node->tln_Succ); node = next)
{
struct X11Window *v = (struct X11Window *) node;
TIMSG *imsg;
if ((v->eventmask & TITYPE_INTERVAL) &&
x11_getimsg(inst, v, &imsg, TITYPE_INTERVAL))
TPutMsg(v->imsgport, TNULL, imsg);
}
TAddTime(&nextt, &intt);
}
/* calculate new wait time: */
waitt = nextt;
TSubTime(&waitt, &nowt);
if (waitt.tdt_Int64 <= 0 || waitt.tdt_Int64 > 20000)
{
nextt = nowt;
TAddTime(&nextt, &intt);
waitt = nextt;
TSubTime(&waitt, &nowt);
}
tv.tv_sec = waitt.tdt_Int64 / 1000000;
tv.tv_usec = waitt.tdt_Int64 % 1000000;
ptv = &tv;
}
else
ptv = NULL;
/* wait for display, signal fd and timeout: */
if (select(inst->x11_fd_max, &rset, NULL, NULL, ptv) > 0)
{
int nbytes;
/* consume signal: */
if (FD_ISSET(inst->x11_fd_sigpipe_read, &rset))
{
ioctl(inst->x11_fd_sigpipe_read, FIONREAD, &nbytes);
if (nbytes > 0)
if (read(inst->x11_fd_sigpipe_read, buf,
TMIN(sizeof(buf), (size_t) nbytes)) != nbytes)
TDBPRINTF(TDB_ERROR,
("could not read wakeup signal\n"));
}
}
/* process input messages: */
x11_processevent(inst);
/* send out input messages to owners: */
x11_sendimessages(inst);
/* get signal state: */
sig = TSetSignal(0, waitsigs);
}
while (!(sig & TTASK_SIG_ABORT));
TDBPRINTF(TDB_INFO, ("Device instance exit\n"));
x11_exitinstance(inst);
}
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;
}
LOCAL void
fb_openwindow(WINDISPLAY *mod, struct TVRequest *req)
{
struct TExecBase *TExecBase = TGetExecBase(mod);
TTAGITEM *tags = req->tvr_Op.OpenWindow.Tags;
WINWINDOW *win;
req->tvr_Op.OpenWindow.Window = TNULL;
for (;;)
{
RECT wrect;
BITMAPINFOHEADER *bmi;
TUINT style;
TUINT exstyle;
TIMSG *imsg;
const char *classname;
TSTRPTR title;
win = TAlloc0(mod->fbd_MemMgr, sizeof(WINWINDOW));
if (win == TNULL)
break;
TInitList(&win->penlist);
InitializeCriticalSection(&win->fbv_LockExtents);
win->fbv_Width = (TUINT) TGetTag(tags, TVisual_Width, FB_DEF_WIDTH);
win->fbv_Height = (TUINT) TGetTag(tags, TVisual_Height, FB_DEF_HEIGHT);
win->fbv_Left = (TUINT) TGetTag(tags, TVisual_WinLeft, 0xffffffff);
win->fbv_Top = (TUINT) TGetTag(tags, TVisual_WinTop, 0xffffffff);
win->fbv_Title = (TSTRPTR) TGetTag(tags, TVisual_Title,
(TTAG) "TEKlib Visual");
win->fbv_Borderless = TGetTag(tags, TVisual_Borderless, TFALSE);
win->fbv_UserData = TGetTag(tags, TVisual_UserData, TNULL);
win->fbv_MinWidth = (TINT) TGetTag(tags, TVisual_MinWidth, (TTAG) -1);
win->fbv_MinHeight = (TINT) TGetTag(tags, TVisual_MinHeight, (TTAG) -1);
win->fbv_MaxWidth = (TINT) TGetTag(tags, TVisual_MaxWidth, (TTAG) -1);
win->fbv_MaxHeight = (TINT) TGetTag(tags, TVisual_MaxHeight, (TTAG) -1);
if (win->fbv_Borderless)
{
style = (WS_POPUP | WS_CLIPCHILDREN | WS_CLIPSIBLINGS) & ~WS_BORDER;
classname = FB_DISPLAY_CLASSNAME_POPUP;
title = NULL;
exstyle = WS_EX_TOPMOST | WS_EX_TOOLWINDOW;
}
else
{
style = WS_OVERLAPPEDWINDOW;
classname = FB_DISPLAY_CLASSNAME;
title = win->fbv_Title;
exstyle = 0;
}
wrect.left = wrect.right = wrect.top = wrect.bottom = 0;
AdjustWindowRectEx(&wrect, style, FALSE, exstyle);
win->fbv_BorderWidth = wrect.right - wrect.left;
win->fbv_BorderHeight = wrect.bottom - wrect.top;
win->fbv_BorderLeft = -wrect.left;
win->fbv_BorderTop = -wrect.top;
if (!win->fbv_Borderless)
{
TINT m1, m2, m3, m4;
win_getminmax(win, &m1, &m2, &m3, &m4, TTRUE);
win->fbv_Width = TCLAMP(m1, (TINT) win->fbv_Width, m3);
win->fbv_Height = TCLAMP(m2, (TINT) win->fbv_Height, m4);
}
if (win->fbv_Left != 0xffffffff && win->fbv_Top != 0xffffffff)
{
wrect.left = win->fbv_Left;
wrect.top = win->fbv_Top;
wrect.right = win->fbv_Left + win->fbv_Width;
wrect.bottom = win->fbv_Top + win->fbv_Height;
if (!AdjustWindowRectEx(&wrect, style, FALSE, exstyle))
break;
win->fbv_Left = wrect.left;
win->fbv_Top = wrect.top;
win->fbv_HWnd = CreateWindowEx(exstyle, classname,
title, style, win->fbv_Left, win->fbv_Top,
wrect.right - wrect.left - win->fbv_BorderWidth,
wrect.bottom - wrect.top - win->fbv_BorderHeight,
(HWND) NULL, (HMENU) NULL, mod->fbd_HInst, (LPVOID) NULL);
}
else
{
win->fbv_HWnd = CreateWindowEx(exstyle, classname,
title, style, CW_USEDEFAULT, CW_USEDEFAULT,
win->fbv_Width, win->fbv_Height,
(HWND) NULL, (HMENU) NULL, mod->fbd_HInst, (LPVOID) NULL);
}
if (win->fbv_HWnd == TNULL)
break;
GetWindowRect(win->fbv_HWnd, &wrect);
win->fbv_Left = wrect.left + win->fbv_BorderLeft;
win->fbv_Top = wrect.top + win->fbv_BorderHeight;
win->fbv_Width = wrect.right - wrect.left - win->fbv_BorderWidth;
win->fbv_Height = wrect.bottom - wrect.top - win->fbv_BorderHeight;
SetWindowLongPtr(win->fbv_HWnd, GWLP_USERDATA, (LONG_PTR) win);
win->fbv_HDC = GetDC(win->fbv_HWnd);
win->fbv_Display = mod;
win->fbv_InputMask = (TUINT) TGetTag(tags, TVisual_EventMask, 0);
win->fbv_IMsgPort = req->tvr_Op.OpenWindow.IMsgPort;
bmi = &win->fbv_DrawBitMap;
bmi->biSize = sizeof(BITMAPINFOHEADER);
bmi->biPlanes = 1;
bmi->biBitCount = 32;
bmi->biCompression = BI_RGB;
bmi->biSizeImage = 0;
bmi->biXPelsPerMeter = 1;
bmi->biYPelsPerMeter = 1;
bmi->biClrUsed = 0;
bmi->biClrImportant = 0;
TInitList(&win->fbv_IMsgQueue);
req->tvr_Op.OpenWindow.Window = win;
/* init default font */
win->fbv_CurrentFont = mod->fbd_FontManager.deffont;
mod->fbd_FontManager.defref++;
if (win->fbv_InputMask & TITYPE_INTERVAL)
++mod->fbd_NumInterval;
/* register default font */
/*TDBPRINTF(TDB_TRACE,("Add window: %p\n", win->window));*/
/* add window on top of window stack: */
TAddHead(&mod->fbd_VisualList, &win->fbv_Node);
SetBkMode(win->fbv_HDC, TRANSPARENT);
ShowWindow(win->fbv_HWnd, SW_SHOWNORMAL);
UpdateWindow(win->fbv_HWnd);
if ((win->fbv_InputMask & TITYPE_FOCUS) &&
(fb_getimsg(mod, win, &imsg, TITYPE_FOCUS)))
{
imsg->timsg_Code = 1;
TAddTail(&win->fbv_IMsgQueue, &imsg->timsg_Node);
}
if ((win->fbv_InputMask & TITYPE_REFRESH) &&
(fb_getimsg(mod, win, &imsg, TITYPE_REFRESH)))
{
imsg->timsg_X = 0;
imsg->timsg_Y = 0;
imsg->timsg_Width = win->fbv_Width;
imsg->timsg_Height = win->fbv_Height;
TAddTail(&win->fbv_IMsgQueue, &imsg->timsg_Node);
}
return;
}
TDBPRINTF(TDB_ERROR,("Window open failed\n"));
fb_closeall(mod, win, TFALSE);
}
LOCAL TAPTR fb_hostqueryfonts(WINDISPLAY *mod, TTAGITEM *tags)
{
struct TExecBase *TExecBase = TGetExecBase(mod);
TSTRPTR names;
LOGFONT logfont;
char *namebuf = logfont.lfFaceName;
struct FontQueryHandle *fqh;
fqh = TAlloc0(TNULL, sizeof(struct FontQueryHandle));
if (fqh == TNULL)
return TNULL;
fqh->handle.thn_Owner = mod;
TInitHook(&fqh->handle.thn_Hook, fqhdestroy, fqh);
TInitList(&fqh->reslist);
fqh->fpxsize = (TINT) TGetTag(tags, TVisual_FontPxSize, (TTAG) FNTQUERY_UNDEFINED);
fqh->fitalic = (TBOOL) TGetTag(tags, TVisual_FontItalic, (TTAG) FNTQUERY_UNDEFINED);
fqh->fbold = (TBOOL) TGetTag(tags, TVisual_FontBold, (TTAG) FNTQUERY_UNDEFINED);
fqh->fscale = (TBOOL) TGetTag(tags, TVisual_FontScaleable, (TTAG) FNTQUERY_UNDEFINED);
fqh->fnum = (TINT) TGetTag(tags, TVisual_FontNumResults, (TTAG) INT_MAX);
fqh->success = TTRUE;
names = (TSTRPTR) TGetTag(tags, TVisual_FontName, TNULL);
if (names == TNULL)
names = "";
for (;;)
{
TSTRPTR p = strchr(names, ',');
if (p)
{
size_t len2 = TMIN(p - names, LF_FACESIZE - 1);
memcpy(namebuf, names, len2);
namebuf[len2] = 0;
names += p - names + 1;
}
else
{
size_t len = strlen(names);
size_t len2 = TMIN(len, LF_FACESIZE - 1);
memcpy(namebuf, names, len2);
namebuf[len2] = 0;
names += len;
}
logfont.lfCharSet = ANSI_CHARSET;
logfont.lfPitchAndFamily = 0;
TDBPRINTF(TDB_INFO,("query font: %s\n", namebuf));
if (strcmp(namebuf, "") == 0)
fqh->match_depth = 0; /* find font first */
else
fqh->match_depth = 1; /* find style */
EnumFontFamiliesEx(
mod->fbd_DeviceHDC,
&logfont,
(FONTENUMPROCA) fontenumcb,
(LPARAM) fqh, 0);
if (strlen(names) == 0)
break;
}
fqh->nptr = &fqh->reslist.tlh_Head;
if (fqh->success)
return fqh;
TDestroy(&fqh->handle);
return TNULL;
}
static TBOOL rfb_inittask(struct TTask *task)
{
TAPTR TExecBase = TGetExecBase(task);
struct rfb_Display *mod = TGetTaskData(task);
for (;;)
{
TTAGITEM *opentags = mod->rfb_OpenTags;
TSTRPTR subname;
/* Initialize rectangle pool */
region_initpool(&mod->rfb_RectPool, TExecBase);
/* list of free input messages: */
TInitList(&mod->rfb_IMsgPool);
/* list of all open visuals: */
TInitList(&mod->rfb_VisualList);
/* init fontmanager and default font */
TInitList(&mod->rfb_FontManager.openfonts);
region_init(&mod->rfb_RectPool, &mod->rfb_DirtyRegion, TNULL);
mod->rfb_PixBuf.tpb_Format = TVPIXFMT_UNDEFINED;
mod->rfb_DevWidth = RFB_DEF_WIDTH;
mod->rfb_DevHeight = RFB_DEF_HEIGHT;
mod->rfb_Flags = RFBFL_BUFFER_CAN_RESIZE;
#if defined(ENABLE_LINUXFB)
if (!rfb_linux_init(mod))
break;
#endif
/* Instance lock (currently needed for async VNC) */
mod->rfb_InstanceLock = TCreateLock(TNULL);
if (mod->rfb_InstanceLock == TNULL)
break;
/* Open sub device, if one is requested: */
subname = (TSTRPTR) TGetTag(opentags, TVisual_DriverName,
(TTAG) SUBDEVICE_NAME);
if (subname)
{
TTAGITEM subtags[2];
subtags[0].tti_Tag = TVisual_IMsgPort;
subtags[0].tti_Value = TGetTag(opentags, TVisual_IMsgPort, TNULL);
subtags[1].tti_Tag = TTAG_DONE;
mod->rfb_RndRPort = TCreatePort(TNULL);
if (mod->rfb_RndRPort == TNULL)
break;
mod->rfb_RndDevice = TOpenModule(subname, 0, subtags);
if (mod->rfb_RndDevice == TNULL)
break;
mod->rfb_RndRequest = TAllocMsg(sizeof(struct TVRequest));
if (mod->rfb_RndRequest == TNULL)
break;
mod->rfb_RndIMsgPort = TCreatePort(TNULL);
if (mod->rfb_RndIMsgPort == TNULL)
break;
}
TDBPRINTF(TDB_TRACE, ("Instance init successful\n"));
return TTRUE;
}
rfb_exittask(mod);
return TFALSE;
}
