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;
}
LOCAL TBOOL rfb_initpointer(struct rfb_Display *mod)
{
TAPTR TExecBase = TGetExecBase(mod);
FILE *f;
if ((mod->rfb_Flags & (RFBFL_CANSHOWPTR | RFBFL_SHOWPTR)) !=
(RFBFL_CANSHOWPTR | RFBFL_SHOWPTR))
return TFALSE;
rfb_initdefpointer(mod);
f = fopen(DEF_CURSORFILE, "rb");
if (f)
{
struct ImgLoader ld;
if (imgload_init_file(&ld, TExecBase, f))
{
if (imgload_load(&ld))
{
mod->rfb_PtrImage = ld.iml_Image;
mod->rfb_PtrWidth = ld.iml_Width;
mod->rfb_PtrHeight = ld.iml_Height;
mod->rfb_Flags |= RFBFL_PTR_ALLOCATED;
}
}
fclose(f);
}
mod->rfb_PtrBackBuffer.data = TAlloc(mod->rfb_MemMgr,
TVPIXFMT_BYTES_PER_PIXEL(mod->rfb_PixBuf.tpb_Format) *
mod->rfb_PtrWidth * mod->rfb_PtrHeight);
if (mod->rfb_PtrBackBuffer.data)
return TTRUE;
rfb_initdefpointer(mod);
return TFALSE;
}
TQuadObj *TQuadObjNew(const TRectangle *rect, void *data)
{
TQuadObj *pt = (TQuadObj *) TAlloc(sizeof(TQuadObj));
if(!pt) return 0;
pt->rect = *rect;
pt->data = data;
return pt;
}
static inline TData *TDataNew(TUInt16 type)
{
TData *content = (TData *)TAlloc(sizeof(TData));
if (content) {
content->data = 0;
content->size = 0;
content->type = type;
}
return content;
}
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 tek_lib_exec_allocarg(lua_State *L, struct TExecBase *TExecBase,
int stackidx, struct LuaTaskArgs *arg)
{
const char *s = lua_tolstring(L, stackidx, &arg->len);
if (arg->len > 0)
{
arg->arg = TAlloc(TNULL, arg->len);
if (arg->arg == TNULL)
luaL_error(L, "out of memory");
memcpy(arg->arg, s, arg->len);
}
}
TQuadTree *TQuadTreeNew(const TRectangle *bounds)
{
TQuadTree *qt = (TQuadTree *) TAlloc(sizeof(TQuadTree));
if(!qt) return 0;
qt->level_limit = 5;
qt->obj_limit = 50;
qt->head = TQuadNodeNew(bounds);
return qt;
}
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;
}
void TArgParserAddArgument(const char *name, char type, char amount, char def, const char *help)
{
TArg *arg = (TArg *) TAlloc(sizeof(TArg));
if(arg) {
arg->name = name;
arg->type = type;
arg->amount = amount;
arg->def = def;
arg->help = help;
arg->used = 0;
if(!TArgParser.argFormat) TArgParser.argFormat = TArrayNew(1);
TArrayAppend(TArgParser.argFormat, arg);
}
}
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;
}
TLIBAPI struct TModule *TNewInstance(struct TModule *mod, TSIZE possize,
TSIZE negsize)
{
struct TExecBase *TExecBase = TGetExecBase(mod);
TAPTR inst = TAlloc(TNULL, possize + negsize);
if (inst)
{
TSIZE size = TMIN(((struct TModule *) mod)->tmd_NegSize, negsize);
inst = (TINT8 *) inst + negsize;
if (size > 0)
TCopyMem((TINT8 *) mod - size, (TINT8 *) inst - size, size);
size = TMIN(((struct TModule *) mod)->tmd_PosSize, possize);
TCopyMem(mod, inst, size);
((struct TModule *) inst)->tmd_PosSize = possize;
((struct TModule *) inst)->tmd_NegSize = negsize;
((struct TModule *) inst)->tmd_InitTask = TFindTask(TNULL);
}
return inst;
}
LOCAL void
fb_allocpen(WINDISPLAY *mod, struct TVRequest *req)
{
struct TExecBase *TExecBase = TGetExecBase(mod);
WINWINDOW *v = req->tvr_Op.AllocPen.Window;
TUINT rgb = req->tvr_Op.AllocPen.RGB;
struct FBPen *pen = TAlloc(mod->fbd_MemMgr, sizeof(struct FBPen));
if (pen)
{
COLORREF col = RGB2COLORREF(rgb);
pen->rgb = rgb;
pen->col = col;
pen->brush = CreateSolidBrush(col);
pen->pen = CreatePen(PS_SOLID, 0, col);
TAddTail(&v->penlist, &pen->node);
req->tvr_Op.AllocPen.Pen = (TVPEN) pen;
return;
}
req->tvr_Op.AllocPen.Pen = TVPEN_UNDEFINED;
}
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;
}
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 int CALLBACK fontenumcb(
ENUMLOGFONTEX *lpelfe,
NEWTEXTMETRICEX *lpntme,
int fonttype,
LPARAM param)
{
LOGFONT *lf = &lpelfe->elfLogFont;
TSTRPTR fullname = (TSTRPTR) lpelfe->elfFullName;
TSTRPTR style = (TSTRPTR) lpelfe->elfStyle;
TSTRPTR script = (TSTRPTR) lpelfe->elfScript;
struct FontQueryHandle *fqh = (struct FontQueryHandle *) param;
WINDISPLAY *mod = fqh->handle.thn_Owner;
struct TExecBase *TExecBase = TGetExecBase(mod);
struct FontQueryNode *fqn;
if (fqh->match_depth == 0)
{
LOGFONT logfont;
memcpy(&logfont, lf, sizeof(LOGFONT));
fqh->match_depth = 1;
TDBPRINTF(TDB_INFO,("fontenum - entering recursion\n"));
logfont.lfCharSet = ANSI_CHARSET;
logfont.lfPitchAndFamily = 0;
EnumFontFamiliesEx(
mod->fbd_DeviceHDC,
&logfont,
(FONTENUMPROCA) fontenumcb,
(LPARAM) fqh, 0);
fqh->match_depth = 0;
return TTRUE;
}
if (fqh->fscale && !(fonttype & TRUETYPE_FONTTYPE))
return TTRUE;
if (fqh->fitalic && !lf->lfItalic)
return TTRUE;
if (fqh->fbold && (lf->lfWeight < FW_BOLD))
return TTRUE;
TDBPRINTF(TDB_INFO,("entry:'%s' style:'%s' script:'%s' type:%04x weight:%d italic:%d recurs:%d, size:%d\n",
fullname, style, script, fonttype, lf->lfWeight, !!lf->lfItalic,
fqh->match_depth, lf->lfHeight));
fqn = TAlloc(TNULL,
sizeof(struct FontQueryNode) + strlen(fullname) + 1);
if (fqn == TNULL)
return TFALSE;
strcpy((char *) (fqn + 1), fullname);
fqn->tags[0].tti_Tag = TVisual_FontName;
fqn->tags[0].tti_Value = (TTAG) (fqn + 1);
fqn->tags[1].tti_Tag = TVisual_FontItalic;
fqn->tags[1].tti_Value = !!lf->lfItalic;
fqn->tags[2].tti_Tag = TVisual_FontBold;
fqn->tags[2].tti_Value = (lf->lfWeight >= FW_BOLD);
fqn->tags[3].tti_Tag = TTAG_DONE;
TAddTail(&fqh->reslist, &fqn->node);
return TTRUE;
}
TQuadNode *TQuadNodeNew(const TRectangle *bounds)
{
TQuadNode *qn = (TQuadNode *) TAlloc(sizeof(TQuadNode));
if(qn) TQuadNodeInit(qn,bounds);
return qn;
}
static void rfb_processevent(struct rfb_Display *mod)
{
TAPTR TExecBase = TGetExecBase(mod);
TIMSG *msg;
if (mod->rfb_RndIMsgPort == TNULL)
return;
while ((msg = TGetMsg(mod->rfb_RndIMsgPort)))
{
/*struct rfb_Window *v = (struct rfb_Window *) msg->timsg_Instance; */
TIMSG *imsg;
switch (msg->timsg_Type)
{
case TITYPE_INTERVAL:
TDBPRINTF(TDB_WARN, ("unhandled event: INTERVAL\n"));
break;
case TITYPE_REFRESH:
{
TINT drect[4];
drect[0] = msg->timsg_X;
drect[1] = msg->timsg_Y;
drect[2] = msg->timsg_X + msg->timsg_Width - 1;
drect[3] = msg->timsg_Y + msg->timsg_Height - 1;
rfb_damage(mod, drect, TNULL);
rfb_flush_clients(mod, TTRUE);
break;
}
case TITYPE_NEWSIZE:
if ((mod->rfb_Flags & RFBFL_BUFFER_OWNER) &&
(mod->rfb_Flags & RFBFL_BUFFER_CAN_RESIZE))
{
region_free(&mod->rfb_RectPool, &mod->rfb_DirtyRegion);
mod->rfb_Flags &= ~RFBFL_DIRTY;
TINT neww = mod->rfb_Width = msg->timsg_Width;
TINT newh = mod->rfb_Height = msg->timsg_Height;
TUINT pixfmt = mod->rfb_PixBuf.tpb_Format;
TUINT bpp = TVPIXFMT_BYTES_PER_PIXEL(pixfmt);
TUINT bpl = bpp * neww;
struct TVPixBuf newbuf;
newbuf.tpb_BytesPerLine = bpl;
newbuf.tpb_Format = mod->rfb_PixBuf.tpb_Format;
newbuf.tpb_Data = TAlloc(mod->rfb_MemMgr, bpl * newh);
if (newbuf.tpb_Data == TNULL)
break;
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;
rfb_setrealcliprect(mod, v);
TINT w0 = REGION_RECT_WIDTH(&v->rfbw_ScreenRect);
TINT h0 = REGION_RECT_HEIGHT(&v->rfbw_ScreenRect);
if ((v->rfbw_Flags & RFBWFL_FULLSCREEN))
{
v->rfbw_ScreenRect.r[0] = 0;
v->rfbw_ScreenRect.r[1] = 0;
v->rfbw_ScreenRect.r[2] = neww - 1;
v->rfbw_ScreenRect.r[3] = newh - 1;
}
TINT ww = REGION_RECT_WIDTH(&v->rfbw_ScreenRect);
TINT wh = REGION_RECT_HEIGHT(&v->rfbw_ScreenRect);
if (v->rfbw_MinWidth > 0 && ww < v->rfbw_MinWidth)
v->rfbw_ScreenRect.r[0] =
v->rfbw_ScreenRect.r[2] - v->rfbw_MinWidth;
if (v->rfbw_MinHeight > 0 && wh < v->rfbw_MinHeight)
v->rfbw_ScreenRect.r[1] =
v->rfbw_ScreenRect.r[3] - v->rfbw_MinHeight;
ww = REGION_RECT_WIDTH(&v->rfbw_ScreenRect);
wh = REGION_RECT_HEIGHT(&v->rfbw_ScreenRect);
if (v->rfbw_Flags & RFBWFL_BACKBUFFER)
rfb_resizewinbuffer(mod, v, w0, h0, ww, wh);
else
v->rfbw_PixBuf = newbuf;
rfb_setwinrect(mod, v);
if (ww != w0 || wh != h0)
{
if (rfb_getimsg(mod, v, &imsg, TITYPE_NEWSIZE))
{
imsg->timsg_Width = ww;
imsg->timsg_Height = wh;
TPutMsg(v->rfbw_IMsgPort, TNULL, imsg);
}
}
}
TFree(mod->rfb_PixBuf.tpb_Data);
mod->rfb_PixBuf = newbuf;
struct Rect drect;
REGION_RECT_SET(&drect, 0, 0, neww - 1, newh - 1);
rfb_damage(mod, drect.r, TNULL);
}
else
TDBPRINTF(TDB_WARN, ("Cannot resize this framebuffer\n"));
break;
case TITYPE_CLOSE:
{
/* send to root window */
TLock(mod->rfb_InstanceLock);
struct rfb_Window *v =
(struct rfb_Window *) TLASTNODE(&mod->rfb_VisualList);
if (rfb_getimsg(mod, v, &imsg, TITYPE_CLOSE))
TPutMsg(v->rfbw_IMsgPort, TNULL, imsg);
TUnlock(mod->rfb_InstanceLock);
break;
}
case TITYPE_FOCUS:
TDBPRINTF(TDB_INFO, ("unhandled event: FOCUS\n"));
break;
case TITYPE_MOUSEOVER:
TDBPRINTF(TDB_INFO, ("unhandled event: MOUSEOVER\n"));
break;
case TITYPE_KEYUP:
case TITYPE_KEYDOWN:
rfb_passevent_keyboard(mod, msg);
break;
case TITYPE_MOUSEMOVE:
rfb_passevent_mousemove(mod, msg);
break;
case TITYPE_MOUSEBUTTON:
rfb_passevent_mousebutton(mod, msg);
break;
}
TReplyMsg(msg);
}
}
static TBOOL x11_processvisualevent(struct X11Display *mod,
struct X11Window *v, TAPTR msgstate, XEvent *ev)
{
TAPTR TExecBase = TGetExecBase(mod);
TIMSG *imsg;
switch (ev->type)
{
case ClientMessage:
if ((v->eventmask & TITYPE_CLOSE) &&
(Atom) ev->xclient.data.l[0] == v->atom_wm_delete_win)
{
if (x11_getimsg(mod, v, &imsg, TITYPE_CLOSE))
TAddTail(&v->imsgqueue, &imsg->timsg_Node);
}
break;
case ConfigureNotify:
if (mod->x11_RequestInProgress && (v->flags & X11WFL_WAIT_RESIZE))
{
TReplyMsg(mod->x11_RequestInProgress);
mod->x11_RequestInProgress = TNULL;
v->flags &= ~X11WFL_WAIT_RESIZE;
TDBPRINTF(TDB_INFO, ("Released request (ConfigureNotify)\n"));
}
v->winleft = ev->xconfigure.x;
v->wintop = ev->xconfigure.y;
if ((v->winwidth != ev->xconfigure.width ||
v->winheight != ev->xconfigure.height))
{
v->flags |= X11WFL_WAIT_EXPOSE;
v->winwidth = ev->xconfigure.width;
v->winheight = ev->xconfigure.height;
if (v->eventmask & TITYPE_NEWSIZE)
{
if (x11_getimsg(mod, v, &imsg, TITYPE_NEWSIZE))
{
imsg->timsg_Width = v->winwidth;
imsg->timsg_Height = v->winheight;
TAddTail(&v->imsgqueue, &imsg->timsg_Node);
}
TDBPRINTF(TDB_TRACE, ("Configure: NEWSIZE: %d %d\n",
v->winwidth, v->winheight));
}
}
break;
case EnterNotify:
case LeaveNotify:
if (v->eventmask & TITYPE_MOUSEOVER)
{
if (x11_getimsg(mod, v, &imsg, TITYPE_MOUSEOVER))
{
imsg->timsg_Code = (ev->type == EnterNotify);
TAddTail(&v->imsgqueue, &imsg->timsg_Node);
}
}
break;
case MapNotify:
if (mod->x11_RequestInProgress)
{
TReplyMsg(mod->x11_RequestInProgress);
mod->x11_RequestInProgress = TNULL;
v->flags |= X11WFL_WAIT_EXPOSE;
TDBPRINTF(TDB_TRACE, ("Released request (MapNotify)\n"));
}
break;
case Expose:
if (v->flags & X11WFL_WAIT_EXPOSE)
v->flags &= ~X11WFL_WAIT_EXPOSE;
else if ((v->eventmask & TITYPE_REFRESH) &&
x11_getimsg(mod, v, &imsg, TITYPE_REFRESH))
{
imsg->timsg_X = ev->xexpose.x;
imsg->timsg_Y = ev->xexpose.y;
imsg->timsg_Width = ev->xexpose.width;
imsg->timsg_Height = ev->xexpose.height;
TAddTail(&v->imsgqueue, &imsg->timsg_Node);
TDBPRINTF(TDB_TRACE, ("Expose: REFRESH: %d %d %d %d\n",
imsg->timsg_X, imsg->timsg_Y,
imsg->timsg_Width, imsg->timsg_Height));
}
break;
case GraphicsExpose:
if (mod->x11_CopyExposeHook)
{
TINT rect[4];
rect[0] = ev->xgraphicsexpose.x;
rect[1] = ev->xgraphicsexpose.y;
rect[2] = rect[0] + ev->xgraphicsexpose.width - 1;
rect[3] = rect[1] + ev->xgraphicsexpose.height - 1;
TCallHookPkt(mod->x11_CopyExposeHook,
mod->x11_RequestInProgress->tvr_Op.CopyArea.Window,
(TTAG) rect);
}
if (ev->xgraphicsexpose.count > 0)
break;
/* no more graphics expose events, fallthru: */
case NoExpose:
if (mod->x11_RequestInProgress)
{
TReplyMsg(mod->x11_RequestInProgress);
mod->x11_RequestInProgress = TNULL;
mod->x11_CopyExposeHook = TNULL;
TDBPRINTF(TDB_TRACE, ("Released request (NoExpose)\n"));
}
else
TDBPRINTF(TDB_INFO, ("NoExpose: TITYPE_REFRESH not set\n"));
break;
case FocusIn:
case FocusOut:
mod->x11_KeyQual = 0;
if (v->eventmask & TITYPE_FOCUS)
{
if (x11_getimsg(mod, v, &imsg, TITYPE_FOCUS))
{
imsg->timsg_Code = (ev->type == FocusIn);
TAddTail(&v->imsgqueue, &imsg->timsg_Node);
}
}
break;
case MotionNotify:
{
struct TNode *next, *node = mod->x11_vlist.tlh_Head.tln_Succ;
x11_setmousepos(mod, v, ev->xmotion.x, ev->xmotion.y);
v->mousex = mod->x11_ScreenMouseX - v->winleft;
v->mousey = mod->x11_ScreenMouseY - v->wintop;
for (; (next = node->tln_Succ); node = next)
{
struct X11Window *v = (struct X11Window *) node;
if (v->eventmask & TITYPE_MOUSEMOVE &&
x11_getimsg(mod, v, &imsg, TITYPE_MOUSEMOVE))
TAddTail(&v->imsgqueue, &imsg->timsg_Node);
}
break;
}
case ButtonRelease:
case ButtonPress:
x11_setmousepos(mod, v, ev->xbutton.x, ev->xbutton.y);
if (v->eventmask & TITYPE_MOUSEBUTTON)
{
if (x11_getimsg(mod, v, &imsg, TITYPE_MOUSEBUTTON))
{
unsigned int button = ev->xbutton.button;
if (ev->type == ButtonPress)
{
switch (button)
{
case Button1:
imsg->timsg_Code = TMBCODE_LEFTDOWN;
break;
case Button2:
imsg->timsg_Code = TMBCODE_MIDDLEDOWN;
break;
case Button3:
imsg->timsg_Code = TMBCODE_RIGHTDOWN;
break;
case Button4:
imsg->timsg_Code = TMBCODE_WHEELUP;
break;
case Button5:
imsg->timsg_Code = TMBCODE_WHEELDOWN;
break;
}
}
else
{
switch (button)
{
case Button1:
imsg->timsg_Code = TMBCODE_LEFTUP;
break;
case Button2:
imsg->timsg_Code = TMBCODE_MIDDLEUP;
break;
case Button3:
imsg->timsg_Code = TMBCODE_RIGHTUP;
break;
}
}
TAddTail(&v->imsgqueue, &imsg->timsg_Node);
}
}
break;
case KeyRelease:
x11_processkey(mod, v, (XKeyEvent *) ev, TFALSE);
break;
case KeyPress:
x11_processkey(mod, v, (XKeyEvent *) ev, TTRUE);
break;
case SelectionRequest:
{
XSelectionRequestEvent *req = (XSelectionRequestEvent *) ev;
XEvent replyevent;
XSelectionEvent *reply = &replyevent.xselection;
memset(&replyevent, 0, sizeof replyevent);
reply->type = SelectionNotify;
reply->serial = ev->xany.send_event;
reply->send_event = True;
reply->display = req->display;
reply->requestor = req->requestor;
reply->selection = req->selection;
reply->property = req->property;
reply->target = None;
reply->time = req->time;
if (req->target == mod->x11_XA_TARGETS)
{
XChangeProperty(mod->x11_Display, req->requestor,
req->property, XA_ATOM, 32, PropModeReplace,
(unsigned char *) &mod->x11_XA_UTF8_STRING, 1);
}
else if (req->target == mod->x11_XA_UTF8_STRING)
{
XSelectionEvent *rcopy = TAlloc(TNULL, sizeof *reply);
if (rcopy && x11_getimsg(mod, v, &imsg, TITYPE_REQSELECTION))
{
*rcopy = *reply;
imsg->timsg_Requestor = (TTAG) rcopy;
imsg->timsg_Code =
req->selection == mod->x11_XA_PRIMARY ? 2 : 1;
TAddTail(&v->imsgqueue, &imsg->timsg_Node);
break;
}
TFree(rcopy);
}
else
reply->property = None;
XSendEvent(mod->x11_Display, req->requestor, 0, NoEventMask,
&replyevent);
XSync(mod->x11_Display, False);
break;
}
}
return TFALSE;
}
TProfile *TProfileNew(void)
{
TProfile *p = (TProfile *) TAlloc(sizeof(p));
if(p) TProfileInit(p);
return p;
}
