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 TBOOL
exec_initport(TEXECBASE *exec, struct TMsgPort *port, struct TTask *task,
TUINT signal)
{
if (!signal)
{
signal = exec_allocsignal(exec, task, 0);
if (!signal)
return TFALSE;
}
if (THALInitLock(exec->texb_HALBase, &port->tmp_Lock))
{
port->tmp_Handle.thn_Hook.thk_Entry = exec_destroyport_internal;
port->tmp_Handle.thn_Owner = (struct TModule *) exec;
port->tmp_Handle.thn_Name = TNULL;
TInitList(&port->tmp_MsgList);
port->tmp_Hook = TNULL;
port->tmp_Signal = signal;
port->tmp_SigTask = task;
return TTRUE;
}
return TFALSE;
}
static void
vis_exit(struct TVisualBase *mod)
{
struct TExecBase *TExecBase = TGetExecBase(mod);
if (mod->vis_Displays)
{
struct TList dlist;
struct TNode *next, *node;
if (mod->vis_InitRequest)
TDisplayFreeReq((struct TDisplayBase *)
mod->vis_InitRequest->tvr_Req.io_Device,
mod->vis_InitRequest);
TInitList(&dlist);
vis_hashtolist(mod, mod->vis_Displays, &dlist);
for (node = dlist.tlh_Head; (next = node->tln_Succ); node = next)
{
#if defined(VISUAL_USE_INTERNAL_HASH)
struct TModule *dmod = (struct TModule *)
((struct vis_HashNode *) node)->value;
#else
struct TModule *dmod = (struct TModule *)
((struct THashNode *) node)->thn_Value;
#endif
TCloseModule(dmod);
}
vis_destroyhash(mod, mod->vis_Displays);
}
}
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;
}
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
exec_initlock(TEXECBASE *exec, struct TLock *lock)
{
if (THALInitLock(exec->texb_HALBase, &lock->tlk_HLock))
{
lock->tlk_Handle.thn_Name = TNULL;
lock->tlk_Handle.thn_Hook.thk_Entry = destroylock;
lock->tlk_Handle.thn_Owner = (struct TModule *) exec;
TInitList(&lock->tlk_Waiters);
lock->tlk_Owner = TNULL;
lock->tlk_NestCount = 0;
lock->tlk_WaitCount = 0;
return TTRUE;
}
return TFALSE;
}
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;
}
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;
}
static TBOOL fb_initinstance(TAPTR task)
{
struct TExecBase *TExecBase = TGetExecBase(task);
WINDISPLAY *mod = TGetTaskData(task);
for (;;)
{
// TTAGITEM *opentags = mod->fbd_OpenTags;
TTAGITEM ftags[3];
WNDCLASSEX wclass, pclass;
mod->fbd_HInst = GetModuleHandle(NULL);
if (mod->fbd_HInst == TNULL)
break;
wclass.cbSize = sizeof(wclass);
wclass.style = 0;
wclass.lpfnWndProc = win_wndproc;
wclass.cbClsExtra = 0;
wclass.cbWndExtra = 0;
wclass.hInstance = mod->fbd_HInst;
wclass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
wclass.hCursor = LoadCursor(NULL, IDC_ARROW);
wclass.hbrBackground = NULL;
wclass.lpszMenuName = NULL;
wclass.lpszClassName = FB_DISPLAY_CLASSNAME;
wclass.hIconSm = NULL;
mod->fbd_ClassAtom = RegisterClassEx(&wclass);
if (mod->fbd_ClassAtom == 0)
break;
pclass.cbSize = sizeof(pclass);
pclass.style = CS_NOCLOSE;
pclass.lpfnWndProc = win_wndproc;
pclass.cbClsExtra = 0;
pclass.cbWndExtra = 0;
pclass.hInstance = mod->fbd_HInst;
pclass.hIcon = NULL;
pclass.hCursor = LoadCursor(NULL, IDC_ARROW);
pclass.hbrBackground = NULL;
pclass.lpszMenuName = NULL;
pclass.lpszClassName = FB_DISPLAY_CLASSNAME_POPUP;
pclass.hIconSm = NULL;
mod->fbd_ClassAtomPopup = RegisterClassEx(&pclass);
if (mod->fbd_ClassAtomPopup == 0)
break;
/* Create invisible window for this device: */
mod->fbd_DeviceHWnd = CreateWindowEx(0, FB_DISPLAY_CLASSNAME, NULL,
0, 0, 0, 0, 0, (HWND) NULL, (HMENU) NULL, mod->fbd_HInst,
(LPVOID) NULL);
if (mod->fbd_DeviceHWnd == NULL)
break;
mod->fbd_DeviceHDC = GetDC(mod->fbd_DeviceHWnd);
/* list of free input messages: */
TInitList(&mod->fbd_IMsgPool);
/* list of all open visuals: */
TInitList(&mod->fbd_VisualList);
/* init fontmanager and default font */
TInitList(&mod->fbd_FontManager.openfonts);
ftags[0].tti_Tag = TVisual_FontName;
ftags[0].tti_Value = (TTAG) FNT_DEFNAME;
ftags[1].tti_Tag = TVisual_FontPxSize;
ftags[1].tti_Value = (TTAG) FNT_DEFPXSIZE;
ftags[2].tti_Tag = TTAG_DONE;
mod->fbd_FontManager.deffont = fb_hostopenfont(mod, ftags);
if (mod->fbd_FontManager.deffont == TNULL) break;
TDBPRINTF(TDB_TRACE,("Instance init successful\n"));
return TTRUE;
}
fb_exitinstance(mod);
return TFALSE;
}
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;
}
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;
}
LOCAL TBOOL fbp_copyarea_int(struct rfb_Display *mod, struct rfb_Window *v,
TINT dx, TINT dy, TINT *dr)
{
struct RectPool *pool = &mod->rfb_RectPool;
struct Region R;
if (!rfb_getlayermask(mod, &R, dr, v, 0, 0))
return TFALSE;
if (R.rg_Rects.rl_NumNodes == 0)
{
region_free(pool, &R);
return TFALSE;
}
TINT yinc = dy < 0 ? -1 : 1;
TINT y, i, h;
TINT dy0 = dr[1];
TINT dy1 = dr[3];
h = dy1 - dy0 + 1;
if (yinc > 0)
{
TINT t = dy0;
dy0 = dy1;
dy1 = t;
}
TINT bpp = TVPIXFMT_BYTES_PER_PIXEL(v->rfbw_PixBuf.tpb_Format);
if (R.rg_Rects.rl_NumNodes == 1)
{
/* optimization for a single rectangle */
struct RectNode *rn =
(struct RectNode *) TFIRSTNODE(&R.rg_Rects.rl_List);
TINT x0 = rn->rn_Rect[0];
TINT y0 = rn->rn_Rect[1];
TINT x1 = rn->rn_Rect[2];
TINT y1 = rn->rn_Rect[3];
h = y1 - y0 + 1;
dy0 = y0;
dy1 = y1;
if (yinc > 0)
{
TINT t = dy0;
dy0 = dy1;
dy1 = t;
}
#if defined(ENABLE_VNCSERVER)
if (mod->rfb_VNCTask && !(v->rfbw_Flags & RFBWFL_BACKBUFFER))
rfb_vnc_copyrect(mod, v, dx, dy, x0, y0, x1, y1, yinc);
else
#endif
{
/* update own buffer */
for (i = 0, y = dy0; i < h; ++i, y -= yinc)
CopyLineOver(v, x0 - dx, y - dy, x0, y, (x1 - x0 + 1) * bpp);
}
/* update sub device */
TINT d[4];
d[0] = rn->rn_Rect[0];
d[1] = rn->rn_Rect[1];
d[2] = rn->rn_Rect[2];
d[3] = rn->rn_Rect[3];
if (v->rfbw_Flags & RFBWFL_BACKBUFFER)
rfb_markdirty(mod, v, d);
else
rfb_copyrect_sub(mod, d, dx, dy);
}
else
{
struct TNode *n;
struct TList r, t;
TInitList(&r);
TInitList(&t);
while ((n = TRemHead(&R.rg_Rects.rl_List)))
TAddTail(&r, n);
for (i = 0, y = dy0; i < h; ++i, y -= yinc)
{
struct TNode *rnext, *rnode = r.tlh_Head.tln_Succ;
for (; (rnext = rnode->tln_Succ); rnode = rnext)
{
struct RectNode *rn = (struct RectNode *) rnode;
if (y >= rn->rn_Rect[1] && y <= rn->rn_Rect[3])
{
struct TNode *prednode = TNULL;
struct TNode *tnext, *tnode = t.tlh_Head.tln_Succ;
for (; (tnext = tnode->tln_Succ); tnode = tnext)
{
struct RectNode *tn = (struct RectNode *) tnode;
if (rn->rn_Rect[2] < tn->rn_Rect[0])
break;
prednode = tnode;
}
TRemove(rnode);
TInsert(&t, rnode, prednode); /* insert after prednode */
}
}
while (!TISLISTEMPTY(&t))
{
TINT x0, x1;
if (dx < 0)
{
struct RectNode *E = (struct RectNode *) TRemHead(&t);
x0 = E->rn_Rect[0];
x1 = E->rn_Rect[2];
TAddTail(&r, &E->rn_Node);
while (!TISLISTEMPTY(&t))
{
struct RectNode *N =
(struct RectNode *) TFIRSTNODE(&t);
if (N->rn_Rect[0] == x1 + 1)
{
x1 = N->rn_Rect[2];
TAddTail(&r, TRemHead(&t));
continue;
}
break;
}
}
else
{
struct RectNode *E = (struct RectNode *) TRemTail(&t);
x0 = E->rn_Rect[0];
x1 = E->rn_Rect[2];
TAddTail(&r, &E->rn_Node);
while (!TISLISTEMPTY(&t))
{
struct RectNode *N = (struct RectNode *) TLASTNODE(&t);
if (N->rn_Rect[2] == x0 - 1)
{
x0 = N->rn_Rect[0];
TAddTail(&r, TRemTail(&t));
continue;
}
break;
}
}
CopyLineOver(v, x0 - dx, y - dy, x0, y, (x1 - x0 + 1) * bpp);
}
}
while ((n = TRemHead(&r)))
{
struct RectNode *rn = (struct RectNode *) n;
/* this would be incorrect, unfortunately: */
/* rfb_copyrect_sub(mod, rn->rn_Rect, dx, dy); */
rfb_markdirty(mod, v, rn->rn_Rect);
TAddTail(&R.rg_Rects.rl_List, n);
}
}
region_free(pool, &R);
return TTRUE; /* do expose */
}
