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);
}
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;
}
static void tek_lib_visual_io_exit(struct TTask *task)
{
struct TExecBase *TExecBase = TGetExecBase(task);
struct IOData *iodata = TGetTaskData(task);
#if defined(ENABLE_FILENO) || defined(ENABLE_DGRAM)
int i;
for (i = 0; i < 2; ++i)
if (iodata->fd_pipe[i] != -1)
close(iodata->fd_pipe[i]);
#if defined(ENABLE_DGRAM)
if (iodata->fd_dgram != -1)
close(iodata->fd_dgram);
#endif
#if defined(ENABLE_FILENO)
visual_io_reader_exit(&iodata->linereader);
#endif
#endif
TLockAtom(iodata->atomname, TATOMF_NAME | TATOMF_DESTROY);
}
static TBOOL tek_lib_exec_init_link_to_parent(lua_State *L,
struct LuaExecTask *lexec)
{
struct TExecBase *TExecBase = lexec->exec;
TAPTR atom;
/* task's userdata initially contains a pointer to
** childtask-userdata in parent Lua state */
struct LuaExecChild *ctx = TGetTaskData(TNULL);
/* now relink to own task */
TSetTaskData(TNULL, lexec);
lexec->parent = ctx ? ctx->parent : TNULL;
if (ctx && ctx->taskname)
{
/* child context */
strcpy(lexec->atomname, ctx->atomname);
lexec->taskname = lexec->atomname + TEK_LIB_TASK_ATOMNAME_OFFSET;
lexec->shared = ctx->parent->shared;
}
else
{
/* root context */
lexec->taskname = tek_lib_exec_taskname(lexec->atomname, "main");
lexec->shared = TAlloc(TNULL, sizeof(struct SharedState));
if (lexec->shared == TNULL)
return TFALSE;
}
atom = TLockAtom(TEK_LIB_BASETASK_ATOMNAME,
TATOMF_CREATE | TATOMF_NAME | TATOMF_TRY);
if (atom)
{
TSetAtomData(atom, (TTAG) lexec->task);
TUnlockAtom(atom, TATOMF_KEEP);
}
return TTRUE;
}
static void fb_runinstance(TAPTR task)
{
struct TExecBase *TExecBase = TGetExecBase(task);
WINDISPLAY *mod = TGetTaskData(task);
struct TVRequest *req;
TUINT sig;
/* interval time: 1/50s: */
TTIME intt = { 20000 };
/* next absolute time to send interval message: */
TTIME nextt;
TTIME waitt, nowt;
TGetSystemTime(&nextt);
TAddTime(&nextt, &intt);
TDBPRINTF(TDB_INFO,("Device instance running\n"));
do
{
TBOOL do_interval = TFALSE;
while ((req = TGetMsg(mod->fbd_CmdPort)))
{
fb_docmd(mod, req);
TReplyMsg(req);
}
fb_notifywindows(mod);
/* calculate new delta to wait: */
TGetSystemTime(&nowt);
waitt = nextt;
TSubTime(&waitt, &nowt);
TWaitTime(&waitt, mod->fbd_CmdPortSignal);
/* check if time interval has expired: */
TGetSystemTime(&nowt);
if (TCmpTime(&nowt, &nextt) > 0)
{
/* expired; send interval: */
do_interval = TTRUE;
TAddTime(&nextt, &intt);
if (TCmpTime(&nowt, &nextt) >= 0)
{
/* nexttime expired already; create new time from now: */
nextt = nowt;
TAddTime(&nextt, &intt);
}
}
/* send out input messages: */
fb_sendimessages(mod, do_interval);
/* get signal state: */
sig = TSetSignal(0, TTASK_SIG_ABORT);
} while (!(sig & TTASK_SIG_ABORT));
TDBPRINTF(TDB_INFO,("Device instance closedown\n"));
fb_exitinstance(mod);
}
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;
}
static TBOOL fb_initwindow(TAPTR task)
{
struct TExecBase *TExecBase = TGetExecBase(task);
struct TVRequest *req = TGetTaskData(task);
TTAGITEM *tags = req->tvr_Op.OpenWindow.Tags;
WINDISPLAY *mod = (WINDISPLAY *) req->tvr_Req.io_Device;
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);
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, wrect.bottom - wrect.top,
(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;
SetWindowLong(win->fbv_HWnd, GWL_USERDATA, (LONG) 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;
win->fbv_Task = task;
TLock(mod->fbd_Lock);
/* init default font */
win->fbv_CurrentFont = mod->fbd_FontManager.deffont;
mod->fbd_FontManager.defref++;
/* 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);
TUnlock(mod->fbd_Lock);
SetBkMode(win->fbv_HDC, TRANSPARENT);
ShowWindow(win->fbv_HWnd, SW_SHOWNORMAL);
UpdateWindow(win->fbv_HWnd);
TSetTaskData(task, win);
if ((win->fbv_InputMask & TITYPE_FOCUS) &&
(fb_getimsg(mod, win, &imsg, TITYPE_FOCUS)))
{
imsg->timsg_Code = 1;
fb_sendimsg(mod, win, imsg);
}
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;
fb_sendimsg(mod, win, imsg);
}
return TTRUE;
}
TDBPRINTF(TDB_ERROR,("Window open failed\n"));
fb_closeall(mod, win, TFALSE);
return TFALSE;
}
static void rfb_runtask(struct TTask *task)
{
TAPTR TExecBase = TGetExecBase(task);
RFBDISPLAY *mod = TGetTaskData(task);
struct TVRequest *req;
TUINT sig;
TTIME intt = { RAWFB_INTERVAL_MICROS };
/* next absolute time to send interval message: */
TTIME nextt;
TTIME waitt, nowt;
TAPTR cmdport = TGetUserPort(task);
TUINT cmdportsignal = TGetPortSignal(cmdport);
TUINT imsgportsignal = TGetPortSignal(mod->rfb_RndIMsgPort);
TDBPRINTF(TDB_INFO,("RawFB device context running\n"));
TGetSystemTime(&nowt);
nextt = nowt;
TAddTime(&nextt, &intt);
do
{
/* process input messages: */
rfb_processevent(mod);
/* do draw commands: */
while ((req = TGetMsg(cmdport)))
{
rfb_docmd(mod, req);
TReplyMsg(req);
}
/* check if time interval has expired: */
TGetSystemTime(&nowt);
if (TCmpTime(&nowt, &nextt) > 0)
{
/* expired; send intervals: */
TLock(mod->rfb_InstanceLock);
struct TNode *next, *node = mod->rfb_VisualList.tlh_Head;
for (; (next = node->tln_Succ); node = next)
{
RFBWINDOW *v = (RFBWINDOW *) node;
TIMSG *imsg;
if ((v->rfbw_InputMask & TITYPE_INTERVAL) &&
rfb_getimsg(mod, v, &imsg, TITYPE_INTERVAL))
TPutMsg(v->rfbw_IMsgPort, TNULL, imsg);
}
TUnlock(mod->rfb_InstanceLock);
TAddTime(&nextt, &intt);
}
/* calculate new wait time: */
waitt = nextt;
TGetSystemTime(&nowt);
TSubTime(&waitt, &nowt);
if (waitt.tdt_Int64 <= 0 || waitt.tdt_Int64 > RAWFB_INTERVAL_MICROS)
{
/* something's wrong with the clock, recalculate */
TDBPRINTF(TDB_INFO,("clock problem: %lld\n", waitt.tdt_Int64));
nextt = nowt;
TAddTime(&nextt, &intt);
waitt = nextt;
TSubTime(&waitt, &nowt);
}
sig = TWaitTime(&waitt,
cmdportsignal | imsgportsignal | TTASK_SIG_ABORT);
} while (!(sig & TTASK_SIG_ABORT));
TDBPRINTF(TDB_INFO,("RawFB device context closedown\n"));
rfb_exittask(mod);
}
static void rfb_runtask(struct TTask *task)
{
TAPTR TExecBase = TGetExecBase(task);
struct rfb_Display *mod = TGetTaskData(task);
struct TVRequest *req;
TUINT sig = 0;
TTIME intt = { 20000 };
/* next absolute time to send interval message: */
TTIME nextt;
TTIME waitt, nowt, *pwaitt;
TAPTR cmdport = TGetUserPort(task);
TUINT cmdportsignal = TGetPortSignal(cmdport);
TUINT imsgportsignal = TGetPortSignal(mod->rfb_RndIMsgPort);
TUINT waitsigs = cmdportsignal | imsgportsignal | TTASK_SIG_ABORT;
TDBPRINTF(TDB_INFO, ("RawFB device context running\n"));
TGetSystemTime(&nowt);
nextt = nowt;
TAddTime(&nextt, &intt);
do
{
if (sig & cmdportsignal)
{
TBOOL checkrect = mod->rfb_Flags & RFBFL_PTR_VISIBLE;
TINT arec[4];
while ((req = TGetMsg(cmdport)))
{
if (checkrect)
{
TINT res = rfb_cmdrectaffected(mod, req, arec, TTRUE);
if (res < 0 || (res > 0 &&
REGION_OVERLAPRECT(mod->rfb_PtrBackBuffer.rect,
arec)))
{
rfb_restoreptrbg(mod);
checkrect = TFALSE;
}
}
rfb_docmd(mod, req);
TReplyMsg(req);
}
}
if (mod->rfb_Flags & RFBFL_SHOWPTR)
rfb_drawpointer(mod);
/* check if time interval has expired: */
TGetSystemTime(&nowt);
/* do interval timers */
if (mod->rfb_NumInterval > 0)
{
if (TCmpTime(&nowt, &nextt) >= 0)
{
/* expired; send intervals: */
TLock(mod->rfb_InstanceLock);
struct TNode *next,
*node = mod->rfb_VisualList.tlh_Head.tln_Succ;
for (; (next = node->tln_Succ); node = next)
{
struct rfb_Window *v = (struct rfb_Window *) node;
TIMSG *imsg;
if ((v->rfbw_InputMask & TITYPE_INTERVAL) &&
rfb_getimsg(mod, v, &imsg, TITYPE_INTERVAL))
TPutMsg(v->rfbw_IMsgPort, TNULL, imsg);
}
TUnlock(mod->rfb_InstanceLock);
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);
}
pwaitt = &waitt;
}
else
pwaitt = TNULL;
#if defined(ENABLE_LINUXFB)
rfb_linux_wait(mod, pwaitt);
sig = TSetSignal(0, waitsigs);
#else
sig = TWaitTime(pwaitt, waitsigs);
#endif
if (sig & imsgportsignal)
rfb_processevent(mod);
} while (!(sig & TTASK_SIG_ABORT));
TDBPRINTF(TDB_INFO, ("RawFB device context closedown\n"));
rfb_exittask(mod);
}
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 void tek_lib_visual_io_task(struct TTask *task)
{
struct TExecBase *TExecBase = TGetExecBase(task);
struct IOData *iodata = TGetTaskData(task);
TEKVisual *vis = iodata->vis;
TIMSG *imsg;
TUINT sig;
#if defined(ENABLE_FILENO) || defined(ENABLE_DGRAM)
char buf[256];
fd_set rset;
#endif
do
{
#if defined(ENABLE_FILENO) || defined(ENABLE_DGRAM)
FD_ZERO(&rset);
FD_SET(iodata->fd_pipe[0], &rset);
#endif
#if defined(ENABLE_FILENO)
if (iodata->fd_stdin != -1)
FD_SET(iodata->fd_stdin, &rset);
#endif
#if defined(ENABLE_DGRAM)
FD_SET(iodata->fd_dgram, &rset);
#endif
#if defined(ENABLE_FILENO) || defined(ENABLE_DGRAM)
if (select(iodata->fdmax, &rset, NULL, NULL, NULL) > 0)
{
int nbytes = 0;
/* consume signal: */
if (FD_ISSET(iodata->fd_pipe[0], &rset))
{
ioctl(iodata->fd_pipe[0], FIONREAD, &nbytes);
if (nbytes > 0)
if (read(iodata->fd_pipe[0], buf,
TMIN(sizeof(buf), (size_t) nbytes)) != nbytes)
TDBPRINTF(TDB_ERROR,("Error reading from selfpipe\n"));
}
#if defined(ENABLE_FILENO)
/* stdin line reader: */
if (iodata->fd_stdin >= 0 && FD_ISSET(iodata->fd_stdin, &rset))
{
if (ioctl(iodata->fd_stdin, FIONREAD, &nbytes) == 0)
{
if (nbytes == 0)
iodata->fd_stdin = -1; /* stop processing */
else
{
char *line;
size_t len;
visual_io_reader_addbytes(&iodata->linereader, nbytes);
while (visual_io_readline(&iodata->linereader, &line,
&len))
{
if (getusermsg(vis, &imsg, TITYPE_USER, len))
{
memcpy((void *) (imsg + 1), line, len);
TPutMsg(vis->vis_IMsgPort, TNULL,
&imsg->timsg_Node);
}
}
}
}
else
iodata->fd_stdin = -1; /* stop processing */
}
#endif
#if defined(ENABLE_DGRAM)
if (iodata->fd_dgram >= 0 && FD_ISSET(iodata->fd_dgram, &rset))
{
char umsg[IOMAXMSGSIZE];
TIMSG *imsg;
ssize_t len = recv(iodata->fd_dgram, umsg, sizeof umsg, 0);
if (len >= 0 && getusermsg(vis, &imsg, TITYPE_USER, len))
{
memcpy((void *) (imsg + 1), umsg, len);
TPutMsg(vis->vis_IMsgPort, TNULL, &imsg->timsg_Node);
}
}
#endif
}
sig = TSetSignal(0, TTASK_SIG_ABORT | TTASK_SIG_USER);
#else
sig = TWait(TTASK_SIG_ABORT | TTASK_SIG_USER);
#endif
if (sig & TTASK_SIG_USER)
{
TAPTR msg, uport = TGetUserPort(TNULL);
while ((msg = TGetMsg(uport)))
{
TSIZE len = TGetSize(msg);
/* repackage into user input message */
if (getusermsg(vis, &imsg, TITYPE_USER, len))
{
memcpy((void *) (imsg + 1), msg, len);
TPutMsg(vis->vis_IMsgPort, TNULL, &imsg->timsg_Node);
}
TAckMsg(msg);
}
}
} while (!(sig & TTASK_SIG_ABORT));
tek_lib_visual_io_exit(task);
}
static TBOOL tek_lib_visual_io_init(struct TTask *task)
{
struct TExecBase *TExecBase = TGetExecBase(task);
struct IOData *iodata = TGetTaskData(task);
#if defined(ENABLE_FILENO) || defined(ENABLE_DGRAM)
TEKVisual *vis = iodata->vis;
iodata->fd_pipe[0] = -1;
iodata->fd_pipe[1] = -1;
iodata->fdmax = 0;
TInitHook(&iodata->mphook, tek_lib_visual_io_mphookfunc, iodata);
TSetPortHook(TGetUserPort(TNULL), &iodata->mphook);
#endif
#if defined(ENABLE_FILENO)
int fd = vis->vis_IOFileNo;
iodata->fd_stdin = fd == -1 ? STDIN_FILENO : fd;
visual_io_reader_init(&iodata->linereader, iodata->fd_stdin, IOMAXMSGSIZE);
iodata->fdmax = TMAX(iodata->fdmax, iodata->fd_stdin);
#endif
#if defined(ENABLE_DGRAM)
iodata->fd_dgram = socket(PF_INET, SOCK_DGRAM, 0);
if (iodata->fd_dgram != -1)
{
int reuse = 1;
setsockopt(iodata->fd_dgram, SOL_SOCKET, SO_REUSEADDR,
(char *) &reuse, sizeof(reuse));
struct sockaddr_in addr;
memset(&addr, 0, sizeof(struct sockaddr_in));
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = inet_addr(ENABLE_DGRAM_ADDR);
addr.sin_port = htons(ENABLE_DGRAM);
if (bind(iodata->fd_dgram,
(struct sockaddr *) &addr, sizeof addr) == -1)
{
close(iodata->fd_dgram);
iodata->fd_dgram = -1;
}
}
if (iodata->fd_dgram == -1)
{
tek_lib_visual_io_exit(task);
return TFALSE;
}
iodata->fdmax = TMAX(iodata->fdmax, iodata->fd_dgram);
#endif
#if defined(ENABLE_FILENO) || defined(ENABLE_DGRAM)
if (pipe(iodata->fd_pipe) != 0)
return TFALSE;
iodata->fdmax = TMAX(iodata->fdmax, iodata->fd_pipe[0]) + 1;
#endif
TAPTR atom = TLockAtom(iodata->atomname, TATOMF_CREATE | TATOMF_NAME);
if (atom)
{
TSetAtomData(atom, (TTAG) TGetUserPort(TNULL));
TUnlockAtom(atom, TATOMF_KEEP);
}
return TTRUE;
}
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);
}
static struct LuaExecTask *getparent(struct TExecBase *TExecBase)
{
struct LuaExecTask *self = TGetTaskData(TNULL);
return self ? self->parent : TNULL;
}
