void loop()
{
int fd = nids_getfd();
fd_set rset;
UpdateCurrentTime(&g_StartTime);
UpdateCurrentTime(&g_LastTimer);
g_InitTimer = TRUE;
for (;;)
{
struct timeval tv;
tv.tv_sec = 0;
tv.tv_usec = 50 * 1000;
FD_ZERO(&rset);
FD_SET(fd, &rset);
UpdateCurrentTime(&g_CurrentTime);
CheckTimerEvents();
if (select(fd + 1, &rset, 0, 0, &tv)) {
if (FD_ISSET(fd, &rset)) {
if (!nids_next()) {
fprintf(stderr, "%s\n", nids_errbuf);
break;
}
}
}
}
}
/*
* Something changed; send events and adjust pointer position
*/
void
RRTellChanged (ScreenPtr pScreen)
{
rrScrPriv (pScreen);
int i;
if (pScrPriv->changed)
{
UpdateCurrentTime ();
if (pScrPriv->configChanged)
{
pScrPriv->lastConfigTime = currentTime;
pScrPriv->configChanged = FALSE;
}
pScrPriv->changed = FALSE;
WalkTree (pScreen, TellChanged, (pointer) pScreen);
for (i = 0; i < pScrPriv->numOutputs; i++)
pScrPriv->outputs[i]->changed = FALSE;
for (i = 0; i < pScrPriv->numCrtcs; i++)
pScrPriv->crtcs[i]->changed = FALSE;
if (pScrPriv->layoutChanged)
{
pScrPriv->layoutChanged = FALSE;
RRPointerScreenConfigured (pScreen);
RRSendConfigNotify (pScreen);
}
}
}
void
nsSMILTimeContainer::SetCurrentTime(nsSMILTime aSeekTo)
{
// SVG 1.1 doesn't specify what to do for negative times so we adopt SVGT1.2's
// behaviour of clamping negative times to 0.
aSeekTo = NS_MAX<nsSMILTime>(0, aSeekTo);
// The following behaviour is consistent with:
// http://www.w3.org/2003/01/REC-SVG11-20030114-errata
// #getCurrentTime_setCurrentTime_undefined_before_document_timeline_begin
// which says that if SetCurrentTime is called before the document timeline
// has begun we should still adjust the offset.
nsSMILTime parentTime = GetParentTime();
mParentOffset = parentTime - aSeekTo;
mIsSeeking = PR_TRUE;
if (IsPaused()) {
mNeedsPauseSample = PR_TRUE;
mPauseStart = parentTime;
}
if (aSeekTo < mCurrentTime) {
// Backwards seek
mNeedsRewind = PR_TRUE;
ClearMilestones();
}
// Force an update to the current time in case we get a call to GetCurrentTime
// before another call to Sample().
UpdateCurrentTime();
NotifyTimeChange();
}
int
XvdiUngrabPort(
ClientPtr client,
XvPortPtr pPort,
Time ctime
){
TimeStamp time;
UpdateCurrentTime();
time = ClientTimeToServerTime(ctime);
if ((!pPort->grab.client) || (client != pPort->grab.client))
{
return Success;
}
if ((CompareTimeStamps(time, currentTime) == LATER) ||
(CompareTimeStamps(time, pPort->time) == EARLIER))
{
return Success;
}
/* FREE THE GRAB RESOURCE; AND SET THE GRAB CLIENT TO NULL */
FreeResource(pPort->grab.id, XvRTGrab);
pPort->grab.client = NULL;
pPort->time = currentTime;
return Success;
}
static int
ProcShapeOffset(ClientPtr client)
{
WindowPtr pWin;
REQUEST(xShapeOffsetReq);
RegionPtr srcRgn;
int rc;
REQUEST_SIZE_MATCH(xShapeOffsetReq);
UpdateCurrentTime();
rc = dixLookupWindow(&pWin, stuff->dest, client, DixSetAttrAccess);
if (rc != Success)
return rc;
switch (stuff->destKind) {
case ShapeBounding:
srcRgn = wBoundingShape(pWin);
break;
case ShapeClip:
srcRgn = wClipShape(pWin);
break;
case ShapeInput:
srcRgn = wInputShape(pWin);
break;
default:
client->errorValue = stuff->destKind;
return BadValue;
}
if (srcRgn) {
RegionTranslate(srcRgn, stuff->xOff, stuff->yOff);
(*pWin->drawable.pScreen->SetShape) (pWin, stuff->destKind);
}
SendShapeNotify(pWin, (int) stuff->destKind);
return Success;
}
void
JXApplication::HandleOneEvent()
{
itsHadBlockingWindowFlag = kJFalse;
UpdateCurrentTime();
const JBoolean allowSleep = HandleCustomEvent();
UpdateCurrentTime();
JBoolean hasEvents = kJFalse;
JPtrArrayIterator<JXDisplay> iter(itsDisplayList);
JXDisplay* display;
JIndex displayIndex = 0;
while (iter.Next(&display))
{
displayIndex++;
itsCurrDisplayIndex = displayIndex; // itsCurrDisplayIndex might change during event
if (XPending(*display) != 0)
{
hasEvents = kJTrue;
// get the next event
XEvent xEvent;
XNextEvent(*display, &xEvent);
if (xEvent.type != MotionNotify)
{
itsLastIdleTime = itsCurrentTime;
}
// dispatch the event
display->HandleEvent(xEvent, itsCurrentTime);
}
else
{
display->Idle(itsCurrentTime);
}
}
PopAllIdleTaskStack();
PerformTasks(hasEvents, allowSleep);
}
HighlightFiles::HighlightFiles()
{
Changed = false;
HierarchicalConfig *cfg = CreateHighlightConfig();
SetHighlighting(false, cfg);
InitHighlightFiles(cfg);
UpdateCurrentTime();
delete cfg;
}
int
XvdiGrabPort(
ClientPtr client,
XvPortPtr pPort,
Time ctime,
int *p_result
){
unsigned long id;
TimeStamp time;
UpdateCurrentTime();
time = ClientTimeToServerTime(ctime);
if (pPort->grab.client && (client != pPort->grab.client))
{
*p_result = XvAlreadyGrabbed;
return Success;
}
if ((CompareTimeStamps(time, currentTime) == LATER) ||
(CompareTimeStamps(time, pPort->time) == EARLIER))
{
*p_result = XvInvalidTime;
return Success;
}
if (client == pPort->grab.client)
{
*p_result = Success;
return Success;
}
id = FakeClientID(client->index);
if (!AddResource(id, XvRTGrab, &pPort->grab))
{
return BadAlloc;
}
/* IF THERE IS ACTIVE VIDEO THEN STOP IT */
if ((pPort->pDraw) && (client != pPort->client))
{
XvdiStopVideo(NULL, pPort, pPort->pDraw);
}
pPort->grab.client = client;
pPort->grab.id = id;
pPort->time = currentTime;
*p_result = Success;
return Success;
}
void
nsSMILTimeContainer::Sample()
{
if (!NeedsSample())
return;
UpdateCurrentTime();
DoSample();
mNeedsPauseSample = PR_FALSE;
}
int
ProcSetSelectionOwner(ClientPtr client)
{
WindowPtr pWin = NULL;
TimeStamp time;
Selection *pSel;
int rc;
REQUEST(xSetSelectionOwnerReq);
REQUEST_SIZE_MATCH(xSetSelectionOwnerReq);
UpdateCurrentTime();
time = ClientTimeToServerTime(stuff->time);
/* If the client's time stamp is in the future relative to the server's
time stamp, do not set the selection, just return success. */
if (CompareTimeStamps(time, currentTime) == LATER)
return Success;
if (stuff->window != None) {
rc = dixLookupWindow(&pWin, stuff->window, client, DixSetAttrAccess);
if (rc != Success)
return rc;
}
if (!ValidAtom(stuff->selection)) {
client->errorValue = stuff->selection;
return BadAtom;
}
/*
* First, see if the selection is already set...
*/
rc = dixLookupSelection(&pSel, stuff->selection, client, DixSetAttrAccess);
if (rc == Success) {
/* If the timestamp in client's request is in the past relative
to the time stamp indicating the last time the owner of the
selection was set, do not set the selection, just return
success. */
if (CompareTimeStamps(time, pSel->lastTimeChanged) == EARLIER)
return Success;
if (pSel->client && (!pWin || (pSel->client != client))) {
xEvent event = {
.u.selectionClear.time = time.milliseconds,
.u.selectionClear.window = pSel->window,
.u.selectionClear.atom = pSel->selection
};
event.u.u.type = SelectionClear;
WriteEventsToClient(pSel->client, 1, &event);
}
}
else if (rc == BadMatch) {
int
XvdiGetVideo(
ClientPtr client,
DrawablePtr pDraw,
XvPortPtr pPort,
GCPtr pGC,
INT16 vid_x, INT16 vid_y,
CARD16 vid_w, CARD16 vid_h,
INT16 drw_x, INT16 drw_y,
CARD16 drw_w, CARD16 drw_h
){
DrawablePtr pOldDraw;
CHECK_SIZE(drw_w, drw_h, vid_w, vid_h);
/* UPDATE TIME VARIABLES FOR USE IN EVENTS */
UpdateCurrentTime();
/* CHECK FOR GRAB; IF THIS CLIENT DOESN'T HAVE THE PORT GRABBED THEN
INFORM CLIENT OF ITS FAILURE */
if (pPort->grab.client && (pPort->grab.client != client))
{
XvdiSendVideoNotify(pPort, pDraw, XvBusy);
return Success;
}
/* CHECK TO SEE IF PORT IS IN USE; IF SO THEN WE MUST DELIVER INTERRUPTED
EVENTS TO ANY CLIENTS WHO WANT THEM */
pOldDraw = pPort->pDraw;
if ((pOldDraw) && (pOldDraw != pDraw))
{
XvdiSendVideoNotify(pPort, pPort->pDraw, XvPreempted);
}
(void) (* pPort->pAdaptor->ddGetVideo)(client, pDraw, pPort, pGC,
vid_x, vid_y, vid_w, vid_h,
drw_x, drw_y, drw_w, drw_h);
if ((pPort->pDraw) && (pOldDraw != pDraw))
{
pPort->client = client;
XvdiSendVideoNotify(pPort, pPort->pDraw, XvStarted);
}
pPort->time = currentTime;
return (Success);
}
int
SProcXvDispatch(ClientPtr client)
{
REQUEST(xReq);
UpdateCurrentTime();
if (stuff->data >= xvNumRequests) {
SendErrorToClient(client, XvReqCode, stuff->data, 0, BadRequest);
return BadRequest;
}
return SXvProcVector[stuff->data](client);
}
void
nsSMILTimeContainer::Begin()
{
Resume(PAUSE_BEGIN);
if (mPauseState) {
mNeedsPauseSample = PR_TRUE;
}
// This is a little bit complicated here. Ideally we'd just like to call
// Sample() and force an initial sample but this turns out to be a bad idea
// because this may mean that NeedsSample() no longer reports true and so when
// we come to the first real sample our parent will skip us over altogether.
// So we force the time to be updated and adopt the policy to never call
// Sample() ourselves but to always leave that to our parent or client.
UpdateCurrentTime();
}
void
nsSMILTimeContainer::SetCurrentTime(nsSMILTime aSeekTo)
{
// The following behaviour is consistent with:
// http://www.w3.org/2003/01/REC-SVG11-20030114-errata
// #getCurrentTime_setCurrentTime_undefined_before_document_timeline_begin
// which says that if SetCurrentTime is called before the document timeline
// has begun we should still adjust the offset.
nsSMILTime parentTime = GetParentTime();
mParentOffset = parentTime - aSeekTo;
if (mPauseState) {
mNeedsPauseSample = PR_TRUE;
mPauseStart = parentTime;
}
// Force an update to the current time in case we get a call to GetCurrentTime
// before another call to Sample().
UpdateCurrentTime();
}
int
XvdiGetStill(
ClientPtr client,
DrawablePtr pDraw,
XvPortPtr pPort,
GCPtr pGC,
INT16 vid_x, INT16 vid_y,
CARD16 vid_w, CARD16 vid_h,
INT16 drw_x, INT16 drw_y,
CARD16 drw_w, CARD16 drw_h
){
int status;
CHECK_SIZE(drw_w, drw_h, vid_w, vid_h);
/* UPDATE TIME VARIABLES FOR USE IN EVENTS */
UpdateCurrentTime();
/* CHECK FOR GRAB; IF THIS CLIENT DOESN'T HAVE THE PORT GRABBED THEN
INFORM CLIENT OF ITS FAILURE */
if (pPort->grab.client && (pPort->grab.client != client))
{
XvdiSendVideoNotify(pPort, pDraw, XvBusy);
return Success;
}
status = (* pPort->pAdaptor->ddGetStill)(client, pDraw, pPort, pGC,
vid_x, vid_y, vid_w, vid_h,
drw_x, drw_y, drw_w, drw_h);
pPort->time = currentTime;
return status;
}
int
XvdiPutImage(
ClientPtr client,
DrawablePtr pDraw,
XvPortPtr pPort,
GCPtr pGC,
INT16 src_x, INT16 src_y,
CARD16 src_w, CARD16 src_h,
INT16 drw_x, INT16 drw_y,
CARD16 drw_w, CARD16 drw_h,
XvImagePtr image,
unsigned char* data,
Bool sync,
CARD16 width, CARD16 height
){
CHECK_SIZE(drw_w, drw_h, src_w, src_h);
/* UPDATE TIME VARIABLES FOR USE IN EVENTS */
UpdateCurrentTime();
/* CHECK FOR GRAB; IF THIS CLIENT DOESN'T HAVE THE PORT GRABBED THEN
INFORM CLIENT OF ITS FAILURE */
if (pPort->grab.client && (pPort->grab.client != client))
{
XvdiSendVideoNotify(pPort, pDraw, XvBusy);
return Success;
}
pPort->time = currentTime;
return (* pPort->pAdaptor->ddPutImage)(client, pDraw, pPort, pGC,
src_x, src_y, src_w, src_h,
drw_x, drw_y, drw_w, drw_h,
image, data, sync, width, height);
}
static int
ProcXTestFakeInput(ClientPtr client)
{
REQUEST(xXTestFakeInputReq);
int nev, n, type, rc;
xEvent *ev;
DeviceIntPtr dev = NULL;
WindowPtr root;
Bool extension = FALSE;
ValuatorMask mask;
int valuators[MAX_VALUATORS] = { 0 };
int numValuators = 0;
int firstValuator = 0;
int nevents = 0;
int i;
int base = 0;
int flags = 0;
int need_ptr_update = 1;
nev = (stuff->length << 2) - sizeof(xReq);
if ((nev % sizeof(xEvent)) || !nev)
return BadLength;
nev /= sizeof(xEvent);
UpdateCurrentTime();
ev = (xEvent *) &((xReq *) stuff)[1];
type = ev->u.u.type & 0177;
if (type >= EXTENSION_EVENT_BASE) {
extension = TRUE;
/* check device */
rc = dixLookupDevice(&dev, stuff->deviceid & 0177, client,
DixWriteAccess);
if (rc != Success) {
client->errorValue = stuff->deviceid & 0177;
return rc;
}
/* check type */
type -= DeviceValuator;
switch (type) {
case XI_DeviceKeyPress:
case XI_DeviceKeyRelease:
if (!dev->key) {
client->errorValue = ev->u.u.type;
return BadValue;
}
break;
case XI_DeviceButtonPress:
case XI_DeviceButtonRelease:
if (!dev->button) {
client->errorValue = ev->u.u.type;
return BadValue;
}
break;
case XI_DeviceMotionNotify:
if (!dev->valuator) {
client->errorValue = ev->u.u.type;
return BadValue;
}
break;
case XI_ProximityIn:
case XI_ProximityOut:
if (!dev->proximity) {
client->errorValue = ev->u.u.type;
return BadValue;
}
break;
default:
client->errorValue = ev->u.u.type;
return BadValue;
}
/* check validity */
if (nev == 1 && type == XI_DeviceMotionNotify)
return BadLength; /* DevMotion must be followed by DevValuator */
if (type == XI_DeviceMotionNotify) {
firstValuator = ((deviceValuator *) (ev + 1))->first_valuator;
if (firstValuator > dev->valuator->numAxes) {
client->errorValue = ev->u.u.type;
return BadValue;
}
if (ev->u.u.detail == xFalse)
flags |= POINTER_ABSOLUTE;
}
else {
firstValuator = 0;
flags |= POINTER_ABSOLUTE;
}
if (nev > 1 && !dev->valuator) {
client->errorValue = firstValuator;
return BadValue;
}
/* check validity of valuator events */
base = firstValuator;
for (n = 1; n < nev; n++) {
deviceValuator *dv = (deviceValuator *) (ev + n);
if (dv->type != DeviceValuator) {
client->errorValue = dv->type;
return BadValue;
}
if (dv->first_valuator != base) {
client->errorValue = dv->first_valuator;
return BadValue;
}
switch (dv->num_valuators) {
case 6:
valuators[base + 5] = dv->valuator5;
case 5:
valuators[base + 4] = dv->valuator4;
case 4:
valuators[base + 3] = dv->valuator3;
case 3:
valuators[base + 2] = dv->valuator2;
case 2:
valuators[base + 1] = dv->valuator1;
case 1:
valuators[base] = dv->valuator0;
break;
default:
client->errorValue = dv->num_valuators;
return BadValue;
}
base += dv->num_valuators;
numValuators += dv->num_valuators;
if (firstValuator + numValuators > dev->valuator->numAxes) {
client->errorValue = dv->num_valuators;
return BadValue;
}
}
type = type - XI_DeviceKeyPress + KeyPress;
}
else {
if (nev != 1)
return BadLength;
switch (type) {
case KeyPress:
case KeyRelease:
dev = PickKeyboard(client);
break;
case ButtonPress:
case ButtonRelease:
dev = PickPointer(client);
break;
case MotionNotify:
dev = PickPointer(client);
valuators[0] = ev->u.keyButtonPointer.rootX;
valuators[1] = ev->u.keyButtonPointer.rootY;
numValuators = 2;
firstValuator = 0;
if (ev->u.u.detail == xFalse)
flags = POINTER_ABSOLUTE | POINTER_DESKTOP;
break;
default:
client->errorValue = ev->u.u.type;
return BadValue;
}
/* Technically the protocol doesn't allow for BadAccess here but
* this can only happen when all MDs are disabled. */
if (!dev)
return BadAccess;
dev = GetXTestDevice(dev);
}
/* If the event has a time set, wait for it to pass */
if (ev->u.keyButtonPointer.time) {
TimeStamp activateTime;
CARD32 ms;
activateTime = currentTime;
ms = activateTime.milliseconds + ev->u.keyButtonPointer.time;
if (ms < activateTime.milliseconds)
activateTime.months++;
activateTime.milliseconds = ms;
ev->u.keyButtonPointer.time = 0;
/* see mbuf.c:QueueDisplayRequest (from the deprecated Multibuffer
* extension) for code similar to this */
if (!ClientSleepUntil(client, &activateTime, NULL, NULL)) {
return BadAlloc;
}
/* swap the request back so we can simply re-execute it */
if (client->swapped) {
(void) XTestSwapFakeInput(client, (xReq *) stuff);
swaps(&stuff->length);
}
ResetCurrentRequest(client);
client->sequence--;
return Success;
}
switch (type) {
case KeyPress:
case KeyRelease:
if (!dev->key)
return BadDevice;
if (ev->u.u.detail < dev->key->xkbInfo->desc->min_key_code ||
ev->u.u.detail > dev->key->xkbInfo->desc->max_key_code) {
client->errorValue = ev->u.u.detail;
return BadValue;
}
need_ptr_update = 0;
break;
case MotionNotify:
if (!dev->valuator)
return BadDevice;
if (!(extension || ev->u.keyButtonPointer.root == None)) {
rc = dixLookupWindow(&root, ev->u.keyButtonPointer.root,
client, DixGetAttrAccess);
if (rc != Success)
return rc;
if (root->parent) {
client->errorValue = ev->u.keyButtonPointer.root;
return BadValue;
}
/* Add the root window's offset to the valuators */
if ((flags & POINTER_ABSOLUTE) && firstValuator <= 1 && numValuators > 0) {
if (firstValuator == 0)
valuators[0] += root->drawable.pScreen->x;
if (firstValuator < 2 && firstValuator + numValuators > 1)
valuators[1 - firstValuator] += root->drawable.pScreen->y;
}
}
if (ev->u.u.detail != xTrue && ev->u.u.detail != xFalse) {
client->errorValue = ev->u.u.detail;
return BadValue;
}
/* FIXME: Xinerama! */
break;
case ButtonPress:
case ButtonRelease:
if (!dev->button)
return BadDevice;
if (!ev->u.u.detail || ev->u.u.detail > dev->button->numButtons) {
client->errorValue = ev->u.u.detail;
return BadValue;
}
break;
}
if (screenIsSaved == SCREEN_SAVER_ON)
dixSaveScreens(serverClient, SCREEN_SAVER_OFF, ScreenSaverReset);
switch (type) {
case MotionNotify:
valuator_mask_set_range(&mask, firstValuator, numValuators, valuators);
nevents = GetPointerEvents(xtest_evlist, dev, type, 0, flags, &mask);
break;
case ButtonPress:
case ButtonRelease:
valuator_mask_set_range(&mask, firstValuator, numValuators, valuators);
nevents = GetPointerEvents(xtest_evlist, dev, type, ev->u.u.detail,
flags, &mask);
break;
case KeyPress:
case KeyRelease:
nevents =
GetKeyboardEvents(xtest_evlist, dev, type, ev->u.u.detail);
break;
}
for (i = 0; i < nevents; i++)
mieqProcessDeviceEvent(dev, &xtest_evlist[i], miPointerGetScreen(inputInfo.pointer));
if (need_ptr_update)
miPointerUpdateSprite(dev);
return Success;
}
static int
ProcShapeRectangles(ClientPtr client)
{
WindowPtr pWin;
REQUEST(xShapeRectanglesReq);
xRectangle *prects;
int nrects, ctype, rc;
RegionPtr srcRgn;
RegionPtr *destRgn;
CreateDftPtr createDefault;
REQUEST_AT_LEAST_SIZE(xShapeRectanglesReq);
UpdateCurrentTime();
rc = dixLookupWindow(&pWin, stuff->dest, client, DixSetAttrAccess);
if (rc != Success)
return rc;
switch (stuff->destKind) {
case ShapeBounding:
createDefault = CreateBoundingShape;
break;
case ShapeClip:
createDefault = CreateClipShape;
break;
case ShapeInput:
createDefault = CreateBoundingShape;
break;
default:
client->errorValue = stuff->destKind;
return BadValue;
}
if ((stuff->ordering != Unsorted) && (stuff->ordering != YSorted) &&
(stuff->ordering != YXSorted) && (stuff->ordering != YXBanded)) {
client->errorValue = stuff->ordering;
return BadValue;
}
nrects = ((stuff->length << 2) - sizeof(xShapeRectanglesReq));
if (nrects & 4)
return BadLength;
nrects >>= 3;
prects = (xRectangle *) &stuff[1];
ctype = VerifyRectOrder(nrects, prects, (int) stuff->ordering);
if (ctype < 0)
return BadMatch;
srcRgn = RegionFromRects(nrects, prects, ctype);
if (!pWin->optional)
MakeWindowOptional(pWin);
switch (stuff->destKind) {
case ShapeBounding:
destRgn = &pWin->optional->boundingShape;
break;
case ShapeClip:
destRgn = &pWin->optional->clipShape;
break;
case ShapeInput:
destRgn = &pWin->optional->inputShape;
break;
default:
return BadValue;
}
return RegionOperate(client, pWin, (int) stuff->destKind,
destRgn, srcRgn, (int) stuff->op,
stuff->xOff, stuff->yOff, createDefault);
}
static int
ProcShapeMask(ClientPtr client)
{
WindowPtr pWin;
ScreenPtr pScreen;
REQUEST(xShapeMaskReq);
RegionPtr srcRgn;
RegionPtr *destRgn;
PixmapPtr pPixmap;
CreateDftPtr createDefault;
int rc;
REQUEST_SIZE_MATCH(xShapeMaskReq);
UpdateCurrentTime();
rc = dixLookupWindow(&pWin, stuff->dest, client, DixSetAttrAccess);
if (rc != Success)
return rc;
switch (stuff->destKind) {
case ShapeBounding:
createDefault = CreateBoundingShape;
break;
case ShapeClip:
createDefault = CreateClipShape;
break;
case ShapeInput:
createDefault = CreateBoundingShape;
break;
default:
client->errorValue = stuff->destKind;
return BadValue;
}
pScreen = pWin->drawable.pScreen;
if (stuff->src == None)
srcRgn = 0;
else {
rc = dixLookupResourceByType((pointer *) &pPixmap, stuff->src,
RT_PIXMAP, client, DixReadAccess);
if (rc != Success)
return rc;
if (pPixmap->drawable.pScreen != pScreen ||
pPixmap->drawable.depth != 1)
return BadMatch;
srcRgn = BitmapToRegion(pScreen, pPixmap);
if (!srcRgn)
return BadAlloc;
}
if (!pWin->optional)
MakeWindowOptional(pWin);
switch (stuff->destKind) {
case ShapeBounding:
destRgn = &pWin->optional->boundingShape;
break;
case ShapeClip:
destRgn = &pWin->optional->clipShape;
break;
case ShapeInput:
destRgn = &pWin->optional->inputShape;
break;
default:
return BadValue;
}
return RegionOperate(client, pWin, (int) stuff->destKind,
destRgn, srcRgn, (int) stuff->op,
stuff->xOff, stuff->yOff, createDefault);
}
HX_RESULT HXScheduler::ExecuteCurrentFunctions(HXBOOL bAtInterrupt)
{
HXBOOL bShouldServiceSystem = FALSE;
HXBOOL bShouldServiceInterrupt = FALSE;
HXBOOL bShouldServiceInterruptOnly = FALSE;
HXBOOL bImmediatesPending = FALSE;
HXBOOL bInterruptImmediatesPending = FALSE;
HXBOOL bInterruptOnlyImmediatesPending = FALSE;
HXBOOL bUpdateRet = UpdateCurrentTime(bAtInterrupt,
bShouldServiceSystem,
bShouldServiceInterrupt,
bShouldServiceInterruptOnly);
if (!bUpdateRet)
{
return HXR_OK;
}
/* if not at interrupt time, execute interrupt safe &
* non-interrupt safe tasks
*/
if (bShouldServiceInterrupt)
{
_Execute(m_pInterruptTimeScheduler, bInterruptImmediatesPending);
}
if (bShouldServiceInterruptOnly)
{
_Execute(m_pInterruptTimeOnlyScheduler, bInterruptOnlyImmediatesPending);
}
if (bShouldServiceSystem)
{
UINT32 ulElemsExecuted = _Execute(m_pScheduler, bImmediatesPending);
#if defined(_WIN32) || defined(THREADS_SUPPORTED)
if (ulElemsExecuted != 0)
{
HXBOOL bChange = FALSE;
if (m_pScheduler->empty())
{
if (m_ulCurrentGranularity < MINIMUM_GRANULARITY &&
(MINIMUM_GRANULARITY - m_ulCurrentGranularity >=
MINIMUM_DIFFERENCE))
{
bChange = TRUE;
m_ulCurrentGranularity = MINIMUM_GRANULARITY;
}
}
else if (m_ulCurrentGranularity > MINIMUM_DIFFERENCE)
{
Timeval timeout = m_pScheduler->head_time() - m_CurrentTimeVal;
INT32 lTimeoutInMs;
if (timeout.tv_sec >= 0)
{
lTimeoutInMs = timeout.tv_sec * 1000 +
timeout.tv_usec / 1000;
}
else
{
lTimeoutInMs = 0;
}
if (lTimeoutInMs > 0 &&
((UINT32) lTimeoutInMs) < m_ulCurrentGranularity &&
(m_ulCurrentGranularity - (UINT32) lTimeoutInMs >=
MINIMUM_DIFFERENCE))
{
bChange = TRUE;
m_ulCurrentGranularity = (UINT32) ((lTimeoutInMs >= MINIMUM_DIFFERENCE ? lTimeoutInMs: MINIMUM_DIFFERENCE));
}
}
if (bChange)
{
m_pTimeline->Pause();
/* Reset the granularity */
m_pTimeline->SetGranularity(m_ulCurrentGranularity);
/* Resume */
m_pTimeline->Resume();
}
}
#endif /*_WIN32*/
}
m_bImmediatesPending = (bImmediatesPending ||
bInterruptImmediatesPending ||
bInterruptOnlyImmediatesPending);
m_ulSystemNextDueTime = _GetNextDueTimeInMs(m_pScheduler);
m_ulInterruptNextDueTime = _GetNextDueTimeInMs(m_pInterruptTimeScheduler);
m_ulInterruptOnlyNextDueTime = _GetNextDueTimeInMs(m_pInterruptTimeOnlyScheduler);
return HXR_OK;
}
JBoolean
JXApplication::HandleOneEventForWindow
(
JXWindow* window,
const JBoolean origAllowSleep
)
{
const JBoolean origHadBlockingWindowFlag = itsHadBlockingWindowFlag;
itsHasBlockingWindowFlag = kJTrue;
itsHadBlockingWindowFlag = kJFalse; // req'd by JXWindow
if (itsIdleTaskStack->IsEmpty())
{
PushIdleTaskStack();
}
UpdateCurrentTime();
const JBoolean allowSleep =
JI2B(origAllowSleep && HandleCustomEventWhileBlocking());
UpdateCurrentTime();
JBoolean windowHasEvents = kJFalse;
const JXDisplay* uiDisplay = window->GetDisplay();
Window eventWindow [ kEventWindowCount ];
eventWindow[0] = window->GetXWindow();
JPtrArrayIterator<JXDisplay> iter(itsDisplayList);
JXDisplay* display;
JIndex displayIndex = 0;
while (iter.Next(&display))
{
JXMenuManager* menuMgr = display->GetMenuManager();
if (!origHadBlockingWindowFlag)
{
menuMgr->CloseCurrentMenus();
}
JXWindow* mouseContainer;
displayIndex++;
itsCurrDisplayIndex = displayIndex; // itsCurrDisplayIndex might change during event
if (XPending(*display) != 0)
{
// get mouse and keyboard grabbers -- for menus inside blocking window
eventWindow[1] = eventWindow[2] = None;
JXWindow* grabber;
if (display == uiDisplay && display->GetMouseGrabber(&grabber) &&
menuMgr->IsMenuForWindow(grabber, window))
{
eventWindow[1] = grabber->GetXWindow();
}
if (display == uiDisplay && display->GetKeyboardGrabber(&grabber) &&
menuMgr->IsMenuForWindow(grabber, window))
{
eventWindow[2] = grabber->GetXWindow();
}
// process one event
XEvent xEvent;
if (display == uiDisplay &&
XCheckIfEvent(*display, &xEvent, GetNextWindowEvent,
reinterpret_cast<char*>(eventWindow)))
{
windowHasEvents = kJTrue;
if (xEvent.type != MotionNotify)
{
itsLastIdleTime = itsCurrentTime;
}
display->HandleEvent(xEvent, itsCurrentTime);
}
else if (XCheckIfEvent(*display, &xEvent, GetNextBkgdEvent, NULL))
{
display->HandleEvent(xEvent, itsCurrentTime);
}
else if (display == uiDisplay &&
display->GetMouseContainer(&mouseContainer) &&
mouseContainer == window)
{
display->Idle(itsCurrentTime);
}
else
{
display->Update();
}
// discard mouse and keyboard events
DiscardEventInfo discardInfo(display, NULL);
if (display == uiDisplay)
{
discardInfo.eventWindow = eventWindow;
}
while (XCheckIfEvent(*display, &xEvent, DiscardNextEvent,
reinterpret_cast<char*>(&discardInfo)))
{ };
}
else if (display == uiDisplay &&
display->GetMouseContainer(&mouseContainer) &&
mouseContainer == window)
{
display->Idle(itsCurrentTime);
}
else
{
display->Update();
}
}
PerformTasks(windowHasEvents, allowSleep);
itsHasBlockingWindowFlag = kJFalse;
itsHadBlockingWindowFlag = kJTrue;
return windowHasEvents;
}
JBoolean
JXApplication::HandleOneBusyEvent
(
const JBoolean origAllowSleep
)
{
itsHadBlockingWindowFlag = kJFalse;
UpdateCurrentTime();
JBoolean cancelRequest = kJFalse;
JPtrArrayIterator<JXDisplay> iter(itsDisplayList);
JXDisplay* display;
JIndex displayIndex = 0;
while (iter.Next(&display))
{
displayIndex++;
itsCurrDisplayIndex = displayIndex; // itsCurrDisplayIndex might change during event
if (XPending(*display) != 0)
{
// look for update events
XEvent xEvent;
if (XCheckIfEvent(*display, &xEvent, GetNextBusyEvent, NULL))
{
display->HandleEvent(xEvent, itsCurrentTime);
}
// discard mouse and keyboard events
DiscardEventInfo discardInfo(display, NULL);
while (XCheckIfEvent(*display, &xEvent, DiscardNextEvent,
reinterpret_cast<char*>(&discardInfo)))
{
// Look for key press cancel
if (xEvent.type == KeyPress)
{
JCharacter buffer[10];
KeySym keySym;
JSize charCount =
XLookupString(const_cast<XKeyEvent*>(&(xEvent.xkey)), buffer, 10, &keySym, NULL);
if (keySym == XK_Escape)
{
cancelRequest = kJTrue;
}
}
}
}
{
// Do display idle but don't allow it to dispatch the mouse
// as we are likely to have the busy cursor currently displayed
JXWindow* container = NULL;
display->GetMouseContainer(&container);
display->SetMouseContainer(NULL);
display->Idle(itsCurrentTime);
display->SetMouseContainer(container);
}
}
// Perform permanent & urgent tasks
//PerformPermanentTasks();
//PerformUrgentTasks();
itsHadBlockingWindowFlag = kJTrue;
return cancelRequest;
}
JBoolean
JXApplication::HandleOneEventForWindow
(
JXWindow* window,
const JBoolean origAllowSleep,
const JBoolean do_tasks
)
{
const JBoolean origHadBlockingWindowFlag = itsHadBlockingWindowFlag;
itsHasBlockingWindowFlag = kJTrue;
itsHadBlockingWindowFlag = kJFalse; // req'd by JXWindow
if (itsIdleTaskStack->IsEmpty())
{
PushIdleTaskStack();
}
UpdateCurrentTime();
const JBoolean allowSleep =
JI2B(origAllowSleep && HandleCustomEventWhileBlocking());
UpdateCurrentTime();
JBoolean windowHasEvents = kJFalse;
const JXDisplay* uiDisplay = window->GetDisplay();
Window eventWindow [ kEventWindowCount ];
eventWindow[0] = window->GetXWindow();
JPtrArrayIterator<JXDisplay> iter(itsDisplayList);
JXDisplay* display;
JIndex displayIndex = 0;
while (iter.Next(&display))
{
JXMenuManager* menuMgr = display->GetMenuManager();
if (!origHadBlockingWindowFlag)
{
menuMgr->CloseCurrentMenus();
}
JXWindow* mouseContainer;
displayIndex++;
itsCurrDisplayIndex = displayIndex; // itsCurrDisplayIndex might change during event
if (XPending(*display) != 0)
{
// get mouse and keyboard grabbers -- for menus inside blocking window
eventWindow[1] = eventWindow[2] = None;
JXWindow* grabber;
if (display == uiDisplay && display->GetMouseGrabber(&grabber) &&
menuMgr->IsMenuForWindow(grabber, window))
{
eventWindow[1] = grabber->GetXWindow();
}
if (display == uiDisplay && display->GetKeyboardGrabber(&grabber) &&
menuMgr->IsMenuForWindow(grabber, window))
{
eventWindow[2] = grabber->GetXWindow();
}
// process one event
XEvent xEvent;
if (display == uiDisplay &&
XCheckIfEvent(*display, &xEvent, GetNextWindowEvent,
reinterpret_cast<char*>(eventWindow)))
{
windowHasEvents = kJTrue;
if (xEvent.type != MotionNotify)
{
itsLastIdleTime = itsCurrentTime;
}
display->HandleEvent(xEvent, itsCurrentTime);
}
#if 0
// cd: background event check is now done as part of window event check
// to give better update responsiveness when dragging a window
else if (XCheckIfEvent(*display, &xEvent, GetNextBkgdEvent, NULL))
{
display->HandleEvent(xEvent, itsCurrentTime);
}
#endif
else if (display == uiDisplay &&
display->GetMouseContainer(&mouseContainer) &&
mouseContainer == window)
{
display->Idle(itsCurrentTime);
}
else
{
display->Update();
}
// discard mouse and keyboard events
DiscardEventInfo discardInfo(display, NULL);
if (display == uiDisplay)
{
discardInfo.eventWindow = eventWindow;
}
while (XCheckIfEvent(*display, &xEvent, DiscardNextEvent,
reinterpret_cast<char*>(&discardInfo)))
{ };
}
else if (display == uiDisplay &&
display->GetMouseContainer(&mouseContainer) &&
mouseContainer == window)
{
display->Idle(itsCurrentTime);
}
else
{
display->Update();
}
}
// Perform idle tasks when we don't receive any events and
// during long intervals of "mouse moved".
if (do_tasks)
{
if (!windowHasEvents)
{
PerformPermanentTasks();
PerformIdleTasks();
itsLastIdleTime = itsCurrentTime;
PerformUrgentTasks();
if (allowSleep)
{
JWait(itsMaxSleepTime / 1000.0);
}
}
else if (windowHasEvents &&
itsCurrentTime - itsLastIdleTime > itsMaxSleepTime)
{
PerformPermanentTasks();
PerformIdleTasks();
itsLastIdleTime = itsCurrentTime;
PerformUrgentTasks();
}
else
{
PerformPermanentTasks();
PerformUrgentTasks();
}
}
itsHasBlockingWindowFlag = kJFalse;
itsHadBlockingWindowFlag = kJTrue;
return windowHasEvents;
}
int
ProcSetSelectionOwner(ClientPtr client)
{
WindowPtr pWin = NULL;
TimeStamp time;
Selection *pSel;
int rc;
REQUEST(xSetSelectionOwnerReq);
REQUEST_SIZE_MATCH(xSetSelectionOwnerReq);
UpdateCurrentTime();
time = ClientTimeToServerTime(stuff->time);
/* If the client's time stamp is in the future relative to the server's
time stamp, do not set the selection, just return success. */
if (CompareTimeStamps(time, currentTime) == LATER)
return Success;
if (stuff->window != None) {
rc = dixLookupWindow(&pWin, stuff->window, client, DixSetAttrAccess);
if (rc != Success)
return rc;
}
if (!ValidAtom(stuff->selection)) {
client->errorValue = stuff->selection;
return BadAtom;
}
/*
* First, see if the selection is already set...
*/
rc = dixLookupSelection(&pSel, stuff->selection, client, DixSetAttrAccess);
if (rc == Success) {
xEvent event;
/* If the timestamp in client's request is in the past relative
to the time stamp indicating the last time the owner of the
selection was set, do not set the selection, just return
success. */
if (CompareTimeStamps(time, pSel->lastTimeChanged) == EARLIER)
return Success;
if (pSel->client && (!pWin || (pSel->client != client)))
{
event.u.u.type = SelectionClear;
event.u.selectionClear.time = time.milliseconds;
event.u.selectionClear.window = pSel->window;
event.u.selectionClear.atom = pSel->selection;
TryClientEvents(pSel->client, NULL, &event, 1, NoEventMask,
NoEventMask /* CantBeFiltered */, NullGrab);
}
}
else if (rc == BadMatch)
{
/*
* It doesn't exist, so add it...
*/
pSel = xalloc(sizeof(Selection));
if (!pSel)
return BadAlloc;
pSel->selection = stuff->selection;
pSel->devPrivates = NULL;
/* security creation/labeling check */
rc = XaceHookSelectionAccess(client, &pSel,
DixCreateAccess|DixSetAttrAccess);
if (rc != Success) {
xfree(pSel);
return rc;
}
pSel->next = CurrentSelections;
CurrentSelections = pSel;
}
else
return rc;
pSel->lastTimeChanged = time;
pSel->window = stuff->window;
pSel->pWin = pWin;
pSel->client = (pWin ? client : NullClient);
CallSelectionCallback(pSel, client, SelectionSetOwner);
return client->noClientException;
}
static int
ProcShapeCombine(ClientPtr client)
{
WindowPtr pSrcWin, pDestWin;
REQUEST(xShapeCombineReq);
RegionPtr srcRgn;
RegionPtr *destRgn;
CreateDftPtr createDefault;
CreateDftPtr createSrc;
RegionPtr tmp;
int rc;
REQUEST_SIZE_MATCH(xShapeCombineReq);
UpdateCurrentTime();
rc = dixLookupWindow(&pDestWin, stuff->dest, client, DixSetAttrAccess);
if (rc != Success)
return rc;
if (!pDestWin->optional)
MakeWindowOptional(pDestWin);
switch (stuff->destKind) {
case ShapeBounding:
createDefault = CreateBoundingShape;
break;
case ShapeClip:
createDefault = CreateClipShape;
break;
case ShapeInput:
createDefault = CreateBoundingShape;
break;
default:
client->errorValue = stuff->destKind;
return BadValue;
}
rc = dixLookupWindow(&pSrcWin, stuff->src, client, DixGetAttrAccess);
if (rc != Success)
return rc;
switch (stuff->srcKind) {
case ShapeBounding:
srcRgn = wBoundingShape(pSrcWin);
createSrc = CreateBoundingShape;
break;
case ShapeClip:
srcRgn = wClipShape(pSrcWin);
createSrc = CreateClipShape;
break;
case ShapeInput:
srcRgn = wInputShape(pSrcWin);
createSrc = CreateBoundingShape;
break;
default:
client->errorValue = stuff->srcKind;
return BadValue;
}
if (pSrcWin->drawable.pScreen != pDestWin->drawable.pScreen) {
return BadMatch;
}
if (srcRgn) {
tmp = RegionCreate((BoxPtr) 0, 0);
RegionCopy(tmp, srcRgn);
srcRgn = tmp;
}
else
srcRgn = (*createSrc) (pSrcWin);
if (!pDestWin->optional)
MakeWindowOptional(pDestWin);
switch (stuff->destKind) {
case ShapeBounding:
destRgn = &pDestWin->optional->boundingShape;
break;
case ShapeClip:
destRgn = &pDestWin->optional->clipShape;
break;
case ShapeInput:
destRgn = &pDestWin->optional->inputShape;
break;
default:
return BadValue;
}
return RegionOperate(client, pDestWin, (int) stuff->destKind,
destRgn, srcRgn, (int) stuff->op,
stuff->xOff, stuff->yOff, createDefault);
}
void InitSoftwareSettings_NS8100(void)
{
INPUT_MSG_STRUCT mn_msg;
debug("Init Software Settings...\r\n");
//-------------------------------------------------------------------------
// Init version msg
//-------------------------------------------------------------------------
InitVersionMsg();
//-------------------------------------------------------------------------
// Init time msg and update current time
//-------------------------------------------------------------------------
InitTimeMsg();
UpdateCurrentTime();
//-------------------------------------------------------------------------
// Get the function address passed by the bootloader
//-------------------------------------------------------------------------
CheckBootloaderAppPresent(); debug("Bootloader check complete\r\n");
//-------------------------------------------------------------------------
// Load the Unit Config
//-------------------------------------------------------------------------
LoadUnitConfig(); debug("Loading Unit Config record\r\n");
//-------------------------------------------------------------------------
// Build the language table based on the user's last language choice
//-------------------------------------------------------------------------
BuildLanguageLinkTable(g_unitConfig.languageMode); debug("Language Tables built\r\n");
//-------------------------------------------------------------------------
// Initialize Unit Config items such as contrast, timers
//-------------------------------------------------------------------------
ActivateUnitConfigOptions(); debug("Activated Unit Config Options\r\n");
//-------------------------------------------------------------------------
// Display the Splash screen
//-------------------------------------------------------------------------
DisplaySplashScreen(); debug("Display Splash screen complete\r\n");
//-------------------------------------------------------------------------
// Wait at least 3 seconds for the main screen to be displayed
//-------------------------------------------------------------------------
debug("Three second delay for Splash screen\r\n");
SoftUsecWait(3 * SOFT_SECS);
//-------------------------------------------------------------------------
// Display Smart Sensor information if found
//-------------------------------------------------------------------------
DisplaySmartSensorInfo(INFO_ON_INIT);
//-------------------------------------------------------------------------
// Bootloader entry check
//-------------------------------------------------------------------------
BootloaderEntryCheck();
//-------------------------------------------------------------------------
// Load the Factory Setup Record
//-------------------------------------------------------------------------
LoadFactorySetupRecord(); debug("Factory setup record loaded\r\n");
//-------------------------------------------------------------------------
// Load Default Trigger Record
//-------------------------------------------------------------------------
LoadDefaultTriggerRecord(); debug("Default Trigger record loaded\r\n");
//-------------------------------------------------------------------------
// Load the Modem Setup Record
//-------------------------------------------------------------------------
LoadModemSetupRecord(); debug("Modem Setup record loaded\r\n");
//-------------------------------------------------------------------------
// Add OnOff Log Timestamp
//-------------------------------------------------------------------------
AddOnOffLogTimestamp(ON); debug("On/Off Log timestamp appended\r\n");
#if 0 // Removed debug log file due to inducing system problems
//-------------------------------------------------------------------------
// Switch Debug Log file
SwitchDebugLogFile();
#endif
//-------------------------------------------------------------------------
// Init Global Unique Event Number
//-------------------------------------------------------------------------
InitCurrentEventNumber(); debug("Current Event Number initialized\r\n");
//-------------------------------------------------------------------------
// Init AutoDialout
//-------------------------------------------------------------------------
InitAutoDialout(); debug("Auto Dialout initialized\r\n");
//-------------------------------------------------------------------------
// Init Monitor Log
//-------------------------------------------------------------------------
InitMonitorLog(); debug("Monitor Log initialized\r\n");
//-------------------------------------------------------------------------
// Init the Sensor Parameters
//-------------------------------------------------------------------------
InitSensorParameters(g_factorySetupRecord.seismicSensorType, (uint8)g_triggerRecord.srec.sensitivity); debug("Sensor Parameters initialized\r\n");
//-------------------------------------------------------------------------
// Init the Summary List file
//-------------------------------------------------------------------------
ManageEventsDirectory();
InitSummaryListFile(); debug("Summary List initialized\r\n");
//-------------------------------------------------------------------------
// Update Flash Usage Stats
//-------------------------------------------------------------------------
OverlayMessage(getLangText(STATUS_TEXT), getLangText(CALCULATING_EVENT_STORAGE_SPACE_FREE_TEXT), 0);
GetSDCardUsageStats(); debug("Flash Usage Stats updated (Cluster size: %d bytes)\r\n", g_sdCardUsageStats.clusterSizeInBytes);
//-------------------------------------------------------------------------
// Check for Timer mode activation
//-------------------------------------------------------------------------
if (TimerModeActiveCheck() == TRUE)
{
debug("--- Timer Mode Startup ---\r\n");
ProcessTimerMode();
}
else // Normal startup
{
debug("--- Normal Startup ---\r\n");
}
//-------------------------------------------------------------------------
// Init the cmd message handling buffers before initialization of the ports.
//-------------------------------------------------------------------------
RemoteCmdMessageHandlerInit(); debug("Craft Message Handler initialized\r\n");
//-------------------------------------------------------------------------
// Init the input buffers and status flags for input craft data.
//-------------------------------------------------------------------------
CraftInitStatusFlags(); debug("Craft Status flags initilaized\r\n");
//-------------------------------------------------------------------------
// Signal remote end that RS232 Comm is available
//-------------------------------------------------------------------------
SET_RTS; SET_DTR; debug("Craft RTS and DTR enabled\r\n");
//-------------------------------------------------------------------------
// Reset LCD timers
//-------------------------------------------------------------------------
ResetSoftTimer(LCD_BACKLIGHT_ON_OFF_TIMER_NUM);
ResetSoftTimer(LCD_POWER_ON_OFF_TIMER_NUM);
//-------------------------------------------------------------------------
// Turn on the Green keypad LED when system init complete
//-------------------------------------------------------------------------
debug("Init complete, turning Kepypad LED Green...\r\n");
WriteMcp23018(IO_ADDRESS_KPD, GPIOA, ((ReadMcp23018(IO_ADDRESS_KPD, GPIOA) & 0xCF) | GREEN_LED_PIN));
//-------------------------------------------------------------------------
// Assign a one second keypad led update timer
//-------------------------------------------------------------------------
AssignSoftTimer(KEYPAD_LED_TIMER_NUM, ONE_SECOND_TIMEOUT, KeypadLedUpdateTimerCallBack); debug("Keypad LED Timer initialized\r\n");
//-------------------------------------------------------------------------
// Jump to the true main menu
//-------------------------------------------------------------------------
debug("Jumping to Main Menu\r\n");
SETUP_MENU_MSG(MAIN_MENU);
JUMP_TO_ACTIVE_MENU();
//-------------------------------------------------------------------------
// Enable Craft input (delayed to prevent serial input from locking unit)
//-------------------------------------------------------------------------
InitCraftInterruptBuffers();
Setup_8100_Usart1_RS232_ISR();
if (GET_HARDWARE_ID == HARDWARE_ID_REV_8_WITH_GPS_MOD)
{
EnableGps();
}
//-------------------------------------------------------------------------
// Enable keypad key input (delayed to prevent key input from locking unit)
//-------------------------------------------------------------------------
EnableMcp23018Interrupts(); debug("Mcp23018 interrupts enabled\r\n");
//-------------------------------------------------------------------------
// Display last line of system init
//-------------------------------------------------------------------------
DisplayVersionToDebug();
}
FileFilter::FileFilter(Panel *HostPanel, FAR_FILE_FILTER_TYPE FilterType):
m_HostPanel(HostPanel),
m_FilterType(FilterType)
{
UpdateCurrentTime();
}
void
JXApplication::HandleOneEvent()
{
itsHadBlockingWindowFlag = kJFalse;
UpdateCurrentTime();
const JBoolean allowSleep = HandleCustomEvent();
UpdateCurrentTime();
JBoolean hasEvents = kJFalse;
JPtrArrayIterator<JXDisplay> iter(itsDisplayList);
JXDisplay* display;
JIndex displayIndex = 0;
while (iter.Next(&display))
{
displayIndex++;
itsCurrDisplayIndex = displayIndex; // itsCurrDisplayIndex might change during event
if (XPending(*display) != 0)
{
hasEvents = kJTrue;
// get the next event
XEvent xEvent;
XNextEvent(*display, &xEvent);
if (xEvent.type != MotionNotify)
{
itsLastIdleTime = itsCurrentTime;
}
// dispatch the event
display->HandleEvent(xEvent, itsCurrentTime);
}
else
{
display->Idle(itsCurrentTime);
}
}
PopAllIdleTaskStack();
// Perform idle tasks when we don't receive any events and
// during long intervals of "mouse moved".
if (!hasEvents)
{
PerformPermanentTasks();
PerformIdleTasks();
itsLastIdleTime = itsCurrentTime;
PerformUrgentTasks();
if (allowSleep)
{
JWait(itsMaxSleepTime / 1000.0);
}
}
else if (hasEvents &&
itsCurrentTime - itsLastIdleTime > itsMaxSleepTime)
{
PerformPermanentTasks();
PerformIdleTasks();
itsLastIdleTime = itsCurrentTime;
PerformUrgentTasks();
}
else
{
PerformPermanentTasks();
PerformUrgentTasks();
}
}