void xINCDayTime :: addSecondsTest (void)
{
TEST_METHOD(addSeconds, 60, 1., 1e-12);
TEST_METHOD(addSeconds, 3600, 1., 1e-12);
TEST_METHOD(addSeconds, 86400, 1., 1e-12);
TEST_METHOD(addSeconds, 7*86400, 1., 1e-12);
cout << endl;
TEST_METHOD(addSeconds, 1000, 1e-3, 1e-12);
TEST_METHOD(addSeconds, 60*1000, 1e-3, 1e-12);
TEST_METHOD(addSeconds, 3600*1000, 1e-3, 1e-12);
TEST_METHOD(addSeconds, 86400*1000, 1e-3, 1e-12);
TEST_METHOD(addSeconds, 86400*2*1000, 1e-3, 1e-12);
TEST_METHOD(addSeconds, 86400*7*1000, 1e-3, 1e-12);
cout << endl;
TEST_METHOD(addSeconds, 1000*1000, 1e-6, 1e-12);
TEST_METHOD(addSeconds, 60*1000*1000, 1e-6, 1e-12);
TEST_METHOD(addSeconds, 5*60*1000*1000, 1e-6, 1e-12);
cout << endl;
TEST_METHOD(addSeconds, (1000*1000), 1e-9, 1e-12);
TEST_METHOD(addSeconds, (100*1000*1000), 1e-9, 1e-12);
cout << endl;
TEST_METHOD(addSeconds, (1000*1000), 1e-11, 1e-12);
TEST_METHOD(addSeconds, (100*1000*1000), 1e-11, 1e-12);
cout << endl;
FinishUp();
}
int XDPSCheckImagingResults(
DPSContext context,
Screen *screen)
{
StatusInfo *info = StatusList;
int status;
if (context == NULL) {
context = XDPSGetSharedContext(DisplayOfScreen(screen));
if (context == NULL) return dps_status_no_extension;
}
while (info != NULL && info->ctxt != context) info = info->next;
if (info == NULL) return dps_status_illegal_value;
status = XDPSGetContextStatus(context);
if (status != PSFROZEN) return dps_status_imaging_incomplete;
XDPSUnfreezeContext(context);
return FinishUp(context, info->cookie);
}
int runtime()
{
justevaled=false;
if(peakCount>9 && running)
{
running = false;
FinishUp();
return 1;
}
if(timer1(T1)<sampleTime) return false;
clearTimer(T1);
double refVal = input;
justevaled=true;
if(!running)
{ //initialize working variables the first time around
peakType = 0;
peakCount=0;
justchanged=false;
absMax=refVal;
absMin=refVal;
setpoint = refVal;
running = true;
outputStart = output;
output = outputStart+oStep;
}
else
{
if(refVal>absMax)absMax=refVal;
if(refVal<absMin)absMin=refVal;
}
//oscillate the output base on the input's relation to the setpoint
if(refVal>setpoint+noiseBand) *output = outputStart-oStep;
else if (refVal<setpoint-noiseBand) *output = outputStart+oStep;
//bool isMax=true, isMin=true;
isMax=true;isMin=true;
//id peaks
for(int i=nLookBack-1;i>=0;i--)
{
double val = lastInputs[i];
if(isMax) isMax = refVal>val;
if(isMin) isMin = refVal<val;
lastInputs[i+1] = lastInputs[i];
}
lastInputs[0] = refVal;
if(nLookBack<9)
{ //we don't want to trust the maxes or mins until the inputs array has been filled
return 0;
}
if(isMax)
{
if(peakType==0)peakType=1;
if(peakType==-1)
{
peakType = 1;
justchanged=true;
peak2 = peak1;
}
peak1 = now;
peaks[peakCount] = refVal;
}
else if(isMin)
{
if(peakType==0)peakType=-1;
if(peakType==1)
{
peakType=-1;
peakCount++;
justchanged=true;
}
if(peakCount<10)peaks[peakCount] = refVal;
}
if(justchanged && peakCount>2)
{ //we've transitioned. check if we can autotune based on the last peaks
double avgSeparation = (abs(peaks[peakCount-1]-peaks[peakCount-2])+abs(peaks[peakCount-2]-peaks[peakCount-3]))/2;
if( avgSeparation < 0.05*(absMax-absMin))
{
FinishUp();
running = false;
return 1;
}
}
justchanged=false;
return 0;
}
int CDb3Mmap::WorkEventChain(DWORD ofsContact, DBContact *dbc, int firstTime)
{
int isUnread = 0;
if (firstTime) {
dbePrevEvent = NULL;
ofsPrevEvent = 0;
ofsDestPrevEvent = 0;
ofsThisEvent = dbc->ofsFirstEvent;
eventCount = 0;
backLookup = 0;
lastTimestamp = 0;
ofsFirstUnread = tsFirstUnread = 0;
if (cb->bEraseHistory) {
dbc->eventCount = 0;
dbc->ofsFirstEvent = 0;
dbc->ofsLastEvent = 0;
dbc->ofsFirstUnread = 0;
dbc->tsFirstUnread = 0;
return ERROR_NO_MORE_ITEMS;
}
}
if (ofsThisEvent == 0) {
FinishUp(ofsDestPrevEvent, dbc);
return ERROR_NO_MORE_ITEMS;
}
DBEvent dbeOld;
if (!SignatureValid(ofsThisEvent, DBEVENT_SIGNATURE)) {
DWORD ofsNew = 0;
DWORD ofsTmp = dbc->ofsLastEvent;
if (!backLookup && ofsTmp) {
backLookup = 1;
while (SignatureValid(ofsTmp, DBEVENT_SIGNATURE)) {
if (PeekEvent(ofsTmp, dbc->dwContactID, dbeOld) != ERROR_SUCCESS)
break;
ofsNew = ofsTmp;
ofsTmp = dbeOld.ofsPrev;
}
}
if (ofsNew) {
cb->pfnAddLogMessage(STATUS_WARNING, TranslateT("Event chain corrupted, trying to recover..."));
ofsThisEvent = ofsNew;
}
else {
cb->pfnAddLogMessage(STATUS_ERROR, TranslateT("Event chain corrupted, further entries ignored"));
FinishUp(ofsDestPrevEvent, dbc);
return ERROR_NO_MORE_ITEMS;
}
}
if (PeekEvent(ofsThisEvent, dbc->dwContactID, dbeOld) != ERROR_SUCCESS) {
FinishUp(ofsDestPrevEvent, dbc);
return ERROR_NO_MORE_ITEMS;
}
if (firstTime) {
if (dbeOld.ofsPrev != 0)
cb->pfnAddLogMessage(STATUS_WARNING, TranslateT("First event not marked as such: correcting"));
dbeOld.ofsPrev = 0;
lastTimestamp = dbeOld.timestamp;
}
if (dbeOld.flags & 1)
dbeOld.flags &= ~1;
if (dbeOld.flags & ~DBEF_ALL) {
cb->pfnAddLogMessage(STATUS_WARNING, TranslateT("Extra flags found in event: removing"));
dbeOld.flags &= DBEF_ALL;
}
if (!(dbeOld.flags & (DBEF_READ | DBEF_SENT))) {
if (cb->bMarkRead) dbeOld.flags |= DBEF_READ;
else if (ofsFirstUnread == 0) {
if (dbc->ofsFirstUnread != ofsThisEvent || dbc->tsFirstUnread != dbeOld.timestamp)
cb->pfnAddLogMessage(STATUS_WARNING, TranslateT("First unread event marked wrong: fixing"));
isUnread = 1;
}
}
if (dbeOld.cbBlob > 1024 * 1024 || dbeOld.cbBlob == 0) {
cb->pfnAddLogMessage(STATUS_ERROR, TranslateT("Infeasibly large event blob: skipping"));
ofsThisEvent = dbeOld.ofsNext;
return ERROR_SUCCESS;
}
DBEvent *dbePrev = NULL;
if (dbePrevEvent && dbeOld.timestamp == lastTimestamp) {
int len = offsetof(DBEvent, blob) + dbePrevEvent->cbBlob;
dbePrev = (DBEvent*)malloc(len);
memcpy(dbePrev, dbePrevEvent, len);
}
if (offsetof(DBEvent, blob) + dbeOld.cbBlob > memsize) {
memsize = offsetof(DBEvent, blob) + dbeOld.cbBlob;
memblock = (DBEvent*)realloc(memblock, memsize);
}
DBEvent *dbeNew = memblock;
DWORD ret;
if (m_dbHeader.version < DB_095_1_VERSION) {
DBEvent_094 oldEvent;
ret = ReadSegment(ofsThisEvent, &oldEvent, offsetof(DBEvent_094, blob));
if (ret == ERROR_SUCCESS) {
dbeNew->signature = oldEvent.signature;
dbeNew->contactID = dbc->dwContactID;
memcpy(&dbeNew->ofsPrev, &oldEvent.ofsPrev, offsetof(DBEvent_094, blob) - sizeof(DWORD));
ret = ReadSegment(ofsThisEvent + offsetof(DBEvent_094, blob), &dbeNew->blob, dbeOld.cbBlob);
}
}
else ret = ReadSegment(ofsThisEvent, dbeNew, offsetof(DBEvent, blob) + dbeOld.cbBlob);
if (ret != ERROR_SUCCESS) {
FinishUp(ofsDestPrevEvent, dbc);
return ERROR_NO_MORE_ITEMS;
}
if ((dbeNew->ofsModuleName = ConvertModuleNameOfs(dbeOld.ofsModuleName)) == 0) {
ofsThisEvent = dbeOld.ofsNext;
return ERROR_SUCCESS;
}
if (!firstTime && dbeOld.ofsPrev != ofsPrevEvent)
cb->pfnAddLogMessage(STATUS_WARNING, TranslateT("Event not backlinked correctly: fixing"));
dbeNew->flags = dbeOld.flags;
dbeNew->ofsPrev = ofsDestPrevEvent;
dbeNew->ofsNext = 0;
if (dbeNew->contactID == 0)
dbeNew->contactID = dbc->dwContactID;
if (dbeOld.wEventType == EVENTTYPE_MESSAGE && cb->bConvertUtf && !(dbeOld.flags & DBEF_ENCRYPTED))
ConvertOldEvent(dbeNew);
if (dbePrev) {
if (dbePrev->cbBlob == dbeNew->cbBlob &&
dbePrev->ofsModuleName == dbeNew->ofsModuleName &&
dbePrev->wEventType == dbeNew->wEventType &&
(dbePrev->flags & DBEF_SENT) == (dbeNew->flags & DBEF_SENT) && !memcmp(dbePrev->blob, dbeNew->blob, dbeNew->cbBlob))
{
cb->pfnAddLogMessage(STATUS_WARNING, TranslateT("Duplicate event was found: skipping"));
if (dbc->eventCount)
dbc->eventCount--;
free(dbePrev);
// ofsDestPrevEvent is still the same!
ofsPrevEvent = ofsThisEvent;
ofsThisEvent = dbeOld.ofsNext;
return ERROR_SUCCESS;
}
free(dbePrev);
}
else if (!firstTime && dbeNew->timestamp < lastTimestamp) {
DWORD found = 0;
DBEvent dbeTmp = { 0 };
DWORD ofsTmp = 0;
if (cb->bCheckOnly) {
if (!cb->bAggressive) {
ofsTmp = dbeOld.ofsPrev;
while (PeekEvent(ofsTmp, dbc->dwContactID, dbeTmp) == ERROR_SUCCESS) {
if (dbeTmp.ofsPrev == ofsContact) {
found = 1;
break;
}
if (dbeTmp.timestamp < dbeNew->timestamp) {
found = 2;
break;
}
ofsTmp = dbeTmp.ofsPrev;
}
}
cb->pfnAddLogMessage(STATUS_WARNING, TranslateT("Event position in chain is not correct"));
}
else {
ofsTmp = ofsDestPrevEvent;
while (ReadWrittenSegment(ofsTmp, &dbeTmp, sizeof(dbeTmp)) == ERROR_SUCCESS) {
if (dbeTmp.ofsPrev == ofsContact) {
found = 1;
break;
}
if (dbeTmp.timestamp < dbeNew->timestamp) {
found = 2;
break;
}
ofsTmp = dbeTmp.ofsPrev;
}
if (found)
cb->pfnAddLogMessage(STATUS_WARNING, TranslateT("Event position in chain is not correct: fixing"));
else
cb->pfnAddLogMessage(STATUS_WARNING, TranslateT("Event position in chain is not correct: unable to fix"));
}
// insert before FIRST
if (found == 1 && !cb->bCheckOnly) {
dbeNew->ofsPrev = 0;
dbeNew->ofsNext = dbc->ofsFirstEvent;
DWORD ofsDestThis = WriteEvent(dbeNew);
if (!ofsDestThis)
return ERROR_HANDLE_DISK_FULL;
if (isUnread && tsFirstUnread >= dbeNew->timestamp) {
ofsFirstUnread = ofsDestThis;
tsFirstUnread = dbeNew->timestamp;
}
// fix first event
WriteOfsNextToPrevious(0, dbc, ofsDestThis);
// fix next event
WriteSegment(dbeNew->ofsNext + offsetof(DBEvent, ofsPrev), &ofsDestThis, sizeof(DWORD));
}
else if (found == 2 && !cb->bCheckOnly) {
dbeNew->ofsPrev = ofsTmp;
dbeNew->ofsNext = dbeTmp.ofsNext;
DWORD ofsDestThis = WriteEvent(dbeNew);
if (!ofsDestThis)
return ERROR_HANDLE_DISK_FULL;
if (isUnread && tsFirstUnread >= dbeNew->timestamp) {
ofsFirstUnread = ofsDestThis;
tsFirstUnread = dbeNew->timestamp;
}
// fix previous event
WriteOfsNextToPrevious(dbeNew->ofsPrev, dbc, ofsDestThis);
// fix next event
WriteSegment(dbeNew->ofsNext + offsetof(DBEvent, ofsPrev), &ofsDestThis, sizeof(DWORD));
}
if (found) {
eventCount++;
// ofsDestPrevEvent is still the same!
ofsPrevEvent = ofsThisEvent;
ofsThisEvent = dbeOld.ofsNext;
return ERROR_SUCCESS;
}
}
lastTimestamp = dbeNew->timestamp;
dbePrevEvent = dbeNew;
DWORD ofsDestThis = WriteEvent(dbeNew);
if (!ofsDestThis)
return ERROR_HANDLE_DISK_FULL;
if (isUnread) {
ofsFirstUnread = ofsDestThis;
tsFirstUnread = dbeOld.timestamp;
}
eventCount++;
WriteOfsNextToPrevious(ofsDestPrevEvent, dbc, ofsDestThis);
ofsDestPrevEvent = ofsDestThis;
ofsPrevEvent = ofsThisEvent;
ofsThisEvent = dbeOld.ofsNext;
return ERROR_SUCCESS;
}
int WorkContactChain(int firstTime)
{
int first=0;
if(firstTime) {
AddToStatus(STATUS_MESSAGE,TranslateT("Processing contact chain"));
ofsDestPrevContact=0;
ofsThisContact=dbhdr.ofsFirstContact;
contactCount=0;
dbhdr.ofsFirstContact=0;
phase=0;
}
switch(phase) {
int ret;
case 0:
if(ofsThisContact==0) {
FinishUp();
return ERROR_NO_MORE_ITEMS;
}
if(!SignatureValid(ofsThisContact,DBCONTACT_SIGNATURE)) {
AddToStatus(STATUS_ERROR,TranslateT("Contact chain corrupted, further entries ignored"));
FinishUp();
return ERROR_NO_MORE_ITEMS;
}
if(ReadSegment(ofsThisContact,&dbc,sizeof(dbc))!=ERROR_SUCCESS) {
FinishUp();
return ERROR_NO_MORE_ITEMS;
}
ofsNextContact=dbc.ofsNext;
dbc.ofsNext=0;
if (!opts.bCheckOnly) {
if((ofsDestThis=WriteSegment(WSOFS_END,&dbc,sizeof(dbc)))==WS_ERROR)
return ERROR_HANDLE_DISK_FULL;
if(ofsDestPrevContact)
WriteSegment(ofsDestPrevContact+offsetof(DBContact,ofsNext),&ofsDestThis,sizeof(DWORD));
else
dbhdr.ofsFirstContact=ofsDestThis;
} else
ofsDestThis = ofsThisContact; // needed in event chain worker
contactCount++;
phase++; first=1;
//fall thru
case 1:
ret=WorkSettingsChain(ofsDestThis,&dbc,first);
if(ret==ERROR_NO_MORE_ITEMS) {
phase++; first=1;
}
else if(ret) return ret;
else break;
//fall thru
case 2:
ret=WorkEventChain(ofsDestThis,&dbc,first);
if(ret==ERROR_NO_MORE_ITEMS) {
phase++; first=1;
}
else if(ret) return ret;
else break;
//fall thru
case 3:
if(WriteSegment(ofsDestThis,&dbc,sizeof(DBContact))==WS_ERROR)
return ERROR_HANDLE_DISK_FULL;
ofsDestPrevContact=ofsDestThis;
ofsThisContact=ofsNextContact;
phase=0;
break;
}
return ERROR_SUCCESS;
}
int XDPSImageFileIntoDrawable(
DPSContext context,
Screen *screen,
Drawable dest,
FILE *file,
int drawableHeight,
int drawableDepth,
XRectangle *bbox,
int xOffset, int yOffset,
double pixelsPerPoint,
Bool clear, Bool createMask,
Bool waitForCompletion,
Bool *doneFlag)
{
#define BUFSIZE 256
#define EXECLEN 6
char buf[BUFSIZE];
static char eobuf[] = "\n$Adobe$DPS$Lib$Dict /execSuccess true put\n\
stop\n\
Magic end of data line )))))))))) 99#2 2#99 <xyz> // 7gsad,32h4ghNmndFgj2\n";
XDPSStandardColormap maskMap;
XDPSStandardColormap rgbMap;
unsigned int flags = 0;
int status;
Bool inited;
DPSPointer cookie;
int doublings;
int ms;
XDPSStatusProc oldProc;
unsigned long startReqNum = 0, endReqNum;
if (screen == NULL || dest == None ||
drawableHeight <= 0 || drawableDepth <= 0 ||
pixelsPerPoint <= 0) {
return dps_status_illegal_value;
}
if (context == NULL) {
context = XDPSGetSharedContext(DisplayOfScreen(screen));
if (context == NULL) {
FillPixmapWithGray(screen, dest, bbox, xOffset, yOffset,
pixelsPerPoint,
createMask);
return dps_status_no_extension;
}
}
(*rewindFunction)(file, rewindClientData);
if (!waitForCompletion) {
DPSWaitContext(context);
/* Any status events before this point go to old handler */
startReqNum = NextRequest(DisplayOfScreen(screen));
}
status = _XDPSTestComponentInitialized(context,
dps_init_bit_preview, &inited);
if (status != dps_status_success) return status;
if (!inited) {
(void) _XDPSSetComponentInitialized(context, dps_init_bit_preview);
_DPSPDefineExecFunction(context);
}
if (createMask) {
if (drawableDepth != 1) return dps_status_illegal_value;
maskMap.colormap = None;
maskMap.red_max = 1;
maskMap.red_mult = -1;
maskMap.base_pixel = 1;
rgbMap.colormap = None;
rgbMap.red_max = rgbMap.green_max = rgbMap.blue_max =
rgbMap.red_mult = rgbMap.green_mult = rgbMap.blue_mult =
rgbMap.base_pixel = 0;
flags = XDPSContextGrayMap | XDPSContextRGBMap;
}
status = XDPSPushContextParameters(context, screen, drawableDepth,
dest, drawableHeight,
&rgbMap, &maskMap,
flags | XDPSContextScreenDepth |
XDPSContextDrawable, &cookie);
if (status != dps_status_success) return status;
_DPSPSetMatrix(context, xOffset, yOffset, pixelsPerPoint);
if (clear) _DPSPClearArea(context, (int) bbox->x, (int) bbox->y,
(int) bbox->width, (int) bbox->height);
if (createMask) _DPSPSetMaskTransfer(context);
/* Prepare to read PostScript code */
_DPSPSaveBeforeExec(context, !waitForCompletion);
DPSWritePostScript(context, "\nexec\n", EXECLEN);
imaging = True;
while ((*getsFunction)(buf, BUFSIZE, file, getsClientData) != NULL) {
DPSWritePostScript(context, buf, strlen(buf));
}
imaging = False;
/* This marks the end of the data stream */
DPSWritePostScript(context, eobuf, strlen(eobuf));
if (!waitForCompletion) {
*doneFlag = False;
oldProc = XDPSRegisterStatusProc(context, HandlePreviewStatus);
SetUpStatusVariables(context, cookie, doneFlag, startReqNum, oldProc);
XDPSSetStatusMask(context, 0, 0, PSFROZENMASK);
ms = timeStart;
/* Check for done until we run out of time */
doublings = 0;
while (1) {
if (XDPSGetContextStatus(context) == PSFROZEN) {
waitForCompletion = True;
XDPSUnfreezeContext(context);
break;
}
if (doublings >= maxDoubles) break;
/* Wait a while */
msleep(ms);
ms *= 2;
doublings++;
}
}
/* If previous decided imaging is done, it changed waitForCompletion */
if (waitForCompletion) return FinishUp(context, cookie);
else {
endReqNum = NextRequest(DisplayOfScreen(screen)) - 1;
SetEndReqNum(context, endReqNum);
return dps_status_imaging_incomplete;
}
#undef EXECLEN
#undef BUFSIZE
}
