static void fb_dowindow(TAPTR task)
{
struct TExecBase *TExecBase = TGetExecBase(task);
WINWINDOW *win = TGetTaskData(task);
WINDISPLAY *mod = win->fbv_Display;
MSG msg;
TUINT sig;
TDBPRINTF(TDB_INFO,("DoWindow...\n"));
do
{
WaitMessage();
while (PeekMessage(&msg, win->fbv_HWnd, 0,0, PM_REMOVE))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
// PostMessage(win->fbv_HWnd, WM_USER, 0, 0);
sig = TSetSignal(0, TTASK_SIG_ABORT);
} while (!(sig & TTASK_SIG_ABORT));
TDBPRINTF(TDB_INFO,("Window Done\n"));
TLock(mod->fbd_Lock);
TRemove(&win->fbv_Node);
TUnlock(mod->fbd_Lock);
fb_closeall(mod, win, TTRUE);
}
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;
}
EXPORT TBOOL
hal_scanmodules(struct THALBase *hal, TSTRPTR path, struct THook *hook)
{
TSTRPTR p;
struct HALSpecific *hws = hal->hmb_Specific;
TBOOL success = TFALSE;
p = getmodpath(hws->hsp_ProgDir, "mod\\*.dll");
if (p)
{
TDBPRINTF(TDB_TRACE,("scanning %s\n", p));
success = scanpathtolist(hook, p, path);
free(p);
}
if (success)
{
p = getmodpath(hws->hsp_ModDir, "*.dll");
if (p)
{
TDBPRINTF(TDB_TRACE,("scanning %s\n", p));
success = scanpathtolist(hook, p, path);
free(p);
}
}
return success;
}
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;
}
static struct rfb_FontQueryNode *fnt_getfqnode(struct rfb_Display *mod,
TSTRPTR filename, TINT pxsize)
{
struct rfb_FontQueryNode *fqnode = TNULL;
TAPTR TExecBase = TGetExecBase(mod);
/* allocate fquery node */
fqnode = TAlloc0(mod->rfb_MemMgr, sizeof(struct rfb_FontQueryNode));
if (fqnode)
{
/* fquerynode ready - fill in attributes */
TSTRPTR myfname = TNULL;
TINT flen = strlen(filename) - 4; /* discard '.ttf' */
if (flen > 0)
myfname = TAlloc0(mod->rfb_MemMgr, flen + 1);
else
TDBPRINTF(20, ("found invalid font: '%s'\n", filename));
if (myfname)
{
memcpy(myfname, filename, flen);
fqnode->tags[0].tti_Tag = TVisual_FontName;
fqnode->tags[0].tti_Value = (TTAG) myfname;
}
else
{
if (flen > 0)
TDBPRINTF(20, ("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
{
TFree(fqnode);
fqnode = TNULL;
}
} /* endif fqnode */
else
TDBPRINTF(20, ("out of memory :(\n"));
return fqnode;
}
/* 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_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;
}
/* dump properties of a fontquerynode
*/
static void
fnt_dumpnode(struct FontQueryNode *fqn)
{
TDBPRINTF(10, ("-----------------------------------------------\n"));
TDBPRINTF(10, ("dumping fontquerynode @ %p\n", fqn));
TDBPRINTF(10, (" * FontName: %s\n", (TSTRPTR)fqn->tags[0].tti_Value));
TDBPRINTF(10, (" * PxSize: %d\n", (TINT)fqn->tags[1].tti_Value));
//TDBPRINTF(10, (" * Italic: %s\n", (TBOOL)fqn->tags[2].tti_Value ? "on" : "off"));
//TDBPRINTF(10, (" * Bold: %s\n", (TBOOL)fqn->tags[3].tti_Value ? "on" : "off"));
TDBPRINTF(10, ("-----------------------------------------------\n"));
}
LOCAL void
fb_getselection(WINDISPLAY *mod, struct TVRequest *req)
{
struct TExecBase *TExecBase = TGetExecBase(mod);
LPSTR utf8 = NULL;
int utf8Bytes = 0;
HANDLE clipData;
LPCWSTR utf16;
req->tvr_Op.GetSelection.Data = TNULL;
req->tvr_Op.GetSelection.Length = 0;
if (!IsClipboardFormatAvailable(CF_UNICODETEXT))
{
TDBPRINTF(TDB_WARN,(
"no 'CF_UNICODETEXT' Windows clipboard data available\n"));
return;
}
if (!OpenClipboard(mod->fbd_DeviceHWnd))
{
TDBPRINTF(TDB_WARN, ("cannot open Windows clipboard\n"));
return;
}
clipData = GetClipboardData(CF_UNICODETEXT);
if (clipData != NULL)
{
utf16 = GlobalLock(clipData);
utf8Bytes = WideCharToMultiByte(CP_UTF8, 0, utf16, -1,
NULL, 0, NULL, 0);
if (utf8Bytes != 0)
{
utf8 = (LPSTR) TAlloc(TNULL, utf8Bytes);
utf8Bytes = WideCharToMultiByte(CP_UTF8, 0, utf16, -1,
utf8, utf8Bytes, NULL, 0);
}
GlobalUnlock(clipData);
}
else
TDBPRINTF(TDB_WARN, ("no Windows clipboard data\n"));
CloseClipboard();
if (!utf8Bytes)
{
TFree(utf8);
TDBPRINTF(TDB_WARN, (
"failed encoding UTF-8 from Windows clipboard\n"));
return;
}
--utf8Bytes;
TDBPRINTF(TDB_TRACE,("get selection: N = %d S = '%s'\n", utf8Bytes, utf8));
req->tvr_Op.GetSelection.Data = utf8;
req->tvr_Op.GetSelection.Length = utf8Bytes;
}
static TCALLBACK TINT
tek_lib_display_dfb_close(lua_State *L)
{
TEKDisplay *display = luaL_checkudata(L, 1, TEK_LIB_DISPLAY_DFB_CLASSNAME);
TDBPRINTF(TDB_TRACE,("display %08x closing\n", display));
if (display->IsBase)
{
/* collected base; remove TEKlib module: */
TExecRemModules(display->ExecBase, &display->InitModules, 0);
TDBPRINTF(TDB_TRACE,("display module removed\n"));
}
return 0;
}
LOCAL TINT rfb_sendevent(struct rfb_Display *mod, TUINT type, TUINT code,
TINT x, TINT y)
{
TIMSG *msg;
if (!rfb_getimsg(mod, TNULL, &msg, type))
return 0;
msg->timsg_Code = code;
msg->timsg_MouseX = x;
msg->timsg_MouseY = y;
TINT res = 1;
switch (type)
{
case TITYPE_MOUSEMOVE:
rfb_passevent_mousemove(mod, msg);
break;
case TITYPE_MOUSEBUTTON:
rfb_passevent_mousebutton(mod, msg);
break;
case TITYPE_KEYUP:
case TITYPE_KEYDOWN:
rfb_passevent_keyboard(mod, msg);
break;
default:
TDBPRINTF(TDB_ERROR, ("illegal message type\n"));
res = 0;
}
/* put back prototype message */
TAddTail(&mod->rfb_IMsgPool, &msg->timsg_Node);
return res;
}
LOCAL void
dfb_closevisual(DFBDISPLAY *mod, struct TVRequest *req)
{
struct DFBPen *pen;
TAPTR exec = TGetExecBase(mod);
DFBWINDOW *v = req->tvr_Op.CloseWindow.Window;
if (v == TNULL) return;
TDBPRINTF(TDB_INFO,("Visual close\n"));
TRemove(&v->node);
if (mod->dfb_Focused == (TAPTR) v)
{
/* pass focus on to the next window */
DFBWINDOW *vt = (DFBWINDOW *)TFIRSTNODE(&mod->dfb_vlist);
if (vt) genimsg(mod, TNULL, vt, TITYPE_FOCUS);
mod->dfb_Focused = (TAPTR) vt;
}
if (mod->dfb_Active == (TAPTR) v)
mod->dfb_Active = TNULL;
while ((pen = (struct DFBPen *) TRemHead(&v->penlist)))
{
/* free pens */
TRemove(&pen->node);
TExecFree(mod->dfb_ExecBase, pen);
}
v->winsurface->Release(v->winsurface);
v->window->Release(v->window);
mod->dfb_fm.defref--;
TExecFree(exec, v);
}
LOCAL void
fb_openfont(WINDISPLAY *mod, struct TVRequest *req)
{
req->tvr_Op.OpenFont.Font =
fb_hostopenfont(mod, req->tvr_Op.OpenFont.Tags);
TDBPRINTF(TDB_INFO,("font opened: %p\n", req->tvr_Op.OpenFont.Font));
}
LOCAL void
exec_returnmsg(TEXECBASE *exec, TAPTR mem, TUINT status)
{
struct TMessage *msg = TGETMSGPTR(mem);
struct TMsgPort *replyport = msg->tmsg_RPort;
if (replyport)
{
TAPTR hal = exec->texb_HALBase;
THALLock(hal, &replyport->tmp_Lock);
TAddTail(&replyport->tmp_MsgList, (struct TNode *) msg);
msg->tmsg_Flags = status;
if (replyport->tmp_Hook)
TCALLHOOKPKT(replyport->tmp_Hook, replyport, (TTAG) msg);
THALUnlock(hal, &replyport->tmp_Lock);
THALSignal(hal, &replyport->tmp_SigTask->tsk_Thread,
replyport->tmp_Signal);
}
else
{
exec_Free(exec, mem); /* free one-way msg transparently */
TDBPRINTF(TDB_TRACE,("message returned to memory manager\n"));
}
}
static THOOKENTRY TTAG
exec_dispatch(struct THook *hook, TAPTR obj, TTAG msg)
{
struct TExecBase *TExecBase = hook->thk_Data;
switch (msg)
{
case TMSG_DESTROY:
THALDestroyLock(TExecBase->texb_HALBase, &TExecBase->texb_Lock);
TDESTROY(&TExecBase->texb_BaseMemManager);
TDESTROY(&TExecBase->texb_MsgMemManager);
break;
#if defined(ENABLE_EXEC_IFACE)
case TMSG_QUERYIFACE:
{
struct TInterfaceQuery *ifq = obj;
if (TStrEqual(ifq->tifq_Name, "exec") &&
ifq->tifq_Version >= 1)
return (TTAG) &TExecBase->texb_Exec1IFace;
return TNULL;
}
case TMSG_DROPIFACE:
TDBPRINTF(TDB_WARN,("drop interface: %p\n", obj));
break;
#endif
}
return 0;
}
static void
init_destroyatom(TAPTR exec, TAPTR atom, TSTRPTR name)
{
if (TExecLockAtom(exec, atom,
TATOMF_TRY | TATOMF_DESTROY) != atom)
TDBPRINTF(20, ("atom '%s' is still in use\n", name));
}
static void x11_processevent(struct X11Display *mod)
{
TAPTR TExecBase = TGetExecBase(mod);
struct TNode *next, *node;
XEvent ev;
struct X11Window *v;
Window w;
while ((XPending(mod->x11_Display)) > 0)
{
XNextEvent(mod->x11_Display, &ev);
if (ev.type == mod->x11_ShmEvent)
{
if (mod->x11_RequestInProgress)
{
TReplyMsg(mod->x11_RequestInProgress);
mod->x11_RequestInProgress = TNULL;
TDBPRINTF(TDB_TRACE, ("Released request (ShmEvent)\n"));
}
else
TDBPRINTF(TDB_ERROR, ("shm event while no request pending\n"));
continue;
}
/* lookup window: */
w = ev.xany.window;
v = TNULL;
node = mod->x11_vlist.tlh_Head.tln_Succ;
for (; (next = node->tln_Succ); node = next)
{
v = (struct X11Window *) node;
if (v->window == w)
break;
v = TNULL;
}
if (v == TNULL)
{
TDBPRINTF(TDB_INFO,
("Message Type %04x from unknown window: %p\n", ev.type, w));
continue;
}
/* while true, spool out messages for this particular event: */
while (x11_processvisualevent(mod, v, TNULL, &ev)) ;
}
}
EXPORT void
hal_unloadmodule(struct THALBase *hal, TAPTR halmod)
{
struct HALModule *hwm = halmod;
FreeLibrary(hwm->hmd_Lib);
TDBPRINTF(2,("module unloaded\n"));
free(halmod);
}
/* 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;
}
}
}
static void fnt_getfnnodes(struct rfb_Display *mod, struct TList *fnlist,
TSTRPTR fname)
{
TINT i, p = 0;
TBOOL lastrun = TFALSE;
TINT fnlen = strlen(fname);
TAPTR TExecBase = mod->rfb_ExecBase;
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 = TAlloc0(mod->rfb_MemMgr, len + 1);
if (ts)
{
struct fnt_node *fnn;
memcpy(ts, fname + p, len);
fnn = TAlloc0(mod->rfb_MemMgr, sizeof(struct fnt_node));
if (fnn)
{
/* add fnnode to fnlist */
fnn->fname = ts;
TAddTail(fnlist, &fnn->node);
}
else
{
TDBPRINTF(20, ("out of memory :(\n"));
break;
}
}
else
{
TDBPRINTF(20, ("out of memory :(\n"));
break;
}
p = i + 1;
}
}
}
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;
}
TLIBAPI TBOOL region_orrectlist(struct RectPool *pool, struct RectList *list,
TINT s[4], TBOOL opportunistic)
{
if (list->rl_NumNodes > 0)
{
TINT x0 = s[0];
TINT y0 = s[1];
TINT x1 = s[2];
TINT y1 = s[3];
TUINT64 area = 0;
struct TNode *next, *node = list->rl_List.tlh_Head;
for (; (next = node->tln_Succ); node = next)
{
struct RectNode *rn = (struct RectNode *) node;
TINT *r = rn->rn_Rect;
if (s[0] >= r[0] && s[1] >= r[1] &&
s[2] <= r[2] && s[3] <= r[3])
return TTRUE;
if (!opportunistic)
continue;
area += (r[2] - r[0] + 1) * (r[3] - r[1] + 1);
x0 = TMIN(x0, r[0]);
y0 = TMIN(y0, r[1]);
x1 = TMAX(x1, r[2]);
y1 = TMAX(y1, r[3]);
}
if (opportunistic)
{
TUINT64 area2 = (x1 - x0 + 1) * (y1 - y0 + 1);
if (area2 < OPPORTUNISTIC_MERGE_THRESHOLD ||
(area * 256 / area2) > OPPORTUNISTIC_MERGE_RATIO)
{
/* merge list into a single rectangle */
TDBPRINTF(TDB_TRACE,("merge %d rects\n",
list->rl_NumNodes + 1));
region_freerects(pool, list);
assert(list->rl_NumNodes == 0);
return region_insertrect(pool, list, x0, y0, x1, y1);
}
}
}
struct RectList temp;
region_initrectlist(&temp);
if (region_cutrectlist(pool, list, &temp, s))
{
if (region_insertrect(pool, &temp, s[0], s[1], s[2], s[3]))
{
region_freerects(pool, list);
region_relinkrects(list, &temp);
return TTRUE;
}
}
region_freerects(pool, &temp);
return TFALSE;
}
static void
fb_modclose(WINDISPLAY *mod)
{
struct TExecBase *TExecBase = TGetExecBase(mod);
TDBPRINTF(TDB_TRACE,("Device close\n"));
TLock(mod->fbd_Lock);
if (--mod->fbd_RefCount == 0)
fb_exit(mod);
TUnlock(mod->fbd_Lock);
}
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
fb_setinput(WINDISPLAY *mod, struct TVRequest *req)
{
WINWINDOW *v = req->tvr_Op.SetInput.Window;
req->tvr_Op.SetInput.OldMask = v->fbv_InputMask;
v->fbv_InputMask = req->tvr_Op.SetInput.Mask;
TDBPRINTF(TDB_TRACE,("Setinputmask: %08x\n", v->fbv_InputMask));
/* spool out possible remaining messages: */
fb_sendimessages(mod, TFALSE);
}
static void TTASKENTRY hal_devfunc(struct TTask *task)
{
TAPTR exec = TGetExecBase(task);
struct THALBase *hal = TExecGetHALBase(exec);
struct HALSpecific *hps = hal->hmb_Specific;
struct HALThread *thread = TlsGetValue(hps->hsp_TLSIndex);
TAPTR port = TExecGetUserPort(exec, task);
struct TTimeRequest *msg;
TUINT sig = 0;
TTIME waittime, curtime;
struct TNode *nnode, *node;
waittime.ttm_Sec = 2000000000;
waittime.ttm_USec = 0;
for (;;)
{
sig = hal_timedwaitevent(hal, thread, &waittime,
TTASK_SIG_ABORT | TTASK_SIG_USER);
if (sig & TTASK_SIG_ABORT)
break;
EnterCriticalSection(&hps->hsp_DevLock);
hal_getsystime(hal, &curtime);
while ((msg = TExecGetMsg(exec, port)))
{
TAddTime(&msg->ttr_Data.ttr_Time, &curtime);
TAddTail(&hps->hsp_ReqList, (struct TNode *) msg);
}
waittime.ttm_Sec = 2000000000;
waittime.ttm_USec = 0;
node = hps->hsp_ReqList.tlh_Head;
for (; (nnode = node->tln_Succ); node = nnode)
{
struct TTimeRequest *tr = (struct TTimeRequest *) node;
TTIME *tm = &tr->ttr_Data.ttr_Time;
if (TCmpTime(&curtime, tm) >= 0)
{
TRemove(node);
tr->ttr_Req.io_Error = 0;
TExecReplyMsg(exec, node);
continue;
}
if (TCmpTime(tm, &waittime) < 0)
waittime = *tm;
}
LeaveCriticalSection(&hps->hsp_DevLock);
}
TDBPRINTF(2,("goodbye from HAL device\n"));
}
LOCAL TCALLBACK void
hal_close(struct THALBase *hal, struct TTask *task)
{
struct HALSpecific *hws = hal->hmb_Specific;
EnterCriticalSection(&hws->hsp_DevLock);
if (hws->hsp_DevTask)
{
if (--hws->hsp_RefCount == 0)
{
TDBPRINTF(2,("hal.device refcount dropped to 0\n"));
TExecSignal(hws->hsp_ExecBase, hws->hsp_DevTask, TTASK_SIG_ABORT);
TDBPRINTF(2,("destroy hal.device task...\n"));
TDestroy(hws->hsp_DevTask);
hws->hsp_DevTask = TNULL;
}
}
LeaveCriticalSection(&hws->hsp_DevLock);
}
LOCAL void
dfb_hostsetfont(DFBDISPLAY *mod, DFBWINDOW *v, TAPTR font)
{
if (font)
{
struct FontNode *fn = (struct FontNode *) font;
v->winsurface->SetFont(v->winsurface, fn->font);
v->curfont = font;
}
else
TDBPRINTF(TDB_ERROR,("invalid font specified\n"));
}
static int tek_lib_exec_base_gc(lua_State *L)
{
TAPTR *pexec = luaL_checkudata(L, 1, "tek.lib.exec.base.meta");
if (*pexec)
{
TAPTR basetask = TExecFindTask(*pexec, TTASKNAME_ENTRY);
TDestroy(basetask);
TDBPRINTF(5,("Exec closed\n"));
*pexec = TNULL;
}
return 0;
}
LOCAL TTAGITEM *fb_hostgetnextfont(WINDISPLAY *mod, struct FontQueryHandle *fqh)
{
struct TNode *next = *fqh->nptr;
TDBPRINTF(TDB_INFO,("getnextfont\n"));
if (next->tln_Succ == TNULL)
{
fqh->nptr = &fqh->reslist.tlh_Head;
return TNULL;
}
fqh->nptr = (struct TNode **)next;
return ((struct FontQueryNode *)next)->tags;
}
