static void rfb_exittask(struct rfb_Display *mod)
{
TAPTR TExecBase = TGetExecBase(mod);
struct TNode *imsg, *node, *next;
#if defined(ENABLE_LINUXFB)
rfb_linux_exit(mod);
#endif
TFree(mod->rfb_PtrBackBuffer.data);
if (mod->rfb_Flags & RFBFL_PTR_ALLOCATED)
TFree(mod->rfb_PtrImage.tpb_Data);
/* free pooled input messages: */
while ((imsg = TRemHead(&mod->rfb_IMsgPool)))
TFree(imsg);
/* close all fonts */
node = mod->rfb_FontManager.openfonts.tlh_Head.tln_Succ;
for (; (next = node->tln_Succ); node = next)
rfb_hostclosefont(mod, (TAPTR) node);
if (mod->rfb_Flags & RFBFL_BUFFER_OWNER)
TFree(mod->rfb_PixBuf.tpb_Data);
TDestroy(mod->rfb_RndIMsgPort);
TFree(mod->rfb_RndRequest);
TCloseModule(mod->rfb_RndDevice);
TDestroy((struct THandle *) mod->rfb_RndRPort);
TDestroy((struct THandle *) mod->rfb_InstanceLock);
region_free(&mod->rfb_RectPool, &mod->rfb_DirtyRegion);
region_destroypool(&mod->rfb_RectPool);
}
static void rfb_exittask(RFBDISPLAY *mod)
{
TAPTR TExecBase = TGetExecBase(mod);
struct TNode *imsg, *node, *next;
/* free pooled input messages: */
while ((imsg = TRemHead(&mod->rfb_IMsgPool)))
TFree(imsg);
/* close all fonts */
node = mod->rfb_FontManager.openfonts.tlh_Head;
for (; (next = node->tln_Succ); node = next)
rfb_hostclosefont(mod, (TAPTR) node);
if (mod->rfb_BufferOwner)
TFree(mod->rfb_BufPtr);
TDestroy(mod->rfb_RndIMsgPort);
TFree(mod->rfb_RndRequest);
TCloseModule(mod->rfb_RndDevice);
TDestroy((struct THandle *) mod->rfb_RndRPort);
TDestroy((struct THandle *) mod->rfb_InstanceLock);
if (mod->rfb_DirtyRegion)
region_destroy(&mod->rfb_RectPool, mod->rfb_DirtyRegion);
region_destroypool(&mod->rfb_RectPool);
}
static THOOKENTRY TTAG rfb_fqhdestroy(struct THook *hook, TAPTR obj, TTAG msg)
{
if (msg == TMSG_DESTROY)
{
struct rfb_FontQueryHandle *fqh = obj;
struct rfb_Display *mod = fqh->handle.thn_Owner;
TAPTR TExecBase = mod->rfb_ExecBase;
struct TNode *node, *next;
node = fqh->reslist.tlh_Head.tln_Succ;
for (; (next = node->tln_Succ); node = next)
{
struct rfb_FontQueryNode *fqn = (struct rfb_FontQueryNode *) node;
/* remove from resultlist */
TRemove(&fqn->node);
/* destroy fontname */
if (fqn->tags[0].tti_Value)
TFree((TAPTR) fqn->tags[0].tti_Value);
/* destroy node */
TFree(fqn);
}
/* destroy queryhandle */
TFree(fqh);
}
return 0;
}
static void
fb_closeall(WINDISPLAY *mod, WINWINDOW *win, TBOOL unref_font)
{
struct TExecBase *TExecBase = TGetExecBase(mod);
struct FBPen *pen;
if (win->fbv_HDC)
ReleaseDC(win->fbv_HWnd, win->fbv_HDC);
if (mod->fbd_WindowFocussedApp == win->fbv_HWnd)
mod->fbd_WindowFocussedApp = NULL;
if (mod->fbd_WindowUnderCursor == win->fbv_HWnd)
mod->fbd_WindowUnderCursor = NULL;
if (mod->fbd_WindowActivePopup == win->fbv_HWnd)
mod->fbd_WindowActivePopup = NULL;
if (win->fbv_HWnd)
DestroyWindow(win->fbv_HWnd);
while ((pen = (struct FBPen *) TRemHead(&win->penlist)))
TFree(pen);
if (unref_font)
mod->fbd_FontManager.defref--;
if (win->fbv_InputMask & TITYPE_INTERVAL)
--mod->fbd_NumInterval;
TFree(win);
}
void TDataFree(TData *context)
{
if (context) {
if (context->type != T_DATA_CONST_UNKNOWN &&
context->type != T_DATA_CONST_STRING)
TFree((TPtr) context->data);
TFree(context);
}
}
static void tek_lib_exec_freeargs(struct TExecBase *TExecBase,
struct LuaTaskArgs *args, int numargs)
{
if (numargs > 0 && args)
{
int i;
for (i = 0; i < numargs; ++i)
TFree(args[i].arg);
TFree(args);
}
}
TLIBAPI void region_destroypool(struct RectPool *pool)
{
TAPTR TExecBase = pool->p_ExecBase;
struct TNode *next, *node = pool->p_Rects.rl_List.tlh_Head;
for (; (next = node->tln_Succ); node = next)
TFree(node);
}
static int tek_lib_exec_sendmsg(lua_State *L)
{
struct LuaExecTask *lexec = tek_lib_exec_check(L);
struct TExecBase *TExecBase = lexec->exec;
const char *taskname = luaL_checkstring(L, 1);
size_t msglen;
const char *src = luaL_checklstring(L, 2, &msglen);
TAPTR ref, task;
char *msg = TAllocMsg(msglen + TEK_LIB_TASKNAME_LEN);
if (msg == TNULL)
luaL_error(L, "out of memory");
task = tek_lib_exec_locktask(TExecBase, taskname, &ref);
if (task)
{
memcpy(msg, src, msglen);
strcpy(msg + msglen, lexec->taskname);
TPutMsg(TGetUserPort(task), TNULL, msg);
tek_lib_exec_unlocktask(TExecBase, ref);
lua_pushboolean(L, TTRUE);
}
else
{
TFree(msg);
lua_pushnil(L);
}
return 1;
}
static inline void TArgParserStoreParam(char type, char def, size_t amount)
{
TFree(TArgParser.ph.param);
TArgParser.ph.param = 0;
TArgParser.ph.paramtype = type;
TArgParser.ph.paramdef = def;
TArgParser.ph.remainingParams = amount;
}
TLIBAPI void TFreeInstance(struct TModule *mod)
{
if (mod)
{
struct TExecBase *TExecBase = TGetExecBase(mod);
TFree((TINT8 *) mod - ((struct TModule *) mod)->tmd_NegSize);
}
}
const void *TArgParserNextParameter(void)
{
const void *data;
const char *arg;
char type = TArgParser.ph.paramtype;
if(!TArgParser.ph.remainingParams) return 0;
TFree(TArgParser.ph.param);
arg = TArgParser.argv[TArgParser.idx];
if(type == 'd' || type == 'i') {
int *p;
TArgParser.ph.param = TAlloc(sizeof(int));
p = (int *) TArgParser.ph.param;
sscanf(arg,"%d",p);
data = TArgParser.ph.param;
} else if(type == 'u') {
unsigned int *p;
TArgParser.ph.param = TAlloc(sizeof(unsigned int));
p = (unsigned int *) TArgParser.ph.param;
sscanf(arg,"%u",p);
data = TArgParser.ph.param;
} else if(type == 'x' || type == 'X') {
unsigned int *p;
TArgParser.ph.param = TAlloc(sizeof(unsigned int));
p = (unsigned int *) TArgParser.ph.param;
sscanf(arg, type == 'x' ? "%x" : "%X",p);
data = TArgParser.ph.param;
} else if(type == 'f' || type == 'F') {
double *p;
TArgParser.ph.param = TAlloc(sizeof(double));
p = (double *) TArgParser.ph.param;
sscanf(arg, "%lf",p);
data = TArgParser.ph.param;
} else if(type == 'c') {
char *p;
TArgParser.ph.param = TAlloc(sizeof(char));
p = (char *) TArgParser.ph.param;
sscanf(arg, "%c",p);
data = TArgParser.ph.param;
} else {
data = arg;
TArgParser.ph.param = 0;
}
TArgParser.ph.remainingParams--;
TArgParser.idx++;
return data;
}
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;
}
TLIBAPI void region_freerects(struct RectPool *p, struct RectList *list)
{
struct TNode *temp;
struct TExecBase *TExecBase = p->p_ExecBase;
region_relinkrects(&p->p_Rects, list);
while (p->p_Rects.rl_NumNodes > MAXPOOLNODES)
{
TFree(TREMTAIL(&p->p_Rects.rl_List, temp));
p->p_Rects.rl_NumNodes--;
}
}
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 void
vis_modclose(struct TVisualBase *inst)
{
struct TVisualBase *mod =
(struct TVisualBase *) inst->vis_Module.tmd_ModSuper;
struct TExecBase *TExecBase = TGetExecBase(mod);
if (inst != mod)
{
struct TNode *node;
TAPTR imsg;
if (inst->vis_Flags & TVISFL_IMSGPORT_OWNER)
{
TINT n = 0;
while ((imsg = TGetMsg(inst->vis_IMsgPort)))
{
TAckMsg(imsg);
n++;
}
if (n > 0)
TDBPRINTF(TDB_WARN,("freed &d pending input message\n", n));
}
while ((node = TRemHead(&inst->vis_ReqPool)))
TFree(node);
while ((node = TRemHead(&inst->vis_WaitList)))
{
TWaitIO((struct TIORequest *) node);
TFree(node);
}
vis_destroyports(inst);
TFreeInstance(&inst->vis_Module);
}
TLock(mod->vis_Lock);
if (--mod->vis_RefCount == 0)
vis_exit(mod);
TUnlock(mod->vis_Lock);
}
static void
fb_exitinstance(WINDISPLAY *mod)
{
struct TExecBase *TExecBase = TGetExecBase(mod);
struct TNode *imsg, *node, *next;
/* free pooled input messages: */
while ((imsg = TRemHead(&mod->fbd_IMsgPool)))
TFree(imsg);
/* free queued input messages in all open visuals: */
node = mod->fbd_VisualList.tlh_Head;
for (; (next = node->tln_Succ); node = next)
{
WINWINDOW *v = (WINWINDOW *) node;
/* unset active font in all open visuals */
v->fbv_CurrentFont = TNULL;
while ((imsg = TRemHead(&v->fbv_IMsgQueue)))
TFree(imsg);
}
/* force closing of default font */
mod->fbd_FontManager.defref = 0;
/* close all fonts */
node = mod->fbd_FontManager.openfonts.tlh_Head;
for (; (next = node->tln_Succ); node = next)
fb_hostclosefont(mod, (TAPTR) node);
if (mod->fbd_DeviceHWnd)
DestroyWindow(mod->fbd_DeviceHWnd);
if (mod->fbd_ClassAtom)
UnregisterClass(FB_DISPLAY_CLASSNAME, mod->fbd_HInst);
if (mod->fbd_ClassAtomPopup)
UnregisterClass(FB_DISPLAY_CLASSNAME_POPUP, mod->fbd_HInst);
}
LOCAL void
fb_freepen(WINDISPLAY *mod, struct TVRequest *req)
{
struct TExecBase *TExecBase = TGetExecBase(mod);
if (req->tvr_Op.FreePen.Pen != TVPEN_UNDEFINED)
{
struct FBPen *pen = (struct FBPen *) req->tvr_Op.FreePen.Pen;
TRemove(&pen->node);
DeleteObject(pen->pen);
DeleteObject(pen->brush);
TFree(pen);
}
}
TLIBAPI struct Region *region_new(struct RectPool *pool, TINT *s)
{
struct TExecBase *TExecBase = pool->p_ExecBase;
struct Region *region = TAlloc(TNULL, sizeof(struct Region));
if (region)
{
if (!region_init(pool, region, s))
{
TFree(region);
region = TNULL;
}
}
return region;
}
static void
fb_closeall(WINDISPLAY *mod, WINWINDOW *win, TBOOL unref_font)
{
struct TExecBase *TExecBase = TGetExecBase(mod);
struct FBPen *pen;
if (win->fbv_HDC)
ReleaseDC(win->fbv_HWnd, win->fbv_HDC);
if (win->fbv_HWnd)
DestroyWindow(win->fbv_HWnd);
while ((pen = (struct FBPen *) TRemHead(&win->penlist)))
TFree(pen);
if (unref_font)
{
TLock(mod->fbd_Lock);
mod->fbd_FontManager.defref--;
TUnlock(mod->fbd_Lock);
}
TFree(win);
}
const char *TArgParserNext(void)
{
const char *next = 0;
// maybe we have reached the end already
if(!TArgParser.argv || (TArgParser.idx >= TArgParser.argc)) {
if(TArgParser.ph.param) {
TFree(TArgParser.ph.param);
TArgParser.ph.param = 0;
}
return next;
}
if(TArgParser.ph.remainingParams) {
TArgParser.idx += TArgParser.ph.remainingParams;
TArgParserStoreParam(0,0,0);
}
while((!next) && (TArgParser.idx < TArgParser.argc)) {
TArg *pat;
next = TArgParser.argv[TArgParser.idx];
if(!next) {
TErrorReport(2);
return 0;
}
if(TArgParserIsSwitch(next)) {
//argument is a switch
//find matching pattern
pat = TArgParserMatchSwitch(next);
TArgParser.idx++;
} else {
pat = TArgParserMatchNonSwitch();
}
if(TArgParserCheck(pat,next)) return 0;
{
// keep parameters ready
size_t limit = TArgParserAmountLimit(pat->amount);
size_t amount = TArgParserNumData(TArgParser.idx, limit);
if(amount) TArgParserStoreParam(pat->type,pat->def,amount);
}
}
return next;
}
LOCAL void tek_lib_visual_io_close(TEKVisual *vis)
{
if (vis->vis_IOTask)
{
struct TExecBase *TExecBase = vis->vis_ExecBase;
TSignal(vis->vis_IOTask, TTASK_SIG_ABORT);
#if defined(ENABLE_FILENO) || defined(ENABLE_DGRAM)
struct IOData *iodata = vis->vis_IOData;
tek_lib_visual_io_wake(iodata);
#endif
TDestroy((struct THandle *) vis->vis_IOTask);
vis->vis_IOTask = TNULL;
TFree(vis->vis_IOData);
vis->vis_IOData = TNULL;
}
}
TLIBAPI struct Region *region_new(struct RectPool *pool, TINT *s)
{
struct TExecBase *TExecBase = pool->p_ExecBase;
struct Region *region = TAlloc(TNULL, sizeof(struct Region));
if (region)
{
region->rg_Pool = pool;
region_initrectlist(®ion->rg_Rects);
if (s && !region_insertrect(pool, ®ion->rg_Rects,
s[0], s[1], s[2], s[3]))
{
TFree(region);
region = TNULL;
}
}
return region;
}
int Free(void * pointer)
{
struct alloc_head * mem_head=(struct alloc_head *)(pointer-sizeof(POINTER_LIST));
switch(mem_head->type)
{
case ALLOC_TEMP:
return TFree(pointer);
case ALLOC_STATIC:
return SFree(pointer);
case ALLOC_DYNAMIC:
return DFree(pointer);
case ALLOC_CACHE:
return CFree(pointer,mem_head->flag);
default:
return -EINVAL;
}
}
static THOOKENTRY TTAG
fqhdestroy(struct THook *hook, TAPTR obj, TTAG msg)
{
if (msg == TMSG_DESTROY)
{
struct FontQueryHandle *fqh = obj;
WINDISPLAY *mod = fqh->handle.thn_Owner;
TAPTR TExecBase = TGetExecBase(mod);
struct TNode *node, *next;
node = fqh->reslist.tlh_Head;
for (; (next = node->tln_Succ); node = next)
{
struct FontQueryNode *fqn = (struct FontQueryNode *)node;
TRemove(&fqn->node);
TFree(fqn);
}
}
return 0;
}
static int tek_lib_exec_base_gc(lua_State *L)
{
struct LuaExecTask *lexec = (struct LuaExecTask *)luaL_checkudata(L, 1, TEK_LIB_EXEC_CLASSNAME);
struct TExecBase *TExecBase = lexec->exec;
if (TExecBase)
{
#if defined(ENABLE_TASKS)
TAPTR atom = TLockAtom(TEK_LIB_BASETASK_ATOMNAME, TATOMF_NAME);
TUnlockAtom(atom, TATOMF_DESTROY);
if (lexec->parent == TNULL)
{
/* free shared state */
TFree(lexec->shared);
}
#endif
TDestroy((struct THandle *) lexec->task);
lexec->exec = TNULL;
}
return 0;
}
LOCAL TBOOL rfb_resizewinbuffer(struct rfb_Display *mod, struct rfb_Window *v,
TINT oldw, TINT oldh, TINT w, TINT h)
{
if (oldw == w && oldh == h)
return TTRUE;
TAPTR TExecBase = TGetExecBase(mod);
struct TVPixBuf newbuf = v->rfbw_PixBuf;
TUINT pixfmt = v->rfbw_PixBuf.tpb_Format;
newbuf.tpb_BytesPerLine = TVPIXFMT_BYTES_PER_PIXEL(pixfmt) * w;
newbuf.tpb_Data = TAlloc(mod->rfb_MemMgr, newbuf.tpb_BytesPerLine * h);
if (!newbuf.tpb_Data)
return TFALSE;
TINT cw = TMIN(oldw, w);
TINT ch = TMIN(oldh, h);
pixconv_convert(&v->rfbw_PixBuf, &newbuf,
0, 0, cw - 1, ch - 1, 0, 0, TFALSE, TFALSE);
TFree(v->rfbw_PixBuf.tpb_Data);
v->rfbw_PixBuf = newbuf;
return TTRUE;
}
LOCAL TBOOL tek_lib_visual_io_open(TEKVisual *vis)
{
struct TExecBase *TExecBase = vis->vis_ExecBase;
struct IOData *iodata = TAlloc(TNULL, sizeof(struct IOData));
if (iodata)
{
TTAGITEM tags[2];
sprintf(iodata->atomname, "msgport.ui.%p", TFindTask(TNULL));
iodata->vis = vis;
vis->vis_IOData = iodata;
tags[0].tti_Tag = TTask_UserData;
tags[0].tti_Value = (TTAG) iodata;
tags[1].tti_Tag = TTAG_DONE;
struct THook taskhook;
TInitHook(&taskhook, tek_lib_visual_io_dispatch, TNULL);
vis->vis_IOTask = TCreateTask(&taskhook, tags);
if (vis->vis_IOTask)
return TTRUE;
TFree(iodata);
vis->vis_IOData = TNULL;
}
return TFALSE;
}
static TMODAPI void
fb_freereq(WINDISPLAY *mod, struct TVRequest *req)
{
struct TExecBase *TExecBase = TGetExecBase(mod);
TFree(req);
}
void TArgParserDestroy(void)
{
TArrayFree(TArgParser.argFormat,TFree);
TFree(TArgParser.ph.param);
}
void __cdecl operator delete[](void *p)
{
TFree(p);
}
