BOOL GRPFILE_WriteGroupFile(HLOCAL hGroup)
{
CHAR szPath[MAX_PATHNAME_LEN];
PROGGROUP *group = LocalLock(hGroup);
OFSTRUCT dummy;
HFILE file;
BOOL ret;
GRPFILE_ModifyFileName(szPath, LocalLock(group->hGrpFile),
MAX_PATHNAME_LEN,
group->bFileNameModified);
/* Try not to overwrite original files */
/* group->bOverwriteFileOk == TRUE only if a file has the modified format */
if (!group->bOverwriteFileOk &&
OpenFile(szPath, &dummy, OF_EXIST) != HFILE_ERROR)
{
/* Original file exists, try `.gr' extension */
GRPFILE_ModifyFileName(szPath, LocalLock(group->hGrpFile),
MAX_PATHNAME_LEN, TRUE);
if (OpenFile(szPath, &dummy, OF_EXIST) != HFILE_ERROR)
{
/* File exists. Do not overwrite */
MAIN_MessageBoxIDS_s(IDS_FILE_NOT_OVERWRITTEN_s, szPath,
IDS_INFO, MB_OK);
return FALSE;
}
/* Inform about the modified file name */
if (IDCANCEL ==
MAIN_MessageBoxIDS_s(IDS_SAVE_GROUP_AS_s, szPath, IDS_INFO,
MB_OKCANCEL | MB_ICONINFORMATION))
return FALSE;
}
{
/* Warn about the (possible) incompatibility */
CHAR msg[MAX_PATHNAME_LEN + 200];
wsprintf(msg,
"Group files written by this DRAFT Program Manager "
"possibly cannot be read by the Microsoft Program Manager!!\n"
"Are you sure to write %s?", szPath);
if (IDOK != MessageBox(Globals.hMainWnd, msg, "WARNING",
MB_OKCANCEL | MB_DEFBUTTON2)) return FALSE;
}
/* Open file */
file = _lcreat(szPath, 0);
if (file != HFILE_ERROR)
{
ret = GRPFILE_DoWriteGroupFile(file, group);
_lclose(file);
}
else ret = FALSE;
if (!ret)
MAIN_MessageBoxIDS_s(IDS_FILE_WRITE_ERROR_s, szPath, IDS_ERROR, MB_OK);
return(ret);
}
VOID AutoTest(void){
static OPENFILENAME ofn;
static char szFilename[80];
char szT[80];
int i, hfile;
Sleep (5000);
gfAll = TRUE;
for (gibmi = 0; gibmi < gcbmi; gibmi++) {
gabmi[gibmi].pfnBenchmark(gabmi[gibmi].cIterations);
}
hfile = _lopen("usrbench.out", OF_READWRITE); //try to open file
if (hfile == -1){
hfile = _lcreat("usrbench.out", 0); //create it if it does not exist
if (hfile == -1)
return;
}
else
_llseek(hfile, 0L, 2); // go to end of file for append
WriteResults(hfile);
_lclose(hfile);
}
int tifwrt(
LPSTR lpFileName,
LPOBJECT lpObject,
LPFRAME lpFrame,
LPRECT lpRect,
int flag,
BOOL fCompressed)
{
int iRet;
int ofp;
BOOL bEscapable;
bEscapable = !FileExists(lpFileName);
if ((ofp = _lcreat(lpFileName,0)) < 0)
{
Message( IDS_EWRITE, lpFileName );
return(-1);
}
iRet = TiffWriteFrame(
ofp, lpFileName, lpObject, lpFrame,
lpRect, flag, fCompressed, bEscapable);
_lclose(ofp);
return(iRet);
}
BOOL My__lcreat()
{
LPCSTR lpPathName=NULL;
int iAttribute=NULL;
HFILE returnVal_Real = NULL;
HFILE returnVal_Intercepted = NULL;
DWORD error_Real = 0;
DWORD error_Intercepted = 0;
disableInterception();
returnVal_Real = _lcreat (lpPathName,iAttribute);
error_Real = GetLastError();
enableInterception();
returnVal_Intercepted = _lcreat (lpPathName,iAttribute);
error_Intercepted = GetLastError();
return ((returnVal_Real == returnVal_Intercepted) && (error_Real == error_Intercepted));
}
static BOOL WriteDIB(
/************************************************************************/
LPBITMAPINFOHEADER lpInfo,
LPSTR lpImageFile)
{
DWORD lCount;
WORD wCount;
HPTR lpClipPtr;
BITMAPFILEHEADER bmhdr;
int ofh;
bmhdr.bfType = 0x4D42;
bmhdr.bfReserved1 = 0;
bmhdr.bfReserved2 = 0;
bmhdr.bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER);
if (lpInfo->biBitCount == 8)
bmhdr.bfOffBits += ( 256 * sizeof(RGBQUAD) );
else
if (lpInfo->biBitCount == 4)
bmhdr.bfOffBits += ( 16 * sizeof(RGBQUAD) );
else
if (lpInfo->biBitCount == 1)
bmhdr.bfOffBits += ( 2 * sizeof(RGBQUAD) );
lCount = bmhdr.bfOffBits + lpInfo->biSizeImage;
bmhdr.bfSize = lCount/2;
// write the winclip.bmp file
if ( (ofh = _lcreat( lpImageFile, 0 )) < 0 )
{
Message (IDS_EOPEN, lpImageFile);
return(FALSE);
}
if ( _lwrite( ofh, (LPSTR)&bmhdr, 14 ) != 14 )
{
Message (IDS_EWRITE, lpImageFile);
_lclose(ofh);
return(FALSE);
}
lCount -= 14;
lpClipPtr = (HPTR)lpInfo;
while( lCount > 0L )
{
wCount = ( ( lCount > 65535L ) ? 65535 : lCount );
if ( _lwrite( ofh, (LPSTR)lpClipPtr, wCount ) != wCount )
{
Message( IDS_EWRITE, lpImageFile );
_lclose(ofh);
return(FALSE);
}
lpClipPtr += wCount;
lCount -= wCount;
}
_lclose(ofh);
return(TRUE);
}
bool CFile::Create(void)
{
m_hFile = _lcreat(m_Path, 0);
// Error?
if (m_hFile == HFILE_ERROR)
return FALSE;
return TRUE;
}
bool CIdentsDBExtension::ExportDataSourceAsXml (LPUNKNOWN pIUnk, HPROJECT hPr, LPCSTR pFName, ULONG &rulCnt)
{
if (pIUnk) LPPROGRESSINDICATOR(pIUnk) -> ChangeText (PIFLAG_FILENAME, pFName);
// Datei bilden, wenn diese noch nicht existiert
int fh = _lcreat (pFName, 0);
if (fh < 0) return false;
bool fRet = false;
{
// hier geht's los
CXMLDocument Doc (fh); // <?xml ...?>
char cbBuffer[80]; // TRiAS Version, aktuelle Zeit
os_time_and_date now;
string resVersion (g_cbTRiAS);
ResString resTempl (IDS_SIGNONVERSION_MODAL, _MAX_PATH);
resVersion += ": ";
resVersion += resTempl;
ATLTRY(now = os_time_and_date::now());
strcpy (cbBuffer, resVersion.c_str());
strcat (cbBuffer, now.to_string(" %e. %B %Y, %T").c_str());
CXMLComment (fh, cbBuffer);
CXMLComment (fh, ResString (IDS_COPYRIGHT, 100)); // allgemeines Copyright
// DTD einfügen
CXMLRawData (fh, s_cbDTD);
// die eigentlichen Infos ausgeben
CXMLAttribute Attr ("Version", "1.0");
CXMLNode MainNode (fh, g_cbTRiASMetadata, Attr);
ENUMLONGKEY ELK;
EXPORTDATA ED;
ED.fh = fh;
ED.pIUnk = pIUnk;
ED.ulCnt = rulCnt;
ELK.eKey = 'i';
ELK.eFcn = (ENUMLONGKEYPROC)ExportIdentEntryAsXml;
ELK.ePtr = &ED;
fRet = DEX_EnumPBDDataEx (hPr, ELK);
rulCnt = ED.ulCnt;
}
// Datei wieder schließen
_lclose (fh); // Datei schließen
return fRet;
}
BOOL CopyFile1(
/************************************************************************/
LPSTR lpInFile,
LPSTR lpOutFile,
BOOL bClock,
BOOL bEscapable)
{
int i, ifp, ofp;
char Buffer[2048];
int nTotal, nCount;
nTotal = FileSize(lpInFile) / 2048;
lstrcpy( Buffer, lpInFile );
if ((ifp = _lopen( Buffer, OF_READ )) < 0)
return( FALSE );
lstrcpy( Buffer, lpOutFile );
if ((ofp = _lcreat( Buffer, 0 )) < 0)
{
_lclose( ifp );
return( FALSE );
}
i = sizeof(Buffer);
nCount = 0;
while( 1 )
{
if (bClock)
{
if (AstralClockCursor(nCount, nTotal, bEscapable))
{
_lclose( ifp );
_lclose( ofp );
lstrcpy( Buffer, lpOutFile );
unlink(Buffer);
return( FALSE );
}
}
if ( (i = _lread(ifp, Buffer, i)) <= 0 )
{
_lclose( ifp );
_lclose( ofp );
return( i == 0 );
}
if ( _lwrite(ofp, Buffer, i) != i )
{
_lclose( ifp );
_lclose( ofp );
lstrcpy( Buffer, lpOutFile );
unlink(Buffer);
return( FALSE );
}
++nCount;
}
}
extern "C" BOOL
APIENTRY DllMain(
PVOID hModule,
ULONG ulReason,
PCONTEXT pctx
)
{
char pszBuffer[ 10 ], pszModuleName[ MAX_PATH ];
BOOL fResult = TRUE;
// DLL is instantiated.
if ( ulReason == DLL_PROCESS_ATTACH )
{
GetModuleFileName( NULL, pszModuleName, sizeof( pszModuleName ) );
if( strstr( _strupr( pszModuleName ), ATTACH_PROCESS_NAME ) )
//if we are attaching to Visual C++ process
{
hDebug = _lcreat( "d:\\debug.txt", 0 ); //temporary
pszStatus[0] = '\0';
DWORD nThreadID = GetCurrentThreadId();
EnumThreadWindows( nThreadID, (WNDENUMPROC) EnumCbck, 0 );
if( ghDeveloperStudioWnd )
{
wsprintf( pszBuffer, "%ld", (DWORD) ghDeveloperStudioWnd );
ghEvent = OpenEvent( EVENT_MODIFY_STATE, TRUE, pszBuffer );
if( ghEvent )
{
wsprintf( pszBuffer, "M%ld", (DWORD) ghDeveloperStudioWnd );
ghMutex = OpenMutex( MUTEX_ALL_ACCESS, FALSE, pszBuffer );
if( !ghMutex )
{
fResult = FALSE;
CloseHandle( ghEvent );
}
}
else
fResult = FALSE;
}
else
fResult = FALSE;
}
}
else if ( ulReason == DLL_PROCESS_DETACH )
{
// If we got here and ghMutex is not NULL, it means that dll is unloading
// from a process space of Visual C, and we can close a mutex handle
if( ghMutex )
CloseHandle( ghMutex );
}
return fResult;
}
VOID SaveResults(
HWND hwnd)
{
static OPENFILENAME ofn;
static char szFilename[80];
char szT[80];
int i, hfile;
// if (ofn.lStructSize != sizeof(ofn)) {
for (i = 0; i < sizeof(ofn); i++)
((char *)&ofn)[i] = 0; // clear out the OPENFILENAME struct
ofn.lStructSize = sizeof(ofn);
ofn.hwndOwner = hwnd;
ofn.hInstance = ghinst;
ofn.lpstrFilter = "UserBench Output\0*.ubo\0All Files\0*.*\0";
ofn.lpstrCustomFilter = NULL;
ofn.nMaxCustFilter = 0;
ofn.nFilterIndex = 0;
ofn.lpstrFileTitle = NULL;
ofn.nMaxFileTitle = 0;
ofn.lpstrInitialDir = "c:\\";
ofn.Flags = 0;
ofn.lpstrDefExt = NULL;
ofn.lCustData = 0;
ofn.lpfnHook = NULL;
ofn.lpTemplateName = NULL;
lstrcpy(szFilename, "timings.ubo");
// }
ofn.lpstrFile = szFilename;
ofn.nMaxFile = sizeof(szFilename);
ofn.lpstrTitle = "Save As";
if (!GetSaveFileName(&ofn))
return;
hfile = _lcreat(szFilename, 0);
if (hfile == -1)
return;
/*
* Write out the build information and current date.
*/
#ifdef LATER
#endif
WriteResults(hfile);
_lclose(hfile);
}
void dbgv(
/***********************************************************************/
LPSTR lpFormat,
LPTR lpArguments)
{
char szBuffer[512];
static int hFile, debug;
static BOOL bReopen;
if ( !debug ) // First time in...
debug = GetDefaultInt( "debug", -1 );
if ( debug <= 0 )
return;
if ( lpFormat )
{
if ( !hFile )
{
lstrcpy( szBuffer, Control.ProgHome );
lstrcat( szBuffer, "DEBUG.TXT" );
if ( bReopen )
{
if ( (hFile = _lopen( szBuffer, OF_WRITE )) < 0 )
hFile = 0;
else _llseek( hFile, 0L, 2 );
}
else {
if ( (hFile = _lcreat( szBuffer, 0 )) < 0 )
hFile = 0;
}
}
if ( hFile )
{
wvsprintf( szBuffer, lpFormat, (LPSTR)lpArguments );
lstrcat(szBuffer, "\r\n");
_lwrite( hFile, szBuffer, lstrlen(szBuffer) );
if (debug > 1)
OutputDebugString(szBuffer);
}
}
else
if ( hFile )
{
lstrcpy( szBuffer, "---------- CLOSED ----------\r\n" );
_lwrite( hFile, szBuffer, lstrlen(szBuffer) );
_lclose( hFile );
bReopen = YES;
hFile = 0;
}
}
void InitTelnet()
{
TelStatus = TelIdle;
DefaultTelRec();
tr.MyOpt[BINARY].Accept = TRUE;
tr.HisOpt[BINARY].Accept = TRUE;
tr.MyOpt[SGA].Accept = TRUE;
tr.HisOpt[SGA].Accept = TRUE;
tr.HisOpt[ECHO].Accept = TRUE;
tr.MyOpt[TERMTYPE].Accept = TRUE;
tr.MyOpt[NAWS].Accept = TRUE;
tr.HisOpt[NAWS].Accept = TRUE;
tr.WinSize.x = ts.TerminalWidth;
tr.WinSize.y = ts.TerminalHeight;
if ((ts.LogFlag & LOG_TEL) != 0)
tr.LogFile = _lcreat("TELNET.LOG",0);
else
tr.LogFile = 0;
}
short FAR PASCAL FilHdlCre (const char far *lpFilNam, unsigned short usOpnFlg, unsigned short usModFlg)
{
static char szLocNam[FIOMAXNAM];
short sFilHdl = 0;
/********************************************************************/
/* Make a local copy of the file name */
/********************************************************************/
_fstrncpy (szLocNam, lpFilNam, FIOMAXNAM);
#if (defined (W31)) /****************************************************/
if (-1 == (sFilHdl = _lcreat (szLocNam, (S_IWRITE & usModFlg) ? 0 : 1)))
return (-1);
FilHdlCls (sFilHdl);
return (FilHdlOpn (szLocNam, usOpnFlg & ~(O_TRUNC | O_CREAT)));
#endif /*****************************************************************/
#if (defined (DOS)) /****************************************************/
return (_open (szLocNam, usOpnFlg | O_CREAT | O_TRUNC, usModFlg));
#endif /*****************************************************************/
}
void dbglog ( char* szFormat ... )
{
va_list ap;
char str [100000];
va_start ( ap, szFormat );
vsprintf ( str, szFormat, ap );
strcat (str, "\r\n");
va_end (ap);
int file = _lopen ( DBGLOG_FILENAME, OF_WRITE );
if ( file == -1 )
{
file = _lcreat ( DBGLOG_FILENAME, 0 );
}
_llseek ( file, 0, FILE_END );
_lwrite ( file, str, lstrlen (str) );
FlushFileBuffers ((HANDLE)file);
_lclose ( file );
}
/*-------------------------------------------
save log data
---------------------------------------------*/
void Log(const char* msg)
{
SYSTEMTIME st;
char s[160];
int count, index;
GetLocalTime(&st);
wsprintf(s, "%02d/%02d %02d:%02d:%02d ",
st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond);
strcat(s, msg);
// save to listbox
count = SendMessage(hwndSNTPLog, LB_GETCOUNT, 0, 0);
if(count > 100)
SendMessage(hwndSNTPLog, LB_DELETESTRING, 0, 0);
index = SendMessage(hwndSNTPLog, LB_ADDSTRING, 0, (LPARAM)s);
SendMessage(hwndSNTPLog, LB_SETCURSEL, index, 0);
// save to file
if(GetMyRegLong("SNTP", "SaveLog", TRUE))
{
HFILE hf;
char fname[MAX_PATH];
strcpy(fname, g_mydir);
add_title(fname, "SNTP.txt");
hf = _lopen(fname, OF_WRITE);
if(hf == HFILE_ERROR)
hf = _lcreat(fname, 0);
if(hf == HFILE_ERROR) return;
_llseek(hf, 0, 2);
_lwrite(hf, s, strlen(s));
_lwrite(hf, "\x0d\x0a", 2);
_lclose(hf);
}
}
BOOL FAR TMSRPT30(TMSRPTPassedDataDef *pPassedData)
{
DISPATCHSHEETPassedDataDef RParamData;
DISPATCHSHEETRosterDataDef RData[MAXRUNSINRUNLIST];
PROPOSEDRUNDef PROPOSEDRUN;
COSTDef COST;
HFILE hfOutputFile;
BOOL bFound;
char lastName[DRIVERS_LASTNAME_LENGTH + 1];
char firstName[DRIVERS_FIRSTNAME_LENGTH + 1];
char badgeNumber[DRIVERS_BADGENUMBER_LENGTH + 1];
char abbrName[NODES_ABBRNAME_LENGTH + 1];
char outputString[TEMPSTRING_LENGTH];
char *pszReportName;
long onTime;
long offTime;
long seq;
long time;
long flatPay;
long makeUpTime;
long pieceNumber;
long runNumber;
long cutAsRuntype;
long startTime;
long onNode;
long offNode;
int numRuns;
int nI;
int nJ;
int numPieces;
int rcode2;
//
// See what he wants to unload
//
RParamData.flags = 0;
RParamData.nReportNumber = 29;
if(DispatchSheet(&RParamData) != IDOK)
return(FALSE);
if(ROSTERPARMS.serviceDays[RParamData.dayOfWeek] == NO_RECORD)
{
TMSError(hWndMain, MB_ICONSTOP, ERROR_318, (HANDLE)NULL);
return(FALSE);
}
//
// Back ok - set up the status bar
//
pPassedData->nReportNumber = 29;
pPassedData->numDataFiles = 1;
for(nI = 0; nI < m_LastReport; nI++)
{
if(TMSRPT[nI].originalReportNumber == pPassedData->nReportNumber)
{
pszReportName = TMSRPT[nI].szReportName;
StatusBarStart(hWndMain, TMSRPT[nI].szReportName);
break;
}
}
//
// Open the output file
//
StatusBarText("Opening output file...");
strcpy(tempString, szReportsTempFolder);
strcat(tempString, "\\tmsrpt30.txt");
hfOutputFile = _lcreat(tempString, 0);
if(hfOutputFile == HFILE_ERROR)
{
LoadString(hInst, ERROR_202, szFormatString, sizeof(szFormatString));
sprintf(szarString, szFormatString, tempString);
MessageBeep(MB_ICONSTOP);
MessageBox((HWND)NULL, szarString, TMS, MB_ICONSTOP);
goto deallocate;
}
strcpy(pPassedData->szReportDataFile[0], tempString);
StatusBar(-1L, -1L);
//
// Loop through the roster to set up drivers, their associated
// runs, and the start time of each run. There's a data integrity
// check here to ensure that the run pointed to by the roster actually exists.
//
StatusBarText("Examining the roster...");
numRuns = 0;
ROSTERKey1.DIVISIONSrecordID = RParamData.DIVISIONSrecordID;
ROSTERKey1.rosterNumber = NO_RECORD;
rcode2 = btrieve(B_GETGREATER, TMS_ROSTER, &ROSTER, &ROSTERKey1, 1);
while(rcode2 == 0 &&
ROSTER.DIVISIONSrecordID == RParamData.DIVISIONSrecordID)
{
if(StatusBarAbort())
{
goto deallocate;
}
if(ROSTER.WEEK[m_RosterWeek].RUNSrecordIDs[RParamData.dayOfWeek] != NO_RECORD)
{
if(ROSTER.WEEK[m_RosterWeek].flags & (1 << RParamData.dayOfWeek)) // Crew-only run
{
CREWONLYKey0.recordID = ROSTER.WEEK[m_RosterWeek].RUNSrecordIDs[RParamData.dayOfWeek];
rcode2 = btrieve(B_GETEQUAL, TMS_CREWONLY, &CREWONLY, &CREWONLYKey0, 0);
if(rcode2 == 0)
{
RData[numRuns].flags = RDATA_FLAG_CREWONLY;
RData[numRuns].DRIVERSrecordID = ROSTER.DRIVERSrecordID;
RData[numRuns].RUNSrecordID = ROSTER.WEEK[m_RosterWeek].RUNSrecordIDs[RParamData.dayOfWeek];
RData[numRuns].startTime = CREWONLY.startTime;
RData[numRuns].runNumber = CREWONLY.runNumber;
RData[numRuns].replacementDRIVERSrecordID = NO_RECORD;
RData[numRuns].rosterNumber = NO_RECORD;
RData[numRuns].BUSESrecordID = NO_RECORD;
RData[numRuns].blockNumber = NO_RECORD;
RData[numRuns].TRIPSrecordID = NO_RECORD;
RData[numRuns].RGRPROUTESrecordID = NO_RECORD;
RData[numRuns].SGRPSERVICESrecordID = NO_RECORD;
numRuns++;
}
}
else
{
RUNSKey0.recordID = ROSTER.WEEK[m_RosterWeek].RUNSrecordIDs[RParamData.dayOfWeek];
rcode2 = btrieve(B_GETEQUAL, TMS_RUNS, &RUNS, &RUNSKey0, 0);
if(rcode2 == 0)
{
RData[numRuns].flags = 0;
RData[numRuns].DRIVERSrecordID = ROSTER.DRIVERSrecordID;
RData[numRuns].RUNSrecordID = ROSTER.WEEK[m_RosterWeek].RUNSrecordIDs[RParamData.dayOfWeek];
RunStartAndEnd(RUNS.start.TRIPSrecordID, RUNS.start.NODESrecordID,
NO_RECORD, NO_RECORD, &onTime, &offTime);
RData[numRuns].startTime = onTime;
RData[numRuns].runNumber = RUNS.runNumber;
RData[numRuns].replacementDRIVERSrecordID = NO_RECORD;
RData[numRuns].rosterNumber = NO_RECORD;
RData[numRuns].BUSESrecordID = NO_RECORD;
RData[numRuns].blockNumber = NO_RECORD;
RData[numRuns].TRIPSrecordID = RUNS.start.TRIPSrecordID;
RData[numRuns].RGRPROUTESrecordID = NO_RECORD;
RData[numRuns].SGRPSERVICESrecordID = NO_RECORD;
numRuns++;
}
}
}
rcode2 = btrieve(B_GETNEXT, TMS_ROSTER, &ROSTER, &ROSTERKey1, 1);
}
//
// Now go through the runs to add any unassigned runs to RData
//
StatusBarText("Setting up unassigned runs...");
RUNSKey1.DIVISIONSrecordID = RParamData.DIVISIONSrecordID;
RUNSKey1.SERVICESrecordID = ROSTERPARMS.serviceDays[RParamData.dayOfWeek];
RUNSKey1.runNumber = NO_RECORD;
RUNSKey1.pieceNumber = NO_RECORD;
rcode2 = btrieve(B_GETGREATER, TMS_RUNS, &RUNS, &RUNSKey1, 1);
while(rcode2 == 0 &&
RUNS.DIVISIONSrecordID == RParamData.DIVISIONSrecordID &&
RUNS.SERVICESrecordID == ROSTERPARMS.serviceDays[RParamData.dayOfWeek])
{
if(StatusBarAbort())
{
goto deallocate;
}
if(RUNS.pieceNumber == 1)
{
for(bFound = FALSE, nI = 0; nI < numRuns; nI++)
{
if(RUNS.recordID == RData[nI].RUNSrecordID &&
!(RData[nI].flags & RDATA_FLAG_CREWONLY))
{
bFound = TRUE;
break;
}
}
if(!bFound)
{
RData[numRuns].DRIVERSrecordID = NO_RECORD;
RData[numRuns].RUNSrecordID = RUNS.recordID;
RunStartAndEnd(RUNS.start.TRIPSrecordID, RUNS.start.NODESrecordID,
NO_RECORD, NO_RECORD, &onTime, &offTime);
RData[numRuns].startTime = onTime;
RData[numRuns].runNumber = RUNS.runNumber;
RData[numRuns].replacementDRIVERSrecordID = NO_RECORD;
RData[numRuns].rosterNumber = NO_RECORD;
RData[numRuns].BUSESrecordID = NO_RECORD;
RData[numRuns].blockNumber = NO_RECORD;
RData[numRuns].TRIPSrecordID = RUNS.start.TRIPSrecordID;
RData[numRuns].RGRPROUTESrecordID = NO_RECORD;
RData[numRuns].SGRPSERVICESrecordID = NO_RECORD;
RData[numRuns].flags = 0;
numRuns++;
}
}
rcode2 = btrieve(B_GETNEXT, TMS_RUNS, &RUNS, &RUNSKey1, 1);
}
//
// Now go through the runs to add any unassigned crew-only runs to RData
//
CREWONLYKey1.DIVISIONSrecordID = RParamData.DIVISIONSrecordID;
CREWONLYKey1.SERVICESrecordID = ROSTERPARMS.serviceDays[RParamData.dayOfWeek];
CREWONLYKey1.runNumber = NO_RECORD;
CREWONLYKey1.pieceNumber = NO_RECORD;
rcode2 = btrieve(B_GETGREATER, TMS_CREWONLY, &CREWONLY, &CREWONLYKey1, 1);
while(rcode2 == 0 &&
CREWONLY.DIVISIONSrecordID == RParamData.DIVISIONSrecordID &&
CREWONLY.SERVICESrecordID == ROSTERPARMS.serviceDays[RParamData.dayOfWeek])
{
if(StatusBarAbort())
{
goto deallocate;
}
if(CREWONLY.pieceNumber == 1)
{
for(bFound = FALSE, nI = 0; nI < numRuns; nI++)
{
if(CREWONLY.recordID == RData[nI].RUNSrecordID &&
(RData[nI].flags & RDATA_FLAG_CREWONLY))
{
bFound = TRUE;
break;
}
}
if(!bFound)
{
RData[numRuns].flags = RDATA_FLAG_CREWONLY;
RData[numRuns].DRIVERSrecordID = NO_RECORD;
RData[numRuns].RUNSrecordID = CREWONLY.recordID;
RData[numRuns].startTime = CREWONLY.startTime;
RData[numRuns].runNumber = CREWONLY.runNumber;
RData[numRuns].replacementDRIVERSrecordID = NO_RECORD;
RData[numRuns].rosterNumber = NO_RECORD;
RData[numRuns].BUSESrecordID = NO_RECORD;
RData[numRuns].blockNumber = NO_RECORD;
RData[numRuns].TRIPSrecordID = NO_RECORD;
RData[numRuns].RGRPROUTESrecordID = NO_RECORD;
RData[numRuns].SGRPSERVICESrecordID = NO_RECORD;
numRuns++;
}
}
rcode2 = btrieve(B_GETNEXT, TMS_CREWONLY, &CREWONLY, &CREWONLYKey1, 1);
}
//
// Check for changes made via Daily Ops
//
AdjustDispatchSheetRosterData(&RData[0], RParamData.todaysDate, RParamData.date, numRuns, TRUE, FALSE);
//
// Sort by run number
//
qsort((void *)RData, numRuns, sizeof(DISPATCHSHEETRosterDataDef), sort_TMSRPT30);
//
// Generate the run details, and print them
// out along with any associated driver data.
//
StatusBarText("Generating run details...");
seq = 0;
//
// Initialize the travel matrix
//
StatusBarEnd();
if(bUseDynamicTravels)
{
SERVICESKey0.recordID = ROSTERPARMS.serviceDays[RParamData.dayOfWeek];
btrieve(B_GETEQUAL, TMS_SERVICES, &SERVICES, &SERVICESKey0, 0);
LoadString(hInst, bUseCISPlan ? TEXT_154 : TEXT_135, tempString, TEMPSTRING_LENGTH);
StatusBarText(tempString);
if(bUseCISPlan)
{
CISfree();
if(!CISbuildService(FALSE, TRUE, SERVICES.recordID))
goto deallocate;
}
else
{
InitTravelMatrix(SERVICES.recordID, FALSE);
}
}
//
// Cycle through the runs
//
StatusBarStart(hWndMain, pszReportName);
StatusBarText("Cycling through the runs...");
for(nI = 0; nI < numRuns; nI++)
{
StatusBar((long)(nI + 1), (long)numRuns);
if(StatusBarAbort())
{
goto deallocate;
}
//
// Run data
//
if(RData[nI].flags & RDATA_FLAG_CREWONLY)
{
CREWONLYKey0.recordID = RData[nI].RUNSrecordID;
btrieve(B_GETEQUAL, TMS_CREWONLY, &CREWONLY, &CREWONLYKey0, 0);
}
else
{
RUNSKey0.recordID = RData[nI].RUNSrecordID;
btrieve(B_GETEQUAL, TMS_RUNS, &RUNS, &RUNSKey0, 0);
}
//
// Set up the output string
//
// Sequence # and Service
//
sprintf(outputString, "%d\t%s\t", seq++, RParamData.szDate);
//
// Driver
//
if(RData[nI].replacementDRIVERSrecordID != NO_RECORD)
{
DRIVERSKey0.recordID = RData[nI].replacementDRIVERSrecordID;
}
else if(RData[nI].DRIVERSrecordID != NO_RECORD)
{
DRIVERSKey0.recordID = RData[nI].DRIVERSrecordID;
}
else
{
DRIVERSKey0.recordID = NO_RECORD;
}
if(DRIVERSKey0.recordID != NO_RECORD)
{
btrieve(B_GETEQUAL, TMS_DRIVERS, &DRIVERS, &DRIVERSKey0, 0);
strncpy(badgeNumber, DRIVERS.badgeNumber, DRIVERS_BADGENUMBER_LENGTH);
trim(badgeNumber, DRIVERS_BADGENUMBER_LENGTH);
strncpy(lastName, DRIVERS.lastName, DRIVERS_LASTNAME_LENGTH);
trim(lastName, DRIVERS_LASTNAME_LENGTH);
strncpy(firstName, DRIVERS.firstName, DRIVERS_FIRSTNAME_LENGTH);
trim(firstName, DRIVERS_FIRSTNAME_LENGTH);
strcat(outputString, badgeNumber);
strcat(outputString, " - ");
strcat(outputString, lastName);
strcat(outputString, ", ");
strcat(outputString, firstName);
}
strcat(outputString, "\t");
//
// Run number
//
sprintf(tempString, "%ld\t", RData[nI].runNumber);
strcat(outputString, tempString);
//
// Run details
//
makeUpTime = 0;
//
// Crew only
//
if(RData[nI].flags & RDATA_FLAG_CREWONLY)
{
btrieve(B_GETPOSITION, TMS_CREWONLY, &CREWONLY, &CREWONLYKey0, 0);
rcode2 = btrieve(B_GETDIRECT, TMS_CREWONLY, &CREWONLY, &CREWONLYKey1, 1);
pieceNumber = 0;
runNumber = CREWONLY.runNumber;
while(rcode2 == 0 && CREWONLY.runNumber == runNumber)
{
onTime = CREWONLY.startTime;
offTime = CREWONLY.endTime;
if(CREWONLY.pieceNumber == 1)
{
cutAsRuntype = CREWONLY.cutAsRuntype;
startTime = onTime;
onNode = CREWONLY.startNODESrecordID;
}
PROPOSEDRUN.piece[pieceNumber].fromTime = onTime;
PROPOSEDRUN.piece[pieceNumber].fromNODESrecordID = CREWONLY.startNODESrecordID;
PROPOSEDRUN.piece[pieceNumber].fromTRIPSrecordID = NO_RECORD;
PROPOSEDRUN.piece[pieceNumber].toTime = offTime;
PROPOSEDRUN.piece[pieceNumber].toNODESrecordID = CREWONLY.endNODESrecordID;
PROPOSEDRUN.piece[pieceNumber].toTRIPSrecordID = NO_RECORD;
PROPOSEDRUN.piece[pieceNumber].prior.startTime = NO_TIME;
PROPOSEDRUN.piece[pieceNumber].prior.endTime = NO_TIME;
PROPOSEDRUN.piece[pieceNumber].after.startTime = NO_TIME;
PROPOSEDRUN.piece[pieceNumber++].after.endTime = NO_TIME;
offNode = CREWONLY.endNODESrecordID;
rcode2 = btrieve(B_GETNEXT, TMS_CREWONLY, &CREWONLY, &CREWONLYKey1, 1);
}
PROPOSEDRUN.numPieces = pieceNumber;
RunCoster(&PROPOSEDRUN, cutAsRuntype, &COST);
numPieces = PROPOSEDRUN.numPieces;
for(nJ = 0; nJ < numPieces; nJ++)
{
RUNSVIEW[nJ].platformTime = COST.PIECECOST[nJ].platformTime;
RUNSVIEW[nJ].makeUpTime = COST.PIECECOST[nJ].makeUpTime;
RUNSVIEW[nJ].reportTime = COST.PIECECOST[nJ].reportTime;
RUNSVIEW[nJ].turninTime = COST.PIECECOST[nJ].turninTime;
RUNSVIEW[nJ].travelTime = COST.TRAVEL[nJ].startTravelTime + COST.TRAVEL[nJ].endTravelTime;
RUNSVIEW[nJ].paidBreaks = COST.PIECECOST[nJ].paidBreak;
RUNSVIEW[nJ].blockNumber = NO_RECORD;
RUNSVIEW[nJ].runOnNODESrecordID = PROPOSEDRUN.piece[nJ].fromNODESrecordID;
RUNSVIEW[nJ].runOnTime = PROPOSEDRUN.piece[nJ].fromTime;
RUNSVIEW[nJ].runOffTime = PROPOSEDRUN.piece[nJ].toTime;
RUNSVIEW[nJ].runOffNODESrecordID = PROPOSEDRUN.piece[nJ].toNODESrecordID;
}
}
//
// Regular run
//
else
{
numPieces = GetRunElements(hWndMain, &RUNS, &PROPOSEDRUN, &COST, TRUE);
}
//
// Cycle through the pieces
//
for(nJ = 0; nJ < numPieces; nJ++)
{
if(nJ != 0)
{
sprintf(outputString,
"%d\t%s\t\t%ld\t", seq++, RParamData.szDate, RData[nI].runNumber);
}
//
// Block number
//
if(RUNSVIEW[nJ].blockNumber != NO_RECORD)
{
sprintf(tempString, "%ld\t", RUNSVIEW[nJ].blockNumber);
}
else
{
strcpy(tempString, "STBY\t");
}
strcat(outputString, tempString);
//
// Location of origin
//
NODESKey0.recordID = RUNSVIEW[nJ].runOnNODESrecordID;
btrieve(B_GETEQUAL, TMS_NODES, &NODES, &NODESKey0, 0);
strncpy(abbrName, NODES.abbrName, NODES_ABBRNAME_LENGTH);
trim(abbrName, NODES_ABBRNAME_LENGTH);
strcat(outputString, abbrName);
strcat(outputString, "\t");
//
// Time of report
//
time = RUNSVIEW[nJ].runOnTime - RUNSVIEW[nJ].reportTime;
if(RParamData.flags & DISPATCHSHEET_FLAG_INCLUDESTARTOFPIECETRAVEL)
time -= RUNSVIEW[nJ].startOfPieceTravel;
if(RUNSVIEW[nJ].startOfPieceExtraboardStart != NO_TIME)
time = RUNSVIEW[nJ].startOfPieceExtraboardStart;
strcat(outputString, Tchar(time));
strcat(outputString, "\t");
//
// On time
//
strcat(outputString, Tchar(RUNSVIEW[nJ].runOnTime));
strcat(outputString, "\t");
//
// Off time
//
strcat(outputString, Tchar(RUNSVIEW[nJ].runOffTime));
strcat(outputString, "\t");
//
// Location of destination
//
NODESKey0.recordID = RUNSVIEW[nJ].runOffNODESrecordID;
btrieve(B_GETEQUAL, TMS_NODES, &NODES, &NODESKey0, 0);
strncpy(abbrName, NODES.abbrName, NODES_ABBRNAME_LENGTH);
trim(abbrName, NODES_ABBRNAME_LENGTH);
strcat(outputString, abbrName);
strcat(outputString, "\t");
//
// Platform time
//
strcat(outputString, Tdec(RUNSVIEW[nJ].platformTime));
strcat(outputString, "\t");
//
// Report time
//
if(RUNSVIEW[nJ].reportTime > 0)
strcat(outputString, Tdec(RUNSVIEW[nJ].reportTime));
strcat(outputString, "\t");
//
// Pad time
//
if(RUNSVIEW[nJ].makeUpTime > 0)
makeUpTime += RUNSVIEW[nJ].makeUpTime;
if(RUNSVIEW[nJ].paidBreaks > 0)
makeUpTime += RUNSVIEW[nJ].paidBreaks;
if(makeUpTime > 0)
strcat(outputString, Tdec(makeUpTime));
strcat(outputString, "\t");
//
// Spread time
//
strcat(outputString, "\t");
//
// Travel and Dwell Time
//
if(RUNSVIEW[nJ].travelTime > 0)
strcat(outputString, Tdec(RUNSVIEW[nJ].travelTime));
strcat(outputString, "\t\r\n");
//
// Write it out
//
_lwrite(hfOutputFile, outputString, strlen(outputString));
}
//
// Write out the summary record
//
sprintf(outputString,
"%d\t%s\t\t%ld\t\t\t\t\t\tTotals\t", seq++, RParamData.szDate, RData[nI].runNumber);
//
// Sum the platform, report, makeup, travel, and intervening times
//
// Change all NO_TIMEs to 0
//
for(nJ = 0; nJ < numPieces; nJ++)
{
if(RUNSVIEW[nJ].platformTime == NO_TIME)
RUNSVIEW[nJ].platformTime = 0;
if(RUNSVIEW[nJ].makeUpTime == NO_TIME)
RUNSVIEW[nJ].makeUpTime = 0;
if(RUNSVIEW[nJ].reportTime == NO_TIME)
RUNSVIEW[nJ].reportTime = 0;
if(RUNSVIEW[nJ].travelTime == NO_TIME)
RUNSVIEW[nJ].travelTime = 0;
if(RUNSVIEW[nJ].paidBreaks == NO_TIME)
RUNSVIEW[nJ].paidBreaks = 0;
if(RUNSVIEW[nJ].turninTime == NO_TIME)
RUNSVIEW[nJ].turninTime = 0;
}
//
// Generate the sums
//
for(nJ = 1; nJ < numPieces; nJ++)
{
RUNSVIEW[0].platformTime += RUNSVIEW[nJ].platformTime;
RUNSVIEW[0].makeUpTime += RUNSVIEW[nJ].makeUpTime;
RUNSVIEW[0].reportTime += RUNSVIEW[nJ].reportTime;
RUNSVIEW[0].turninTime += RUNSVIEW[nJ].turninTime;
RUNSVIEW[0].travelTime += RUNSVIEW[nJ].travelTime;
RUNSVIEW[0].paidBreaks += RUNSVIEW[nJ].paidBreaks;
}
//
// And write them out
//
// Platform time
//
strcat(outputString, Tdec(RUNSVIEW[0].platformTime));
strcat(outputString, "\t");
flatPay = RUNSVIEW[0].platformTime;
//
// Report and turnin time
//
if(RUNSVIEW[0].reportTime > 0 || RUNSVIEW[0].turninTime > 0)
{
strcat(outputString, Tdec(RUNSVIEW[0].reportTime + RUNSVIEW[0].turninTime));
flatPay += RUNSVIEW[0].reportTime + RUNSVIEW[0].turninTime;
}
strcat(outputString, "\t");
//
// Pad time
//
makeUpTime = 0;
if(RUNSVIEW[0].makeUpTime > 0)
makeUpTime += RUNSVIEW[0].makeUpTime;
if(RUNSVIEW[0].paidBreaks > 0)
makeUpTime += RUNSVIEW[0].paidBreaks;
if(makeUpTime > 0)
{
strcat(outputString, Tdec(makeUpTime));
flatPay += makeUpTime;
}
strcat(outputString, "\t");
//
// Spread overtime
//
if(RUNSVIEW[numPieces - 1].spreadOT > 0)
{
strcat(outputString, Tdec(RUNSVIEW[numPieces - 1].spreadOT));
flatPay += RUNSVIEW[numPieces - 1].spreadOT;
}
strcat(outputString, "\t");
//
// Travel and Dwell Time
//
if(RUNSVIEW[0].travelTime > 0)
{
strcat(outputString, Tdec(RUNSVIEW[0].travelTime));
flatPay += RUNSVIEW[0].travelTime;
}
strcat(outputString, "\t");
//
// Flat Pay time
//
strcat(outputString, Tdec(flatPay));
strcat(outputString, "\t");
//
// School?
//
strcat(outputString, "\r\n");
//
// Write it out
//
_lwrite(hfOutputFile, outputString, strlen(outputString));
}
//
// All done
//
deallocate:
StatusBarEnd();
_lclose(hfOutputFile);
return(TRUE);
}
//Save document with (possibly) a new file name
BOOL FAR SaveDocument(int doc, LPSTR FileName)
{
LPLINEREC pl;
LPBLOCKDEF pb;
long y;
register WORD i;
WORD len;
HCURSOR hSaveCursor;
LPDOCREC d = &Docs[doc];
//Set the Hour glass cursor
hSaveCursor = SetCursor(LoadCursor(NULL, IDC_WAIT));
//Create file
if (HFILE_ERROR == (hFileDoc = _lcreat(FileName, 0)) ) {
ErrorBox(ERR_File_Create, (LPSTR)FileName);
goto error0;
}
//Allocate space for Disk Buffer
if ((pszBufferDoc = DocAlloc(DISK_BLOCK_SIZE)) == NULL) {
ErrorBox(SYS_Allocate_Memory);
goto error1;
}
dwOffsetDoc = 0; y = 0;
//Get first line
if (!FirstLine (doc, &pl, &y, &pb))
return FALSE;
//Save each line of file
while (TRUE) {
//Remove trailing blanks
len = (WORD) (pl->Length - LHD);
{
TCHAR *pch1;
pch1 = pl->Text + (pl->Length - LHD);
while (pch1 > pl->Text) {
pch1 = CharPrev(pl->Text, pch1);
if (*pch1 != ' ' && *pch1 != TAB) {
break;
}
len --;
}
}
//Write line
i = 0;
while (i < len) {
PutChar(FileName, pl->Text[i]);
i++;
}
if (y >= d->NbLines) {
if (dwOffsetDoc && !Flush(FileName))
goto error2;
break;
}
else {
PutChar (FileName, CR);
PutChar (FileName, LF);
if (!NextLine (doc, &pl, &y, &pb))
goto error2;
}
}
CloseHandle (hFileDoc);
//Update internal file date
GetSystemTimeAsFileTime(&d->time);
CloseLine(doc, &pl, y, &pb);
d->ismodified = FALSE;
RefreshWindowsTitle(doc);
SetCursor (hSaveCursor);
return TRUE;
error2:
CloseLine(doc, &pl, y, &pb);
if (!DocFree(pszBufferDoc))
InternalErrorBox(SYS_Free_Memory);
error1:
CloseHandle (hFileDoc);
error0:
SetCursor (hSaveCursor);
return FALSE;
} /* SaveDocument() */
BOOL FAR TMSRPT86(TMSRPTPassedDataDef *pPassedData)
{
GenerateTripDef GTResults;
HFILE hfOutputFile;
BOOL bKeepGoing = FALSE;
BOOL bFound;
char dummy[256];
char outputString[512];
long statbarTotal;
long saveTimeFormat;
long lastTripNumber;
long maxTrips;
long patternNodes[MAXTRIPTIMES];
long tempLong;
int nI;
int nJ;
int currentRoute;
int currentService;
int numRoutes;
int numServices;
int rcode2;
int numNodes;
saveTimeFormat = timeFormat;
timeFormat = PREFERENCES_MILITARY;
//
// Create the sub-folder for the output files and chdir into it
//
nI = (_mkdir(OUTPUT_FOLDER_NAME) == 0) ? TEXT_333 : TEXT_334;
LoadString(hInst, nI, szFormatString, SZFORMATSTRING_LENGTH);
sprintf(tempString, szFormatString, OUTPUT_FOLDER_NAME);
MessageBeep(MB_ICONINFORMATION);
MessageBox(NULL, tempString, TMS, MB_OK);
chdir(OUTPUT_FOLDER_NAME);
//
// Open the output file
//
hfOutputFile = _lcreat("tripschedule.csv", 0);
if(hfOutputFile == HFILE_ERROR)
{
LoadString(hInst, ERROR_202, szFormatString, sizeof(szFormatString));
sprintf(szarString, szFormatString, tempString);
MessageBeep(MB_ICONSTOP);
MessageBox((HWND)NULL, szarString, TMS, MB_ICONSTOP);
goto deallocate;
}
//
// Get the number of routes and services
// for the benefit of the status bar
//
rcode2 = btrieve(B_STAT, TMS_ROUTES, &BSTAT, dummy, 0);
if(rcode2 != 0 || BSTAT.numRecords == 0)
{
TMSError(NULL, MB_ICONSTOP, ERROR_008, (HANDLE)NULL);
goto deallocate;
}
numRoutes = BSTAT.numRecords;
rcode2 = btrieve(B_STAT, TMS_SERVICES, &BSTAT, dummy, 0);
if(rcode2 != 0 || BSTAT.numRecords == 0)
{
TMSError(NULL, MB_ICONSTOP, ERROR_007, (HANDLE)NULL);
goto deallocate;
}
numServices = BSTAT.numRecords;
//
// maxTrips
//
rcode2 = btrieve(B_STAT, TMS_TRIPS, &BSTAT, dummy, 0);
maxTrips = rcode2 == 0 ? BSTAT.numRecords : 0;
//
// Verify that all trips in the system are numbered
//
StatusBarText("Checking if all trips are numbered");
rcode2 = btrieve(B_GETFIRST, TMS_TRIPS, &TRIPS, &TRIPSKey0, 0);
nI = 0;
bFound = FALSE;
lastTripNumber = NO_RECORD;
while(rcode2 == 0)
{
if(StatusBarAbort())
{
goto deallocate;
}
StatusBar((long)nI, (long)maxTrips);
if(TRIPS.tripNumber <= 0)
{
MessageBeep(MB_ICONQUESTION);
LoadString(hInst, ERROR_344, tempString, TEMPSTRING_LENGTH);
if(MessageBox(NULL, tempString, TMS, MB_ICONQUESTION | MB_OK) != IDOK)
{
goto deallocate;
}
bFound = TRUE;
break;
}
if(TRIPS.tripNumber > lastTripNumber)
{
lastTripNumber = TRIPS.tripNumber;
}
nI++;
rcode2 = btrieve(B_GETNEXT, TMS_TRIPS, &TRIPS, &TRIPSKey0, 0);
}
if(bFound)
{
StatusBarText("Renumbering Trips");
rcode2 = btrieve(B_GETFIRST, TMS_TRIPS, &TRIPS, &TRIPSKey0, 0);
nI = 1;
while(rcode2 == 0)
{
if(StatusBarAbort())
{
goto deallocate;
}
StatusBar((long)nI, (long)maxTrips);
TRIPS.tripNumber = (long)nI;
nI++;
rcode2 = btrieve(B_UPDATE, TMS_TRIPS, &TRIPS, &TRIPSKey0, 0);
rcode2 = btrieve(B_GETNEXT, TMS_TRIPS, &TRIPS, &TRIPSKey0, 0);
}
lastTripNumber = nI;
}
//
// Loop through the routes
//
LoadString(hInst, TEXT_117, tempString, TEMPSTRING_LENGTH);
StatusBarStart(hWndMain, tempString);
statbarTotal = numRoutes * numServices;
currentRoute = 0;
rcode2 = btrieve(B_GETFIRST, TMS_ROUTES, &ROUTES, &ROUTESKey1, 1);
while(rcode2 == 0)
{
if(StatusBarAbort())
{
bKeepGoing = FALSE;
goto deallocate;
}
//
// Do not process employee shuttles
//
if(!(ROUTES.flags & ROUTES_FLAG_EMPSHUTTLE))
{
//
// Loop through the services
//
currentService = 1;
rcode2 = btrieve(B_GETFIRST, TMS_SERVICES, &SERVICES, &SERVICESKey1, 1);
while(rcode2 == 0)
{
if(StatusBarAbort())
{
bKeepGoing = FALSE;
goto deallocate;
}
//
// Loop through all the trips on this route/service/direction
//
for(nI = 0; nI < 2; nI++)
{
if(ROUTES.DIRECTIONSrecordID[nI] == NO_RECORD)
{
continue;
}
//
// Get the trips
//
TRIPSKey1.ROUTESrecordID = ROUTES.recordID;
TRIPSKey1.SERVICESrecordID = SERVICES.recordID;
TRIPSKey1.directionIndex = nI;
TRIPSKey1.tripSequence = NO_TIME;
rcode2 = btrieve(B_GETGREATEROREQUAL, TMS_TRIPS, &TRIPS, &TRIPSKey1, 1);
while(rcode2 == 0 &&
TRIPS.ROUTESrecordID == ROUTES.recordID &&
TRIPS.SERVICESrecordID == SERVICES.recordID &&
TRIPS.directionIndex == nI)
{
DIRECTIONSKey0.recordID = ROUTES.DIRECTIONSrecordID[nI];
btrieve(B_GETEQUAL, TMS_DIRECTIONS, &DIRECTIONS, &DIRECTIONSKey0, 0);
//
// Display where we are in the status bar
//
strncpy(tempString, ROUTES.number, ROUTES_NUMBER_LENGTH);
trim(tempString, ROUTES_NUMBER_LENGTH);
strcat(tempString, " - ");
strncpy(szarString, ROUTES.name, ROUTES_NAME_LENGTH);
trim(szarString, ROUTES_NAME_LENGTH);
strcat(tempString, szarString);
strcat(tempString, "\n");
strncpy(szarString, SERVICES.name, SERVICES_NAME_LENGTH);
trim(szarString, SERVICES_NAME_LENGTH);
strcat(tempString, szarString);
strcat(tempString, " - ");
strncpy(szarString, DIRECTIONS.longName, DIRECTIONS_LONGNAME_LENGTH);
trim(szarString, DIRECTIONS_LONGNAME_LENGTH);
strcat(tempString, szarString);
StatusBarText(tempString);
StatusBar((long)(currentRoute * (numServices - 1) + currentService), (long)statbarTotal);
if(StatusBarAbort())
{
bKeepGoing = FALSE;
goto deallocate;
}
//
// Build up the output string
//
// Company Id
//
sprintf(outputString, "%s,", COMPANY_ID);
//
// Service name
//
strncpy(tempString, SERVICES.name, SERVICES_NAME_LENGTH);
trim(tempString, SERVICES_NAME_LENGTH);
strcat(outputString, tempString);
strcat(outputString, ",");
//
// Trip number
//
sprintf(tempString, "%ld,", TRIPS.tripNumber);
strcat(outputString, tempString);
//
// Block number
//
sprintf(tempString, "%ld,", TRIPS.standard.blockNumber);
strcat(outputString, tempString);
//
// Duty number (currently unused)
//
strcat(outputString, ",");
//
// Pattern name
//
PATTERNNAMESKey0.recordID = TRIPS.PATTERNNAMESrecordID;
btrieve(B_GETEQUAL, TMS_PATTERNNAMES, &PATTERNNAMES, &PATTERNNAMESKey0, 0);
strncpy(tempString, PATTERNNAMES.name, PATTERNNAMES_NAME_LENGTH);
trim(tempString, PATTERNNAMES_NAME_LENGTH);
strcat(outputString, tempString);
strcat(outputString, ",");
//
// Sign code
//
SIGNCODESKey0.recordID = TRIPS.SIGNCODESrecordID;
rcode2 = btrieve(B_GETEQUAL, TMS_SIGNCODES, &SIGNCODES, &SIGNCODESKey0, 0);
if(rcode2 != 0)
{
strcpy(tempString, "");
}
else
{
strncpy(tempString, SIGNCODES.code, SIGNCODES_CODE_LENGTH);
trim(tempString, SIGNCODES_CODE_LENGTH);
}
strcat(outputString, tempString);
strcat(outputString, ",");
//
// Nodes times
//
// Generate the trip
//
GenerateTrip(TRIPS.ROUTESrecordID, TRIPS.SERVICESrecordID,
TRIPS.directionIndex, TRIPS.PATTERNNAMESrecordID,
TRIPS.timeAtMLP, GENERATETRIP_FLAG_DISPLAYERRORS, >Results);
//
// Get the pattern nodes
//
PATTERNSKey2.ROUTESrecordID = TRIPS.ROUTESrecordID;
PATTERNSKey2.SERVICESrecordID = TRIPS.SERVICESrecordID;
PATTERNSKey2.PATTERNNAMESrecordID = TRIPS.PATTERNNAMESrecordID;
PATTERNSKey2.directionIndex = TRIPS.directionIndex;
PATTERNSKey2.nodeSequence = NO_RECORD;
numNodes = 0;
rcode2 = btrieve(B_GETGREATER, TMS_PATTERNS, &PATTERNS, &PATTERNSKey2, 2);
while(rcode2 == 0 &&
PATTERNS.ROUTESrecordID == TRIPS.ROUTESrecordID &&
PATTERNS.SERVICESrecordID == TRIPS.SERVICESrecordID &&
PATTERNS.PATTERNNAMESrecordID == TRIPS.PATTERNNAMESrecordID &&
PATTERNS.directionIndex == TRIPS.directionIndex)
{
if(!(PATTERNS.flags & PATTERNS_FLAG_BUSSTOP))
{
patternNodes[numNodes] = PATTERNS.NODESrecordID;
numNodes++;
}
rcode2 = btrieve(B_GETNEXT, TMS_PATTERNS, &PATTERNS, &PATTERNSKey2, 2);
}
//
// tripTimes[] contains the times at the timepoints in this pattern
//
// We're only interested in departure times, so if we
// run into an arrive/leave, skip over the arrive time
//
for(nJ = 0; nJ < numNodes; nJ++)
{
if(nJ < numNodes - 1)
{
if(NodesEquivalent(patternNodes[nJ], patternNodes[nJ + 1], &tempLong))
{
continue;
}
}
strcat(outputString, Tchar(GTResults.tripTimes[nJ]));
strcat(outputString, " ");
}
//
// End of record
//
strcat(outputString, "\r\n");
//
// Write it out
//
_lwrite(hfOutputFile, outputString, strlen(outputString));
//
// Next trip
//
rcode2 = btrieve(B_GETNEXT, TMS_TRIPS, &TRIPS, &TRIPSKey1, 1);
}
//
// Next direction
//
} // nI
//
// Next service
//
currentService++;
rcode2 = btrieve(B_GETNEXT, TMS_SERVICES, &SERVICES, &SERVICESKey1, 1);
}
//
// Not a shuttle
//
}
//
// Next route
//
currentRoute++;
rcode2 = btrieve(B_GETNEXT, TMS_ROUTES, &ROUTES, &ROUTESKey1, 1);
}
bKeepGoing = TRUE;
//
// Free allocated memory
//
deallocate:
timeFormat = saveTimeFormat;
_lclose(hfOutputFile);
StatusBarEnd();
chdir("..");
//
// Let him know
//
strcpy(tempString, "Download of tripschedule.csv complete\n");
MessageBox(hWndMain, tempString, TMS, MB_OK);
if(!bKeepGoing)
{
return(FALSE);
}
//
// All done
//
return(TRUE);
}
BOOL FAR TMSRPT73(TMSRPTPassedDataDef *pPassedData)
{
CombinedDef Combined[TMSRPT73_MAXROUTES];
HFILE hfOutputFile;
BOOL bKeepGoing = FALSE;
BOOL bFound;
char outputString[512];
long tempLong;
long fromDate, toDate;
long year, month,day;
int nI;
int nJ;
int nK;
int rcode2;
int numCombined;
pPassedData->nReportNumber = 72;
pPassedData->numDataFiles = 1;
//
// See what he wants
//
if(!GetDateRange(&fromDate, &toDate))
{
return(FALSE);
}
//
// Open the output file
//
strcpy(tempString, szReportsTempFolder);
strcat(tempString, "\\TMSRPT73.txt");
hfOutputFile = _lcreat(tempString, 0);
if(hfOutputFile == HFILE_ERROR)
{
LoadString(hInst, ERROR_202, szFormatString, sizeof(szFormatString));
sprintf(szarString, szFormatString, tempString);
MessageBeep(MB_ICONSTOP);
MessageBox((HWND)NULL, szarString, TMS, MB_ICONSTOP);
goto deallocate;
}
strcpy(pPassedData->szReportDataFile[0], tempString);
//
// Go through the audit trail to get the ridership numbers
//
StatusBarStart(hWndMain, "Unloading Ridership Data");
for(tempLong = fromDate; tempLong <= toDate; tempLong++)
{
if(StatusBarAbort())
{
bKeepGoing = FALSE;
goto deallocate;
}
for(nI = 0; nI < TMSRPT73_MAXROUTES; nI++)
{
Combined[nI].ROUTESrecordID = NO_RECORD;
Combined[nI].RUNSrecordID = NO_RECORD;
for(nJ = 0; nJ < 4; nJ++)
{
Combined[nI].numFares[nJ] = 0;
Combined[nI].fareValue[nJ] = 0;
}
Combined[nI].mileageOut = 0.0;
Combined[nI].mileageIn = 0.0;
}
numCombined = 0;
DAILYOPSKey1.recordTypeFlag = DAILYOPS_FLAG_RIDERSHIP;
DAILYOPSKey1.pertainsToDate = tempLong;
DAILYOPSKey1.pertainsToTime = 0;
DAILYOPSKey1.recordFlags = 0;
bFound = FALSE;
rcode2 = btrieve(B_GETGREATEROREQUAL, TMS_DAILYOPS, &DAILYOPS, &DAILYOPSKey1, 1);
while(rcode2 == 0 &&
(DAILYOPS.recordTypeFlag & DAILYOPS_FLAG_RIDERSHIP) &&
DAILYOPS.pertainsToDate == tempLong)
{
if(DAILYOPS.recordFlags & DAILYOPS_FLAG_SETRIDERSHIP)
{
if(!ANegatedRecord(DAILYOPS.recordID, 1))
{
TRIPSKey0.recordID = DAILYOPS.DOPS.Ridership.R.TRIPSrecordID;
rcode2 = btrieve(B_GETEQUAL, TMS_TRIPS, &TRIPS, &TRIPSKey0, 0);
for(nI = 0; nI < numCombined; nI++)
{
if(Combined[nI].ROUTESrecordID == TRIPS.ROUTESrecordID)
{
bFound = TRUE;
break;
}
}
if(!bFound)
{
nI = numCombined;
Combined[nI].ROUTESrecordID = TRIPS.ROUTESrecordID;
Combined[nI].RUNSrecordID = DAILYOPS.DOPS.Ridership.R.RUNSrecordID;
numCombined++;
}
for(nJ = 0; nJ < 4; nJ++)
{
Combined[nI].numFares[nJ] += DAILYOPS.DOPS.Ridership.R.numFares[nJ];
}
}
}
rcode2 = btrieve(B_GETNEXT, TMS_DAILYOPS, &DAILYOPS, &DAILYOPSKey1, 1);
}
//
// Get the fare values for each of the routes
//
for(nI = 0; nI < numCombined; nI++)
{
for(bFound = FALSE, nJ = 0; nJ < m_numFareTypesByRoute; nJ++)
{
if(Combined[nI].ROUTESrecordID == m_FareTypesByRoute[nJ].ROUTESrecordID)
{
bFound = TRUE;
break;
}
}
if(bFound)
{
for(nK = 0; nK < 4; nK++)
{
Combined[nI].fareValue[nK] = m_FareTypesByRoute[nJ].fareValue[nK];
}
}
}
//
// Get the mileage for this run
//
DAILYOPSKey1.recordTypeFlag = DAILYOPS_FLAG_RIDERSHIP;
DAILYOPSKey1.pertainsToDate = tempLong;
DAILYOPSKey1.pertainsToTime = 0;
DAILYOPSKey1.recordFlags = 0;
bFound = FALSE;
rcode2 = btrieve(B_GETGREATEROREQUAL, TMS_DAILYOPS, &DAILYOPS, &DAILYOPSKey1, 1);
while(rcode2 == 0 &&
(DAILYOPS.recordTypeFlag & DAILYOPS_FLAG_RIDERSHIP) &&
DAILYOPS.pertainsToDate == tempLong)
{
if(DAILYOPS.recordFlags & DAILYOPS_FLAG_SETMILEAGE)
{
if(!ANegatedRecord(DAILYOPS.recordID, 1))
{
for(nI = 0; nI < numCombined; nI++)
{
if(Combined[nI].RUNSrecordID == DAILYOPS.DOPS.Ridership.M.RUNSrecordID)
{
bFound = TRUE;
break;
}
}
if(bFound)
{
Combined[nI].mileageOut = DAILYOPS.DOPS.Ridership.M.mileageOut;
Combined[nI].mileageIn = DAILYOPS.DOPS.Ridership.M.mileageIn;
}
}
}
rcode2 = btrieve(B_GETNEXT, TMS_DAILYOPS, &DAILYOPS, &DAILYOPSKey1, 1);
}
//
// Loop through Combined
//
for(nI = 0; nI < numCombined; nI++)
{
//
// Route number
//
ROUTESKey0.recordID = Combined[nI].ROUTESrecordID;
rcode2 = btrieve(B_GETEQUAL, TMS_ROUTES, &ROUTES, &ROUTESKey0, 0);
strncpy(tempString, ROUTES.number, ROUTES_NUMBER_LENGTH);
trim(tempString, ROUTES_NUMBER_LENGTH);
strcpy(outputString, tempString);
strcat(outputString, "\t");
//
// Route name
//
strncpy(tempString, ROUTES.name, ROUTES_NAME_LENGTH);
trim(tempString, ROUTES_NAME_LENGTH);
strcat(outputString, tempString);
strcat(outputString, "\t");
//
// Date
//
GetYMD(tempLong, &year, &month, &day);
sprintf(tempString, "%02ld/%02ld/%ld", month, day, year);
strcat(outputString, tempString);
strcat(outputString, "\t");
//
// Cash received
//
for(nJ = 0; nJ < 4; nJ++)
{
sprintf(tempString, "%6.02f", Combined[nI].numFares[nJ] * Combined[nI].fareValue[nJ]);
strcat(outputString, tempString);
strcat(outputString, "\t");
}
//
// Number of fares
//
for(nJ = 0; nJ < 4; nJ++)
{
sprintf(tempString, "%d", Combined[nI].numFares[nJ]);
strcat(outputString, tempString);
strcat(outputString, "\t");
}
//
// Mileage
//
sprintf(tempString, "%8.1f", Combined[nI].mileageOut);
strcat(outputString, tempString);
strcat(outputString, "\t");
sprintf(tempString, "%8.1f", Combined[nI].mileageIn);
strcat(outputString, tempString);
strcat(outputString, "\r\n");
//
// Write it out
//
_lwrite(hfOutputFile, outputString, strlen(outputString));
}
} // tempLong
bKeepGoing = TRUE;
//
// Free allocated memory
//
deallocate:
_lclose(hfOutputFile);
StatusBarEnd();
if(!bKeepGoing)
{
return(FALSE);
}
//
// All done
//
return(TRUE);
}
//
// Unassigned drivers report
//
BOOL FAR TMSRPT13(TMSRPTPassedDataDef *pPassedData)
{
HFILE hfOutputFile;
BOOL bKeepGoing = FALSE;
char szOutputString[128];
long year, month,day;
int rcode2;
int nI;
pPassedData->nReportNumber = 12;
pPassedData->numDataFiles = 1;
for(nI = 0; nI < m_LastReport; nI++)
{
if(TMSRPT[nI].originalReportNumber == pPassedData->nReportNumber)
{
StatusBarStart(hWndMain, TMSRPT[nI].szReportName);
break;
}
}
//
// Open the output file
//
StatusBarText("Cycling through roster...");
strcpy(tempString, szReportsTempFolder);
strcat(tempString, "\\tmsrpt13.txt");
hfOutputFile = _lcreat(tempString, 0);
if(hfOutputFile == HFILE_ERROR)
{
LoadString(hInst, ERROR_202, szFormatString, sizeof(szFormatString));
sprintf(szarString, szFormatString, tempString);
MessageBeep(MB_ICONSTOP);
MessageBox((HWND)NULL, szarString, TMS, MB_ICONSTOP);
goto deallocate;
}
strcpy(pPassedData->szReportDataFile[0], tempString);
//
// Loop through the drivers in seniority order
//
rcode2 = btrieve(B_GETFIRST, TMS_DRIVERS, &DRIVERS, &DRIVERSKey2, 2);
while(rcode2 == 0)
{
if(ConsideringThisDriverType(DRIVERS.DRIVERTYPESrecordID))
{
ROSTERKey2.DRIVERSrecordID = DRIVERS.recordID;
rcode2 = btrieve(B_GETEQUAL, TMS_ROSTER, &ROSTER, &ROSTERKey2, 2);
if(rcode2 != 0)
{
if(DRIVERS.DRIVERTYPESrecordID == NO_RECORD)
{
strcpy(tempString, "");
}
else
{
DRIVERTYPESKey0.recordID = DRIVERS.DRIVERTYPESrecordID;
rcode2 = btrieve(B_GETEQUAL, TMS_DRIVERTYPES, &DRIVERTYPES, &DRIVERTYPESKey0, 0);
if(rcode2 != 0)
{
strcpy(tempString, "");
}
else
{
strncpy(tempString, DRIVERTYPES.name, DRIVERTYPES_NAME_LENGTH);
trim(tempString, DRIVERTYPES_NAME_LENGTH);
}
}
strcpy(szOutputString, tempString);
strcat(szOutputString, "\t");
GetYMD(DRIVERS.seniorityDate, &year, &month, &day);
sprintf(tempString, "%4ld/%02ld/%02ld - ", year, month, day);
strcat(szOutputString, tempString);
strncpy(tempString, DRIVERS.lastName, DRIVERS_LASTNAME_LENGTH);
trim(tempString, DRIVERS_LASTNAME_LENGTH);
strcat(szOutputString, tempString);
strcat(szOutputString, ", ");
strncpy(tempString, DRIVERS.firstName, DRIVERS_FIRSTNAME_LENGTH);
trim(tempString, DRIVERS_FIRSTNAME_LENGTH);
strcat(szOutputString, tempString);
strncpy(tempString, DRIVERS.badgeNumber, DRIVERS_BADGENUMBER_LENGTH);
trim(tempString, DRIVERS_BADGENUMBER_LENGTH);
if(strcmp(tempString, "") != 0)
{
strcat(szOutputString, " (Badge ");
strcat(szOutputString, tempString);
strcat(szOutputString, ")");
}
strcat(szOutputString, "\r\n");
_lwrite(hfOutputFile, szOutputString, strlen(szOutputString));
}
}
rcode2 = btrieve(B_GETNEXT, TMS_DRIVERS, &DRIVERS, &DRIVERSKey2, 2);
}
bKeepGoing = TRUE;
//
// Free allocated memory / close output file
//
deallocate:
_lclose(hfOutputFile);
StatusBarEnd();
if(!bKeepGoing)
return(FALSE);
//
// All done
//
return(TRUE);
}
BOOL FAR TMSRPT04(TMSRPTPassedDataDef *pPassedData)
{
GenerateTripDef GTResults;
REPORTPARMSDef REPORTPARMS;
HFILE hfOutputFile;
BOOL bKeepGoing = FALSE;
BOOL bRC;
char routeNumber[ROUTES_NUMBER_LENGTH + 1];
char serviceName[SERVICES_NAME_LENGTH + 1];
char outputString[512];
long statbarTotal;
int nI;
int nJ;
int nK;
int nL;
int rcode2;
pPassedData->nReportNumber = 3;
pPassedData->numDataFiles = 1;
//
// See what he wants
//
REPORTPARMS.nReportNumber = pPassedData->nReportNumber;
REPORTPARMS.ROUTESrecordID = m_RouteRecordID;
REPORTPARMS.SERVICESrecordID = m_ServiceRecordID;
REPORTPARMS.COMMENTSrecordID = NO_RECORD;
REPORTPARMS.pRouteList = NULL;
REPORTPARMS.pServiceList = NULL;
REPORTPARMS.flags = RPFLAG_ROUTES | RPFLAG_SERVICES | RPFLAG_COMMENTS;
bRC = DialogBoxParam(hInst, MAKEINTRESOURCE(IDD_RPTPARMS),
hWndMain, (DLGPROC)RPTPARMSMsgProc, (LPARAM)&REPORTPARMS);
if(!bRC)
{
return(FALSE);
}
//
// Check the list of routes and services
//
if(REPORTPARMS.numRoutes == 0 || REPORTPARMS.numServices == 0)
{
goto deallocate;
}
//
// Open the output file
//
strcpy(tempString, szReportsTempFolder);
strcat(tempString, "\\tmsrpt04.txt");
hfOutputFile = _lcreat(tempString, 0);
if(hfOutputFile == HFILE_ERROR)
{
LoadString(hInst, ERROR_202, szFormatString, sizeof(szFormatString));
sprintf(szarString, szFormatString, tempString);
MessageBeep(MB_ICONSTOP);
MessageBox((HWND)NULL, szarString, TMS, MB_ICONSTOP);
goto deallocate;
}
strcpy(pPassedData->szReportDataFile[0], tempString);
//
// Loop through the routes
//
LoadString(hInst, TEXT_117, tempString, TEMPSTRING_LENGTH);
StatusBarStart(hWndMain, tempString);
statbarTotal = REPORTPARMS.numRoutes * REPORTPARMS.numServices;
for(nI = 0; nI < REPORTPARMS.numRoutes; nI++)
{
if(StatusBarAbort())
{
bKeepGoing = FALSE;
goto deallocate;
}
ROUTESKey0.recordID = REPORTPARMS.pRouteList[nI];
rcode2 = btrieve(B_GETEQUAL, TMS_ROUTES, &ROUTES, &ROUTESKey0, 0);
if(rcode2 != 0)
{
continue;
}
strncpy(routeNumber, ROUTES.number, ROUTES_NUMBER_LENGTH);
trim(routeNumber, ROUTES_NUMBER_LENGTH);
//
// Loop through the services
//
for(nJ = 0; nJ < REPORTPARMS.numServices; nJ++)
{
if(StatusBarAbort())
{
bKeepGoing = FALSE;
goto deallocate;
}
SERVICESKey0.recordID = REPORTPARMS.pServiceList[nJ];
rcode2 = btrieve(B_GETEQUAL, TMS_SERVICES, &SERVICES, &SERVICESKey0, 0);
if(rcode2 != 0)
{
continue;
}
strncpy(serviceName, SERVICES.name, SERVICES_NAME_LENGTH);
trim(serviceName, SERVICES_NAME_LENGTH);
LoadString(hInst, TEXT_118, szarString, sizeof(szarString));
sprintf(tempString, szarString, routeNumber, serviceName);
StatusBarText(tempString);
StatusBar((long)(nI * REPORTPARMS.numServices + nJ), (long)statbarTotal);
if(StatusBarAbort())
{
bKeepGoing = FALSE;
goto deallocate;
}
//
// Loop through the directions
//
for(nK = 0; nK < 2; nK++)
{
if(StatusBarAbort())
{
bKeepGoing = FALSE;
goto deallocate;
}
if(ROUTES.DIRECTIONSrecordID[nK] == NO_RECORD)
{
continue;
}
DIRECTIONSKey0.recordID = ROUTES.DIRECTIONSrecordID[nK];
rcode2 = btrieve(B_GETEQUAL, TMS_DIRECTIONS, &DIRECTIONS, &DIRECTIONSKey0, 0);
if(rcode2 != 0)
{
continue;
}
m_bEstablishRUNTIMES = TRUE;
//
// Get all the trips
//
TRIPSKey1.ROUTESrecordID = REPORTPARMS.pRouteList[nI];
TRIPSKey1.SERVICESrecordID = REPORTPARMS.pServiceList[nJ];
TRIPSKey1.directionIndex = nK;
TRIPSKey1.tripSequence = NO_TIME;
rcode2 = btrieve(B_GETGREATEROREQUAL, TMS_TRIPS, &TRIPS, &TRIPSKey1, 1);
while(rcode2 == 0 &&
TRIPS.ROUTESrecordID == REPORTPARMS.pRouteList[nI] &&
TRIPS.SERVICESrecordID == REPORTPARMS.pServiceList[nJ] &&
TRIPS.directionIndex == nK)
{
//
// Generate the trip
//
GenerateTrip(TRIPS.ROUTESrecordID, TRIPS.SERVICESrecordID,
TRIPS.directionIndex, TRIPS.PATTERNNAMESrecordID,
TRIPS.timeAtMLP, GENERATETRIP_FLAG_DISPLAYERRORS, >Results);
//
// Set up the output string
//
strcpy(outputString, "");
for(nL = 0; nL < NUMCOLS; nL++)
{
switch(nL)
{
//
// Route number
//
case 0:
strncpy(tempString, ROUTES.number, ROUTES_NUMBER_LENGTH);
tempString[ROUTES_NUMBER_LENGTH] = '\0';
sprintf(szarString, "\"%s\"", tempString);
break;
//
// Route name
//
case 1:
strncpy(tempString, ROUTES.name, ROUTES_NAME_LENGTH);
tempString[ROUTES_NAME_LENGTH] = '\0';
sprintf(szarString, "\"%s\"", tempString);
break;
//
// Service Name
//
case 2:
strncpy(tempString, SERVICES.name, SERVICES_NAME_LENGTH);
tempString[SERVICES_NAME_LENGTH] = '\0';
sprintf(szarString, "\"%s\"", tempString);
break;
//
// Direction
//
case 3:
strncpy(tempString, DIRECTIONS.longName, DIRECTIONS_LONGNAME_LENGTH);
tempString[DIRECTIONS_LONGNAME_LENGTH] = '\0';
sprintf(szarString, "\"%s\"", tempString);
break;
//
// Trip time (in minutes)
//
case 4:
sprintf(szarString, "%ld", GTResults.lastNodeTime - GTResults.firstNodeTime);
break;
//
// Distance
//
case 5:
sprintf(szarString, "%7.2f", GTResults.tripDistance);
break;
} // End of switch
strcat(outputString, szarString);
strcat(outputString, nL == NUMCOLS - 1 ? "\r\n" : "\t");
} // nL
_lwrite(hfOutputFile, outputString, strlen(outputString));
rcode2 = btrieve(B_GETNEXT, TMS_TRIPS, &TRIPS, &TRIPSKey1, 1);
} // while
} // nK
} // nJ
} // nI
bKeepGoing = TRUE;
//
// Free allocated memory
//
deallocate:
TMSHeapFree(REPORTPARMS.pRouteList);
TMSHeapFree(REPORTPARMS.pServiceList);
_lclose(hfOutputFile);
StatusBarEnd();
if(!bKeepGoing)
{
return(FALSE);
}
//
// All done
//
return(TRUE);
}
void XInit(PFileVar fv, PXVar xv, PComVar cv, PTTSet ts) {
char inistr[MAX_PATH + 10];
fv->LogFlag = ((ts->LogFlag & LOG_X) != 0);
if (fv->LogFlag)
fv->LogFile = _lcreat("XMODEM.LOG", 0);
fv->LogState = 0;
fv->LogCount = 0;
fv->FileSize = 0;
if ((xv->XMode == IdXSend) && fv->FileOpen) {
fv->FileSize = GetFSize(fv->FullName);
InitDlgProgress(fv->HWin, IDC_PROTOPROGRESS, &fv->ProgStat);
} else {
fv->ProgStat = -1;
}
fv->StartTime = GetTickCount();
SetWindowText(fv->HWin, fv->DlgCaption);
SetDlgItemText(fv->HWin, IDC_PROTOFNAME, &(fv->FullName[fv->DirLen]));
xv->PktNumOffset = 0;
xv->PktNum = 0;
xv->PktNumSent = 0;
xv->PktBufCount = 0;
xv->CRRecv = FALSE;
fv->ByteCount = 0;
if (cv->PortType == IdTCPIP) {
xv->TOutShort = TimeOutVeryLong;
xv->TOutLong = TimeOutVeryLong;
} else {
xv->TOutShort = TimeOutShort;
xv->TOutLong = TimeOutLong;
}
XSetOpt(fv, xv, xv->XOpt);
if (xv->XOpt == XoptCheck) {
xv->NAKMode = XnakNAK;
xv->NAKCount = 10;
} else {
xv->NAKMode = XnakC;
xv->NAKCount = 3;
}
switch (xv->XMode) {
case IdXSend:
xv->TextFlag = 0;
// ファイル送信開始前に、"rx ファイル名"を自動的に呼び出す。(2007.12.20 yutaka)
if (ts->XModemRcvCommand[0] != '\0') {
_snprintf_s(inistr, sizeof(inistr), _TRUNCATE, "%s %s\015",
ts->XModemRcvCommand, &(fv->FullName[fv->DirLen]));
FTConvFName(inistr + strlen(ts->XModemRcvCommand) + 1);
XWrite(fv, xv, cv, inistr, strlen(inistr));
}
FTSetTimeOut(fv, TimeOutVeryLong);
break;
case IdXReceive:
XSendNAK(fv, xv, cv);
break;
}
}
BOOL FAR TMSRPT67(TMSRPTPassedDataDef *pPassedData)
{
NodesAndStopsDef NodesAndStops[TMSRPT67_MAXNODESANDSTOPS];
GetConnectionTimeDef GCTData;
GenerateTripDef GTResults;
BLOCKSDef *pTRIPSChunk;
double prevLat, prevLon;
HFILE hfOutputFile;
HFILE hfErrorLog;
float distanceToHere;
float tripDistances[100];
float distance;
struct tm tmED, tmUD, today;
time_t EDmktime;
time_t UDmktime;
time_t now;
BOOL bFound;
BOOL bGotError;
BOOL bFinishedOK;
BOOL bBikeRack;
BOOL bFirst;
long SERVICESinEffect[TMSRPT66_MAXSERVICES];
long year, month, day;
long serviceRecordID;
long previousPattern;
long timeAtStop;
long absRecID;
long stopFlags;
long stopNumber;
long assignedToNODESrecordID;
long blockNumber;
long fromNODESrecordID;
long toNODESrecordID;
long toTime;
long fromTime;
long dhd;
long number;
char outputString[1024];
char outputStringSave[1024];
char out2[1024];
char *ptr;
char *pszReportName;
char outputFileName[64];
char szServiceCode[SERVICES_NAME_LENGTH + 1];
char szTripCode[16];
int nI;
int rcode2;
int dayOfWeek;
int numServices;
int tripIndex;
int numNodes;
int seq;
bFinishedOK = FALSE;
//
// Maintain the distance measure
//
distanceMeasureSave = distanceMeasure;
distanceMeasure = PREFERENCES_MILES;
//
// Set up the trip planner
//
if(bUseDynamicTravels)
{
if(bUseCISPlan)
{
CISfree();
if(!CISbuild(FALSE, TRUE))
{
goto done;
}
}
else
{
rcode2 = btrieve(B_GETFIRST, TMS_SERVICES, &SERVICES, &SERVICESKey1, 1);
while(rcode2 == 0)
{
serviceRecordID = SERVICES.recordID;
InitTravelMatrix(serviceRecordID, TRUE);
SERVICESKey0.recordID = serviceRecordID;
btrieve(B_GETEQUAL, TMS_SERVICES, &SERVICES, &SERVICESKey0, 0);
btrieve(B_GETPOSITION, TMS_SERVICES, &SERVICES, &SERVICESKey0, 0);
btrieve(B_GETDIRECT, TMS_SERVICES, &SERVICES, &SERVICESKey1, 1);
rcode2 = btrieve(B_GETNEXT, TMS_SERVICES, &SERVICES, &SERVICESKey1, 1);
}
}
}
//
// Create the sub-folder for the output files and chdir into it
//
nI = (_mkdir(OUTPUT_FOLDER_NAME) == 0) ? TEXT_333 : TEXT_334;
LoadString(hInst, nI, szFormatString, SZFORMATSTRING_LENGTH);
sprintf(tempString, szFormatString, OUTPUT_FOLDER_NAME);
MessageBeep(MB_ICONINFORMATION);
MessageBox(NULL, tempString, TMS, MB_OK);
chdir(OUTPUT_FOLDER_NAME);
//
// Open the error log and fire up the status bar
//
hfErrorLog = _lcreat("error.log", 0);
if(hfErrorLog == HFILE_ERROR)
{
TMSError((HWND)NULL, MB_ICONSTOP, ERROR_226, (HANDLE)NULL);
goto done;
}
bGotError = FALSE;
pPassedData->nReportNumber = 66;
for(nI = 0; nI < m_LastReport; nI++)
{
if(TMSRPT[nI].originalReportNumber == pPassedData->nReportNumber)
{
pszReportName = TMSRPT[nI].szReportName;
StatusBarStart(hWndMain, TMSRPT[nI].szReportName);
break;
}
}
//
// Get today's date
//
time(&now);
today = *localtime(&now);
//
// ==============================
// Service File - oci_service.csv
// ==============================
//
if(StatusBarAbort())
{
goto done;
}
strcpy(outputFileName, "oci_service.csv");
hfOutputFile = _lcreat(outputFileName, 0);
if(hfOutputFile == HFILE_ERROR)
{
LoadString(hInst, ERROR_320, szFormatString, SZFORMATSTRING_LENGTH);
sprintf(szarString, szFormatString, outputFileName);
MessageBeep(MB_ICONSTOP);
MessageBox(NULL, szarString, TMS, MB_OK | MB_ICONSTOP);
goto done;
}
StatusBarText(outputFileName);
//
// Write out the header
//
strcpy(outputString, "\"ServiceCode\",\"Date\"\r\n");
_lwrite(hfOutputFile, outputString, strlen(outputString));
numServices = 0;
//
// Dump out the service day based on calendar days
//
// Effective date
//
GetYMD(effectiveDate, &year, &month, &day);
memset(&tmED, 0x00, sizeof(tmED));
tmED.tm_mday = day;
tmED.tm_mon = month - 1;
tmED.tm_year = year - 1900;
//
// Until date
//
GetYMD(untilDate, &year, &month, &day);
memset(&tmUD, 0x00, sizeof(tmUD));
tmUD.tm_mday = day;
tmUD.tm_mon = month - 1;
tmUD.tm_year = year - 1900;
//
// Start at the effective date and go to the until date
//
EDmktime = mktime(&tmED);
if(EDmktime == (time_t)(-1))
{
LoadString(hInst, ERROR_328, szFormatString, SZFORMATSTRING_LENGTH);
sprintf(outputString, szFormatString, 1);
_lwrite(hfErrorLog, outputString, strlen(outputString));
bGotError = TRUE;
}
else
{
UDmktime = mktime(&tmUD);
while(EDmktime <= UDmktime)
{
if(StatusBarAbort())
{
goto done;
}
dayOfWeek = (tmED.tm_wday == 0 ? 6 : tmED.tm_wday - 1);
for(bFound = FALSE, nI = 0; nI < numServices; nI++)
{
if(ROSTERPARMS.serviceDays[dayOfWeek] == SERVICESinEffect[nI])
{
bFound = TRUE;
break;
}
}
if(!bFound)
{
SERVICESinEffect[numServices] = ROSTERPARMS.serviceDays[dayOfWeek];
numServices++;
}
//
// ServiceCode (SERVICES.recordID)
//
SERVICESKey0.recordID = ROSTERPARMS.serviceDays[dayOfWeek];
btrieve(B_GETEQUAL, TMS_SERVICES, &SERVICES, &SERVICESKey0, 0);
strncpy(tempString, SERVICES.name, SERVICES_NAME_LENGTH);
trim(tempString, SERVICES_NAME_LENGTH);
sprintf(szarString, "\"%s\",", tempString);
strcpy(outputString, szarString);
//
// Date
//
sprintf(szarString, "\"%4ld%02ld%02ld\"\r\n", tmED.tm_year + 1900, tmED.tm_mon + 1, tmED.tm_mday);
strcat(outputString, szarString);
//
// Write out the record
//
_lwrite(hfOutputFile, outputString, strlen(outputString));
//
// Figure out the next day
//
tmED.tm_mday++;
EDmktime = mktime(&tmED);
if(EDmktime == (time_t)(-1))
{
LoadString(hInst, ERROR_328, szFormatString, SZFORMATSTRING_LENGTH);
sprintf(outputString, szFormatString, 1);
_lwrite(hfErrorLog, outputString, strlen(outputString));
bGotError = TRUE;
}
}
}
//
// Close the file
//
_lclose(hfOutputFile);
//
// ============================
// Routes File - oci_routes.csv
// ============================
//
if(StatusBarAbort())
{
goto done;
}
strcpy(outputFileName, "oci_routes.csv");
hfOutputFile = _lcreat(outputFileName, 0);
if(hfOutputFile == HFILE_ERROR)
{
LoadString(hInst, ERROR_320, szFormatString, SZFORMATSTRING_LENGTH);
sprintf(szarString, szFormatString, outputFileName);
MessageBeep(MB_ICONSTOP);
MessageBox(NULL, szarString, TMS, MB_OK | MB_ICONSTOP);
goto done;
}
StatusBarText(outputFileName);
//
// Write out the header
//
strcpy(outputString, "\"RouteCode\",\"RouteName\",\"DirectionCode\",\"DirectionName\",\"PatternCode\",\"PatternName\"\r\n");
_lwrite(hfOutputFile, outputString, strlen(outputString));
//
// Traverse the Routes Table
//
rcode2 = btrieve(B_GETFIRST, TMS_ROUTES, &ROUTES, &ROUTESKey1, 1);
while(rcode2 == 0)
{
if(StatusBarAbort())
{
goto done;
}
//
// Go through the directions
//
for(nI = 0; nI < 2; nI++)
{
if(ROUTES.DIRECTIONSrecordID[nI] == NO_RECORD)
{
continue;
}
//
// RouteCode (ROUTES.number)
//
strncpy(tempString, ROUTES.number, ROUTES_NUMBER_LENGTH);
trim(tempString, ROUTES_NUMBER_LENGTH);
ptr = tempString;
while(ptr && *ptr == ' ')
{
ptr++;
}
sprintf(szarString, "\"%s\",", ptr);
strcpy(outputString, szarString);
//
// RouteName (ROUTES.name)
//
strncpy(tempString, ROUTES.name, ROUTES_NAME_LENGTH);
trim(tempString, ROUTES_NAME_LENGTH);
sprintf(szarString, "\"%s\",", tempString);
strcat(outputString, szarString);
//
// DirectionCode (DIRECTIONS.abbrName)
//
DIRECTIONSKey0.recordID = ROUTES.DIRECTIONSrecordID[nI];
btrieve(B_GETEQUAL, TMS_DIRECTIONS, &DIRECTIONS, &DIRECTIONSKey0, 0);
strncpy(tempString, DIRECTIONS.abbrName, DIRECTIONS_ABBRNAME_LENGTH);
trim(tempString, DIRECTIONS_ABBRNAME_LENGTH);
sprintf(szarString, "\"%s\",", tempString);
strcat(outputString, szarString);
//
// DirectionName (DIRECTIONS.longName)
//
DIRECTIONSKey0.recordID = ROUTES.DIRECTIONSrecordID[nI];
btrieve(B_GETEQUAL, TMS_DIRECTIONS, &DIRECTIONS, &DIRECTIONSKey0, 0);
strncpy(tempString, DIRECTIONS.longName, DIRECTIONS_LONGNAME_LENGTH);
trim(tempString, DIRECTIONS_LONGNAME_LENGTH);
sprintf(szarString, "\"%s\",", tempString);
strcat(outputString, szarString);
//
// Cycle through the patterns for route/service/direction
//
strcpy(outputStringSave, outputString);
rcode2 = btrieve(B_GETFIRST, TMS_SERVICES, &SERVICES, &SERVICESKey0, 0);
while(rcode2 == 0)
{
PATTERNSKey2.ROUTESrecordID = ROUTES.recordID;
PATTERNSKey2.SERVICESrecordID = SERVICES.recordID;
PATTERNSKey2.PATTERNNAMESrecordID = basePatternRecordID;
PATTERNSKey2.directionIndex = nI;
PATTERNSKey2.nodeSequence = NO_RECORD;
previousPattern = NO_RECORD;
rcode2 = btrieve(B_GETGREATER, TMS_PATTERNS, &PATTERNS, &PATTERNSKey2, 2);
while(rcode2 == 0 &&
PATTERNS.ROUTESrecordID == ROUTES.recordID &&
PATTERNS.SERVICESrecordID == SERVICES.recordID &&
PATTERNS.directionIndex == nI)
{
if(PATTERNS.PATTERNNAMESrecordID != previousPattern)
{
//
// PatternCode (SERVICES.recordID-PATTERNNAMES.recordID)
//
sprintf(szarString, "\"%ld-%ld\",", SERVICES.recordID, PATTERNS.PATTERNNAMESrecordID);
strcat(outputString, szarString);
//
// PatternName (PATTERNNAMES.name)
//
PATTERNNAMESKey0.recordID = PATTERNS.PATTERNNAMESrecordID;
btrieve(B_GETEQUAL, TMS_PATTERNNAMES, &PATTERNNAMES, &PATTERNNAMESKey0, 0);
strncpy(tempString, PATTERNNAMES.name, PATTERNNAMES_NAME_LENGTH);
trim(tempString, PATTERNNAMES_NAME_LENGTH);
sprintf(szarString, "\"%s\"\r\n", tempString);
strcat(outputString, szarString);
//
// Write out the record and get the next pattern
//
_lwrite(hfOutputFile, outputString, strlen(outputString));
strcpy(outputString, outputStringSave);
previousPattern = PATTERNS.PATTERNNAMESrecordID;
}
rcode2 = btrieve(B_GETNEXT, TMS_PATTERNS, &PATTERNS, &PATTERNSKey2, 2);
}
rcode2 = btrieve(B_GETNEXT, TMS_SERVICES, &SERVICES, &SERVICESKey0, 0);
}
} // nI
//
// Get the next route
//
rcode2 = btrieve(B_GETNEXT, TMS_ROUTES, &ROUTES, &ROUTESKey1, 1);
}
//
// Close the file
//
_lclose(hfOutputFile);
//
// ==============================
// Bus Stops File - oci_stops.csv
// ==============================
//
if(StatusBarAbort())
{
goto done;
}
strcpy(outputFileName, "oci_stops.csv");
hfOutputFile = _lcreat(outputFileName, 0);
if(hfOutputFile == HFILE_ERROR)
{
LoadString(hInst, ERROR_320, szFormatString, SZFORMATSTRING_LENGTH);
sprintf(szarString, szFormatString, outputFileName);
MessageBeep(MB_ICONSTOP);
MessageBox(NULL, szarString, TMS, MB_OK | MB_ICONSTOP);
goto done;
}
//
// Write out the header
//
strcpy(outputString, "\"StopCode\",\"StopName\",\"Latitude\",\"Longitude\",\"Shelter\",\"Bench\",\"Accessible\",\"TimingPoint\"\r\n");
_lwrite(hfOutputFile, outputString, strlen(outputString));
StatusBarText(outputFileName);
//
// Get the list of nodes
//
//
// Cycle through the Nodes Table to get associated stop numbers
//
rcode2 = btrieve(B_GETFIRST, TMS_NODES, &NODES, &NODESKey0, 0);
numNodes = 0;
while(rcode2 == 0)
{
if(!(NODES.flags & NODES_FLAG_STOP))
{
NodesAndStops[numNodes].NODESrecordID = NODES.recordID;
NodesAndStops[numNodes].StopNumber = NODES.number;
NodesAndStops[numNodes].OutboundStopNumber = NODES.OBStopNumber;
NodesAndStops[numNodes].InboundStopNumber = NODES.IBStopNumber;
numNodes++;
if(numNodes >= TMSRPT67_MAXNODESANDSTOPS)
{
MessageBeep(MB_ICONSTOP);
MessageBox(NULL, "TMSRPT67_MAXNODESANDSTOPS Exceeded.\n\nPlease contact Schedule Masters, Inc. for help", TMS, MB_OK | MB_ICONSTOP);
goto done;
}
}
rcode2 = btrieve(B_GETNEXT, TMS_NODES, &NODES, &NODESKey0, 0);
}
//
// Cycle through the Nodes Table
//
rcode2 = btrieve(B_GETFIRST, TMS_NODES, &NODES, &NODESKey0, 0);
while(rcode2 == 0)
{
//
// StopCode (NODES.number or NODES.abbrName)
//
if(NODES.flags & NODES_FLAG_STOP)
{
sprintf(szarString, "\"%04ld\",", NODES.number);
}
else
{
// strncpy(tempString, NODES.abbrName, NODES_ABBRNAME_LENGTH);
// trim(tempString, NODES_ABBRNAME_LENGTH);
// sprintf(szarString, "\"%s\",", tempString);
if(nI == 0)
{
number = (NODES.OBStopNumber <= 0 ? NODES.number : NODES.OBStopNumber);
}
else
{
number = (NODES.IBStopNumber <= 0 ? NODES.number : NODES.IBStopNumber);
}
sprintf(szarString, "\"%04ld\",", number);
}
strcpy(outputString, szarString);
//
// StopName (NODES.intersection)
//
strncpy(tempString, NODES.intersection, NODES_INTERSECTION_LENGTH);
trim(tempString, NODES_INTERSECTION_LENGTH);
ptr = strstr(tempString, "&&");
if(ptr)
{
*ptr = 'a';
*(ptr + 1) = 't';
}
sprintf(szarString, "\"%s\",", tempString);
strcat(outputString, szarString);
//
// Latitude (NODES.latitude)
//
sprintf(tempString, "%12.6f", NODES.latitude);
ptr = tempString;
while(ptr && *ptr == ' ')
{
ptr++;
}
sprintf(szarString, "\"%s\",", ptr);
strcat(outputString, szarString);
//
// Longitude (NODES.longitude)
//
sprintf(tempString, "%12.6f", NODES.longitude);
ptr = tempString;
while(ptr && *ptr == ' ')
{
ptr++;
}
sprintf(szarString, "\"%s\",", ptr);
strcat(outputString, szarString);
//
// If this isn't a stop, look to see if we can find the stop in the Nodes Table
//
if(NODES.flags & NODES_FLAG_STOP)
{
stopFlags = NODES.stopFlags;
}
else
{
stopFlags = 0;
stopNumber = NO_RECORD;
if(NODES.number > 0)
{
stopNumber = NODES.number;
}
if(stopNumber == NO_RECORD && NODES.OBStopNumber > 0)
{
stopNumber = NODES.OBStopNumber;
}
if(stopNumber == NO_RECORD && NODES.IBStopNumber > 0)
{
stopNumber = NODES.IBStopNumber;
}
if(stopNumber != NO_RECORD)
{
btrieve(B_GETPOSITION, TMS_NODES, &absRecID, &NODESKey0, 0);
rcode2 = btrieve(B_GETFIRST, TMS_NODES, &NODES, &NODESKey0, 0);
while(rcode2 == 0)
{
if(NODES.flags & NODES_FLAG_STOP)
{
if(NODES.number == stopNumber)
{
stopFlags = NODES.stopFlags;
break;
}
}
rcode2 = btrieve(B_GETNEXT, TMS_NODES, &NODES, &NODESKey0, 0);
}
NODES.recordID = absRecID;
btrieve(B_GETDIRECT, TMS_NODES, &NODES, &NODESKey0, 0);
}
}
//
// Shelter (item 12 from "Stop Flags.txt")
//
sprintf(tempString, (stopFlags & (1 << 12) ? "True" : "False"));
sprintf(szarString, "\"%s\",", tempString);
strcat(outputString, szarString);
//
// Bench (item 5 from "Stop Flags.txt")
//
sprintf(tempString, (stopFlags & (1 << 5) ? "True" : "False"));
sprintf(szarString, "\"%s\",", tempString);
strcat(outputString, szarString);
//
// Accessible (item 16 from "Stop Flags.txt")
//
sprintf(tempString, (stopFlags & (1 << 6) ? "True" : "False"));
sprintf(szarString, "\"%s\",", tempString);
strcat(outputString, szarString);
//
// Timing point?
//
if(!(NODES.flags & NODES_FLAG_STOP))
{
bFound = TRUE;
}
else
{
bFound = FALSE;
for(nI = 0; nI < numNodes; nI++)
{
if(NodesAndStops[nI].StopNumber == NODES.number ||
NodesAndStops[nI].OutboundStopNumber == NODES.number ||
NodesAndStops[nI].InboundStopNumber == NODES.number)
{
bFound = TRUE;
break;
}
}
}
sprintf(tempString, (bFound ? "True" : "False"));
sprintf(szarString, "\"%s\"\r\n", tempString);
strcat(outputString, szarString);
//
// Write it out and get the next node
//
_lwrite(hfOutputFile, outputString, strlen(outputString));
rcode2 = btrieve(B_GETNEXT, TMS_NODES, &NODES, &NODESKey0, 0);
}
//
// Close the file
//
_lclose(hfOutputFile);
//
// ====================================
// Bus Patterns File - oci_patterns.csv
// ====================================
//
if(StatusBarAbort())
{
goto done;
}
strcpy(outputFileName, "oci_patterns.csv");
hfOutputFile = _lcreat(outputFileName, 0);
if(hfOutputFile == HFILE_ERROR)
{
LoadString(hInst, ERROR_320, szFormatString, SZFORMATSTRING_LENGTH);
sprintf(szarString, szFormatString, outputFileName);
MessageBeep(MB_ICONSTOP);
MessageBox(NULL, szarString, TMS, MB_OK | MB_ICONSTOP);
goto done;
}
//
// Write out the header
//
strcpy(outputString, "\"RouteCode\",\"DirectionCode\",\"PatternCode\",\"StopCode\",\"Sequence\"\r\n");
_lwrite(hfOutputFile, outputString, strlen(outputString));
StatusBarText(outputFileName);
//
// Traverse the Routes Table
//
rcode2 = btrieve(B_GETFIRST, TMS_ROUTES, &ROUTES, &ROUTESKey1, 1);
while(rcode2 == 0)
{
if(StatusBarAbort())
{
goto done;
}
for(nI = 0; nI < 2; nI++)
{
if(ROUTES.DIRECTIONSrecordID[nI] == NO_RECORD)
{
continue;
}
//
// RouteCode (ROUTES.number)
//
strncpy(tempString, ROUTES.number, ROUTES_NUMBER_LENGTH);
trim(tempString, ROUTES_NUMBER_LENGTH);
ptr = tempString;
while(ptr && *ptr == ' ')
{
ptr++;
}
sprintf(szarString, "\"%s\",", ptr);
strcpy(outputString, szarString);
//
// DirectionCode (DIRECTIONS.abbrName)
//
DIRECTIONSKey0.recordID = ROUTES.DIRECTIONSrecordID[nI];
btrieve(B_GETEQUAL, TMS_DIRECTIONS, &DIRECTIONS, &DIRECTIONSKey0, 0);
strncpy(tempString, DIRECTIONS.abbrName, DIRECTIONS_ABBRNAME_LENGTH);
trim(tempString, DIRECTIONS_ABBRNAME_LENGTH);
sprintf(szarString, "\"%s\",", tempString);
strcat(outputString, szarString);
//
// Go through all the services
//
strcpy(outputStringSave, outputString);
rcode2 = btrieve(B_GETFIRST, TMS_SERVICES, &SERVICES, &SERVICESKey0, 0);
while(rcode2 == 0)
{
//
// Go through all the patterns
//
PATTERNSKey2.ROUTESrecordID = ROUTES.recordID;
PATTERNSKey2.SERVICESrecordID = SERVICES.recordID;
PATTERNSKey2.PATTERNNAMESrecordID = basePatternRecordID;
PATTERNSKey2.directionIndex = nI;
PATTERNSKey2.nodeSequence = -1;
rcode2 = btrieve(B_GETGREATER, TMS_PATTERNS, &PATTERNS, &PATTERNSKey2, 2);
previousPattern = NO_RECORD;
while(rcode2 == 0 &&
PATTERNS.ROUTESrecordID == ROUTES.recordID &&
PATTERNS.SERVICESrecordID == SERVICES.recordID &&
PATTERNS.directionIndex == nI)
{
if(previousPattern != PATTERNS.PATTERNNAMESrecordID)
{
previousPattern = PATTERNS.PATTERNNAMESrecordID;
seq = 1;
}
//
// PatternCode (SERVICES.recordID-PATTERNS.PATTERNNAMESrecordID)
//
sprintf(szarString, "\"%ld-%ld\",", SERVICES.recordID, PATTERNS.PATTERNNAMESrecordID);
strcat(outputString, szarString);
//
// StopCode (NODES.number or NODES.abbrName)
//
NODESKey0.recordID = PATTERNS.NODESrecordID;
btrieve(B_GETEQUAL, TMS_NODES, &NODES, &NODESKey0, 0);
if(!(NODES.flags & NODES_FLAG_STOP))
{
if(nI == 0)
{
number = (NODES.OBStopNumber <= 0 ? NODES.number : NODES.OBStopNumber);
}
else
{
number = (NODES.IBStopNumber <= 0 ? NODES.number : NODES.IBStopNumber);
}
sprintf(tempString, "%04ld", number);
// strncpy(tempString, NODES.abbrName, NODES_ABBRNAME_LENGTH);
// trim(tempString, NODES_ABBRNAME_LENGTH);
}
else
{
sprintf(tempString, "%04ld", NODES.number);
}
sprintf(szarString, "\"%s\",", tempString);
strcat(outputString, szarString);
//
// Sequence
//
sprintf(tempString, "\"%d\"\r\n", seq++);
strcat(outputString, tempString);
//
// Write it out and get the next node on the pattern
//
_lwrite(hfOutputFile, outputString, strlen(outputString));
strcpy(outputString, outputStringSave);
rcode2 = btrieve(B_GETNEXT, TMS_PATTERNS, &PATTERNS, &PATTERNSKey2, 2);
} // while on patterns
rcode2 = btrieve(B_GETNEXT, TMS_SERVICES, &SERVICES, &SERVICESKey0, 0);
}
} // nI
//
// Get the next route
//
rcode2 = btrieve(B_GETNEXT, TMS_ROUTES, &ROUTES, &ROUTESKey1, 1);
}
//
// Close the file
//
_lclose(hfOutputFile);
//
// ==========================================
// Bus Trips File - oci_trips_{RouteCode}.dat
// ==========================================
//
//
// Traverse the Routes Table
//
rcode2 = btrieve(B_GETFIRST, TMS_ROUTES, &ROUTES, &ROUTESKey1, 1);
while(rcode2 == 0)
{
if(StatusBarAbort())
{
goto done;
}
strncpy(tempString, ROUTES.number, ROUTES_NUMBER_LENGTH);
trim(tempString, ROUTES_NUMBER_LENGTH);
ptr = tempString;
while(ptr && *ptr == ' ')
{
ptr++;
}
sprintf(outputFileName, "oci_trips_%s.csv", ptr);
hfOutputFile = _lcreat(outputFileName, 0);
if(hfOutputFile == HFILE_ERROR)
{
LoadString(hInst, ERROR_320, szFormatString, SZFORMATSTRING_LENGTH);
sprintf(szarString, szFormatString, outputFileName);
MessageBeep(MB_ICONSTOP);
MessageBox(NULL, szarString, TMS, MB_OK | MB_ICONSTOP);
goto done;
}
//
// Write out the header
//
strcpy(outputString, "\"RouteCode\",\"DirectionCode\",\"PatternCode\",\"TripCode\",\"StopCode\",\"Sequence\",\"ArrivalTime\",\"DepartureTime\",\"TimingPoint\",\"Bicycles\",\"ServiceCode\"\r\n");
_lwrite(hfOutputFile, outputString, strlen(outputString));
StatusBarText(outputFileName);
//
// Go through the services
//
rcode2 = btrieve(B_GETFIRST, TMS_SERVICES, &SERVICES, &SERVICESKey1, 1);
while(rcode2 == 0)
{
if(StatusBarAbort())
{
goto done;
}
strncpy(szServiceCode, SERVICES.name, SERVICES_NAME_LENGTH);
trim(szServiceCode, SERVICES_NAME_LENGTH);
//
// Loop through the directions
//
for(nI = 0; nI < 2; nI++)
{
if(ROUTES.DIRECTIONSrecordID[nI] == NO_RECORD)
{
continue;
}
//
// RouteCode (ROUTES.number)
//
strncpy(tempString, ROUTES.number, ROUTES_NUMBER_LENGTH);
trim(tempString, ROUTES_NUMBER_LENGTH);
ptr = tempString;
while(ptr && *ptr == ' ')
{
ptr++;
}
sprintf(szarString, "\"%s\",", ptr);
strcpy(outputString, szarString);
//
// DirectionCode (DIRECTIONS.abbrName)
//
DIRECTIONSKey0.recordID = ROUTES.DIRECTIONSrecordID[nI];
btrieve(B_GETEQUAL, TMS_DIRECTIONS, &DIRECTIONS, &DIRECTIONSKey0, 0);
strncpy(tempString, DIRECTIONS.abbrName, DIRECTIONS_ABBRNAME_LENGTH);
trim(tempString, DIRECTIONS_ABBRNAME_LENGTH);
sprintf(szarString, "\"%s\",", tempString);
strcat(outputString, szarString);
strcpy(out2, outputString);
//
// Get the trips for this route/ser/dir
//
TRIPSKey1.ROUTESrecordID = ROUTES.recordID;
TRIPSKey1.SERVICESrecordID = SERVICES.recordID;
TRIPSKey1.directionIndex = nI;
TRIPSKey1.tripSequence = NO_RECORD;
rcode2 = btrieve(B_GETGREATER, TMS_TRIPS, &TRIPS, &TRIPSKey1, 1);
while(rcode2 == 0 &&
TRIPS.ROUTESrecordID == ROUTES.recordID &&
TRIPS.SERVICESrecordID == SERVICES.recordID &&
TRIPS.directionIndex == nI)
{
strcpy(outputString, out2);
//
// PatternCode (SERVICES.recordID-PATTERNNAMES.recordID)
//
sprintf(szarString, "\"%ld-%ld\",", TRIPS.SERVICESrecordID, TRIPS.PATTERNNAMESrecordID);
strcat(outputString, szarString);
//
// TripCode (TRIPS.tripNumber)
//
sprintf(szarString, "\"%ld\",", TRIPS.tripNumber);
strcat(outputString, szarString);
//
// Does this vehicle have a bike rack?
//
bBikeRack = FALSE;
if(TRIPS.BUSTYPESrecordID != NO_RECORD)
{
BUSTYPESKey0.recordID = TRIPS.BUSTYPESrecordID;
rcode2 = btrieve(B_GETEQUAL, TMS_BUSTYPES, &BUSTYPES, &BUSTYPESKey0, 0);
if(rcode2 == 0)
{
if(BUSTYPES.flags & BUSTYPES_FLAG_CARRIER)
{
bBikeRack = TRUE;
}
}
}
//
// Generate the trip
//
GenerateTrip(TRIPS.ROUTESrecordID, TRIPS.SERVICESrecordID,
TRIPS.directionIndex, TRIPS.PATTERNNAMESrecordID,
TRIPS.timeAtMLP, GENERATETRIP_FLAG_DISPLAYERRORS, >Results);
//
// Go through the pattern twice
//
// Pass 1 - Determine distances at each timepoint
//
if(GTResults.tripDistance != 0.0)
{
PATTERNSKey2.ROUTESrecordID = ROUTES.recordID;
PATTERNSKey2.SERVICESrecordID = SERVICES.recordID;
PATTERNSKey2.directionIndex = nI;
PATTERNSKey2.PATTERNNAMESrecordID = TRIPS.PATTERNNAMESrecordID;
PATTERNSKey2.nodeSequence = NO_RECORD;
rcode2 = btrieve(B_GETGREATER, TMS_PATTERNS, &PATTERNS, &PATTERNSKey2, 2);
tripIndex = 0;
distanceToHere = 0.0;
while(rcode2 == 0 &&
PATTERNS.ROUTESrecordID == ROUTES.recordID &&
PATTERNS.SERVICESrecordID == SERVICES.recordID &&
PATTERNS.directionIndex == nI &&
PATTERNS.PATTERNNAMESrecordID == TRIPS.PATTERNNAMESrecordID)
{
NODESKey0.recordID = PATTERNS.NODESrecordID;
rcode2 = btrieve(B_GETEQUAL, TMS_NODES, &NODES, &NODESKey0, 0);
if(PATTERNS.flags & PATTERNS_FLAG_BUSSTOP)
{
distanceToHere += (float)GreatCircleDistance(prevLon, prevLat, NODES.longitude, NODES.latitude);
}
else
{
tripDistances[tripIndex] = distanceToHere;
tripIndex++;
}
prevLat = NODES.latitude;
prevLon = NODES.longitude;
rcode2 = btrieve(B_GETNEXT, TMS_PATTERNS, &PATTERNS, &PATTERNSKey2, 2);
}
}
//
// Save outputString to this point
//
strcpy(outputStringSave, outputString);
//
// Pass 2 - Determine time interpolations and output the records
//
PATTERNSKey2.ROUTESrecordID = ROUTES.recordID;
PATTERNSKey2.SERVICESrecordID = SERVICES.recordID;
PATTERNSKey2.directionIndex = nI;
PATTERNSKey2.PATTERNNAMESrecordID = TRIPS.PATTERNNAMESrecordID;
PATTERNSKey2.nodeSequence = NO_RECORD;
rcode2 = btrieve(B_GETGREATER, TMS_PATTERNS, &PATTERNS, &PATTERNSKey2, 2);
tripIndex = 0;
seq = 1;
distanceToHere = 0.0;
while(rcode2 == 0 &&
PATTERNS.ROUTESrecordID == ROUTES.recordID &&
PATTERNS.SERVICESrecordID == SERVICES.recordID &&
PATTERNS.directionIndex == nI &&
PATTERNS.PATTERNNAMESrecordID == TRIPS.PATTERNNAMESrecordID)
{
NODESKey0.recordID = PATTERNS.NODESrecordID;
rcode2 = btrieve(B_GETEQUAL, TMS_NODES, &NODES, &NODESKey0, 0);
if(PATTERNS.flags & PATTERNS_FLAG_BUSSTOP)
{
if(GTResults.tripDistance == 0)
{
timeAtStop = GTResults.tripTimes[tripIndex - 1];
}
else
{
distanceToHere += (float)GreatCircleDistance(prevLon, prevLat, NODES.longitude, NODES.latitude);
timeAtStop = (long)((GTResults.tripTimes[tripIndex] - GTResults.tripTimes[tripIndex - 1]) *
(distanceToHere / (tripDistances[tripIndex] - tripDistances[tripIndex - 1])));
timeAtStop += (GTResults.tripTimes[tripIndex - 1]);
}
}
else
{
timeAtStop = GTResults.tripTimes[tripIndex];
distanceToHere = 0.0;
tripIndex++;
}
//
// StopCode (NODES.number or NODES.abbrName)
//
/*
if(NODES.flags & NODES_FLAG_STOP)
{
sprintf(szarString, "\"%04ld\",", NODES.number);
}
else
{
strncpy(tempString, NODES.abbrName, NODES_ABBRNAME_LENGTH);
trim(tempString, NODES_ABBRNAME_LENGTH);
sprintf(szarString, "\"%s\",", tempString);
}
*/
if(!(NODES.flags & NODES_FLAG_STOP))
{
if(nI == 0)
{
number = (NODES.OBStopNumber <= 0 ? NODES.number : NODES.OBStopNumber);
}
else
{
number = (NODES.IBStopNumber <= 0 ? NODES.number : NODES.IBStopNumber);
}
sprintf(szarString, "\"%04ld\",", number);
}
else
{
sprintf(szarString, "\"%04ld\",", NODES.number);
}
strcat(outputString, szarString);
//
// Sequence
//
sprintf(szarString, "\"%d\",", seq++);
strcat(outputString, szarString);
//
// ArrivalTime (Time at the stop, in seconds)
//
// Now time is in HHMM (11-Aug-08)
//
// sprintf(szarString, "\"%ld\",", timeAtStop);
sprintf(szarString, "\"%s\",", TcharNAP(timeAtStop, FALSE));
strcat(outputString, szarString);
//
// DepartureTime (Time at the stop, in seconds)
//
// Now time is in HHMM (11-Aug-08)
//
// sprintf(szarString, "\"%ld\",", timeAtStop);
sprintf(szarString, "\"%s\",", TcharNAP(timeAtStop, FALSE));
strcat(outputString, szarString);
//
// Timepoint?
//
sprintf(tempString, "%s", (NODES.flags & NODES_FLAG_STOP ? "False" : "True"));
sprintf(szarString, "\"%s\",", tempString);
strcat(outputString, szarString);
//
// Bicycles?
//
sprintf(tempString, "%s", (bBikeRack ? "True" : "False"));
sprintf(szarString, "\"%s\",", tempString);
strcat(outputString, szarString);
//
// ServiceCode
//
sprintf(szarString, "\"%s\"\r\n", szServiceCode);
strcat(outputString, szarString);
//
// Write it out and go back
//
_lwrite(hfOutputFile, outputString, strlen(outputString));
strcpy(outputString, outputStringSave);
prevLat = NODES.latitude;
prevLon = NODES.longitude;
rcode2 = btrieve(B_GETNEXT, TMS_PATTERNS, &PATTERNS, &PATTERNSKey2, 2);
} // while on pattern
//
// Get the next trip
//
rcode2 = btrieve(B_GETNEXT, TMS_TRIPS, &TRIPS, &TRIPSKey1, 1);
} // while on trips
} // nI (directions on the route)
//
// Get the next service
//
rcode2 = btrieve(B_GETNEXT, TMS_SERVICES, &SERVICES, &SERVICESKey1, 1);
}
//
// Close the file
//
_lclose(hfOutputFile);
//
// Get the next route
//
rcode2 = btrieve(B_GETNEXT, TMS_ROUTES, &ROUTES, &ROUTESKey1, 1);
}
//
// Blocks
//
//
// ============================
// Blocks File - oci_blocks.dat
// ============================
//
pTRIPSChunk = &TRIPS.standard;
sprintf(outputFileName, "oci_blocks.csv", ptr);
hfOutputFile = _lcreat(outputFileName, 0);
if(hfOutputFile == HFILE_ERROR)
{
LoadString(hInst, ERROR_320, szFormatString, SZFORMATSTRING_LENGTH);
sprintf(szarString, szFormatString, outputFileName);
MessageBeep(MB_ICONSTOP);
MessageBox(NULL, szarString, TMS, MB_OK | MB_ICONSTOP);
goto done;
}
//
// Write out the header
//
strcpy(outputString, "\"BlockCode\",\"ServiceCode\",\"TripCode\",\"Sequence\",\"StartStopCode\",\"EndStopCode\",\"InService\"\r\n");
_lwrite(hfOutputFile, outputString, strlen(outputString));
StatusBarText(outputFileName);
//
// Traverse the Routes Table
//
rcode2 = btrieve(B_GETFIRST, TMS_ROUTES, &ROUTES, &ROUTESKey1, 1);
while(rcode2 == 0)
{
if(StatusBarAbort())
{
goto done;
}
//
// Go through the services
//
rcode2 = btrieve(B_GETFIRST, TMS_SERVICES, &SERVICES, &SERVICESKey1, 1);
while(rcode2 == 0)
{
if(StatusBarAbort())
{
goto done;
}
strncpy(szServiceCode, SERVICES.name, SERVICES_NAME_LENGTH);
trim(szServiceCode, SERVICES_NAME_LENGTH);
//
// Get all the blocks on this route group
//
NODESKey1.flags = NODES_FLAG_GARAGE;
memset(NODESKey1.abbrName, 0x00, NODES_ABBRNAME_LENGTH);
rcode2 = btrieve(B_GETGREATEROREQUAL, TMS_NODES, &NODES, &NODESKey1, 1);
bFirst = TRUE;
while(rcode2 == 0 && NODES.flags & NODES_FLAG_GARAGE)
{
//
// Cycle through the blocks
//
assignedToNODESrecordID = bFirst ? NO_RECORD : NODES.recordID;
TRIPSKey2.assignedToNODESrecordID = assignedToNODESrecordID;
TRIPSKey2.RGRPROUTESrecordID = ROUTES.recordID;
TRIPSKey2.SGRPSERVICESrecordID = SERVICES.recordID;
TRIPSKey2.blockNumber = 1;
TRIPSKey2.blockSequence = NO_TIME;
rcode2 = btrieve(B_GETGREATEROREQUAL, TMS_TRIPS, &TRIPS, &TRIPSKey2, 2);
blockNumber = NO_RECORD;
//
// Get the first trip on the block
//
while(rcode2 == 0 &&
pTRIPSChunk->assignedToNODESrecordID == assignedToNODESrecordID &&
pTRIPSChunk->RGRPROUTESrecordID == ROUTES.recordID &&
pTRIPSChunk->SGRPSERVICESrecordID == SERVICES.recordID)
{
if(StatusBarAbort())
{
goto done;
}
if(pTRIPSChunk->blockNumber != blockNumber)
{
seq = 1;
blockNumber = pTRIPSChunk->blockNumber;
}
//
// Gen the whole trip
//
GenerateTrip(TRIPS.ROUTESrecordID, TRIPS.SERVICESrecordID,
TRIPS.directionIndex, TRIPS.PATTERNNAMESrecordID,
TRIPS.timeAtMLP, GENERATETRIP_FLAG_DISPLAYERRORS, >Results);
//
// Pullout?
//
if(pTRIPSChunk->POGNODESrecordID == NO_RECORD)
{
fromNODESrecordID = GTResults.firstNODESrecordID;
fromTime = GTResults.firstNodeTime;
}
else
{
GCTData.fromPATTERNNAMESrecordID = TRIPS.PATTERNNAMESrecordID;
GCTData.toPATTERNNAMESrecordID = TRIPS.PATTERNNAMESrecordID;
GCTData.fromROUTESrecordID = pTRIPSChunk->RGRPROUTESrecordID;
GCTData.fromSERVICESrecordID = pTRIPSChunk->SGRPSERVICESrecordID;
GCTData.toROUTESrecordID = pTRIPSChunk->RGRPROUTESrecordID;
GCTData.toSERVICESrecordID = pTRIPSChunk->SGRPSERVICESrecordID;
GCTData.fromNODESrecordID = pTRIPSChunk->POGNODESrecordID;
GCTData.toNODESrecordID = GTResults.firstNODESrecordID;
GCTData.timeOfDay = GTResults.firstNodeTime;
dhd = GetConnectionTime(GCT_FLAG_DEADHEADTIME, &GCTData, &distance);
distance = (float)fabs((double)distance);
if(dhd == NO_TIME)
{
dhd = 0;
}
fromNODESrecordID = pTRIPSChunk->POGNODESrecordID;
fromTime = GTResults.firstNodeTime - dhd;
//
// Output the pull-out deadhead record
//
// Start and End Stop codes
//
NODESKey0.recordID = pTRIPSChunk->POGNODESrecordID;
btrieve(B_GETEQUAL, TMS_NODES, &NODES, &NODESKey0, 0);
strncpy(tempString, NODES.abbrName, NODES_ABBRNAME_LENGTH);
trim(tempString, NODES_ABBRNAME_LENGTH);
NODESKey0.recordID = GTResults.firstNODESrecordID;
btrieve(B_GETEQUAL, TMS_NODES, &NODES, &NODESKey0, 0);
strncpy(szarString, NODES.abbrName, NODES_ABBRNAME_LENGTH);
trim(szarString, NODES_ABBRNAME_LENGTH);
//
// Write it
//
sprintf(outputString, "\"%ld\",\"%s\",\"\",\"%d\",\"%s\",\"%s\",\"False\"\r\n",
pTRIPSChunk->blockNumber, szServiceCode, seq, tempString, szarString);
_lwrite(hfOutputFile, outputString, strlen(outputString));
seq++;
}
//
// Start/end trip details
//
sprintf(szTripCode, "%ld", TRIPS.tripNumber);
//
// Start and End Stop codes
//
NODESKey0.recordID = GTResults.firstNODESrecordID;
btrieve(B_GETEQUAL, TMS_NODES, &NODES, &NODESKey0, 0);
strncpy(tempString, NODES.abbrName, NODES_ABBRNAME_LENGTH);
trim(tempString, NODES_ABBRNAME_LENGTH);
NODESKey0.recordID = GTResults.lastNODESrecordID;
btrieve(B_GETEQUAL, TMS_NODES, &NODES, &NODESKey0, 0);
strncpy(szarString, NODES.abbrName, NODES_ABBRNAME_LENGTH);
trim(szarString, NODES_ABBRNAME_LENGTH);
//
// Write it
//
sprintf(outputString, "\"%ld\",\"%s\",\"%s\",\"%d\",\"%s\",\"%s\",\"True\"\r\n",
pTRIPSChunk->blockNumber, szServiceCode, szTripCode, seq, tempString, szarString);
_lwrite(hfOutputFile, outputString, strlen(outputString));
seq++;
//
// Pullin
//
if(pTRIPSChunk->PIGNODESrecordID == NO_RECORD)
{
toNODESrecordID = GTResults.lastNODESrecordID;
toTime = GTResults.lastNodeTime;
}
else
{
GCTData.fromPATTERNNAMESrecordID = TRIPS.PATTERNNAMESrecordID;
GCTData.toPATTERNNAMESrecordID = TRIPS.PATTERNNAMESrecordID;
GCTData.fromROUTESrecordID = pTRIPSChunk->RGRPROUTESrecordID;
GCTData.fromSERVICESrecordID = pTRIPSChunk->SGRPSERVICESrecordID;
GCTData.toROUTESrecordID = pTRIPSChunk->RGRPROUTESrecordID;
GCTData.toSERVICESrecordID = pTRIPSChunk->SGRPSERVICESrecordID;
GCTData.fromNODESrecordID = GTResults.lastNODESrecordID;
GCTData.toNODESrecordID = pTRIPSChunk->PIGNODESrecordID;
GCTData.timeOfDay = GTResults.lastNodeTime;
dhd = GetConnectionTime(GCT_FLAG_DEADHEADTIME, &GCTData, &distance);
distance = (float)fabs((double)distance);
if(dhd == NO_TIME)
{
dhd = 0;
}
toNODESrecordID = pTRIPSChunk->PIGNODESrecordID;
toTime = GTResults.lastNodeTime + dhd;
//
// Output the pull-in deadhead record
//
// Start and End Stop codes
//
NODESKey0.recordID = GTResults.lastNODESrecordID;
btrieve(B_GETEQUAL, TMS_NODES, &NODES, &NODESKey0, 0);
strncpy(tempString, NODES.abbrName, NODES_ABBRNAME_LENGTH);
trim(tempString, NODES_ABBRNAME_LENGTH);
NODESKey0.recordID = pTRIPSChunk->PIGNODESrecordID;
btrieve(B_GETEQUAL, TMS_NODES, &NODES, &NODESKey0, 0);
strncpy(szarString, NODES.abbrName, NODES_ABBRNAME_LENGTH);
trim(szarString, NODES_ABBRNAME_LENGTH);
//
// Write it
//
sprintf(outputString, "\"%ld\",\"%s\",\"\",\"%d\",\"%s\",\"%s\",\"False\"\r\n",
pTRIPSChunk->blockNumber, szServiceCode, seq, tempString, szarString);
_lwrite(hfOutputFile, outputString, strlen(outputString));
seq++;
}
rcode2 = btrieve(B_GETNEXT, TMS_TRIPS, &TRIPS, &TRIPSKey2, 2);
} // while blocks on this garage node
//
// Get the next garage node
//
if(bFirst)
{
bFirst = FALSE;
}
else
{
rcode2 = btrieve(B_GETNEXT, TMS_NODES, &NODES, &NODESKey1, 1);
}
} // while cycling through garage nodes
//
// Get the next service
//
rcode2 = btrieve(B_GETNEXT, TMS_SERVICES, &SERVICES, &SERVICESKey1, 1);
}
//
// Get the next route
//
rcode2 = btrieve(B_GETNEXT, TMS_ROUTES, &ROUTES, &ROUTESKey1, 1);
}
//
// Close the file
//
_lclose(hfOutputFile);
//
// All done
//
StatusBar(-1L, -1L);
bFinishedOK = TRUE;
done:
chdir(".."); // Back to where we started from
StatusBarEnd();
if(!bFinishedOK)
{
TMSError((HWND)NULL, MB_ICONINFORMATION, ERROR_227, (HANDLE)NULL);
}
if(bGotError)
{
TMSError((HWND)NULL, MB_ICONINFORMATION, ERROR_350, (HANDLE)NULL);
}
_lclose(hfErrorLog);
distanceMeasure = distanceMeasureSave;
recordLength[TMS_COMMENTS] = COMMENTS_FIXED_LENGTH;
return(bFinishedOK);
}
int
DIAMONDAPI
DiamondNotifyFunction(
IN FDINOTIFICATIONTYPE Operation,
IN PFDINOTIFICATION Parameters
)
{
switch(Operation) {
case fdintCABINET_INFO:
case fdintNEXT_CABINET:
case fdintPARTIAL_FILE:
//
// Cabinet management functions which we don't use.
// Return success.
//
return(0);
case fdintCOPY_FILE:
//
// Diamond is asking us whether we want to copy the file.
//
{
PDIAMOND_INFO Info = (PDIAMOND_INFO)Parameters->pv;
HFILE h;
//
// If we need to rename the target file, do that here.
// The name stored in the cabinet file will be used as
// the uncompressed name.
//
if(Info->RenameTargetFile) {
PSTR p,q;
//
// Find the start of the filename part of the target.
//
if(p = StringRevChar(Info->TargetFileName,'\\')) {
p++;
} else {
p = Info->TargetFileName;
}
//
// Find the start of the filename part of the name in the cabinet.
//
if(q = StringRevChar(Parameters->psz1,'\\')) {
q++;
} else {
q = Parameters->psz1;
}
//
// Copy the filename part of the name in the cabinet over
// the filename part of the name in the target spec.
//
lstrcpy(p,q);
}
//
// Inform the expand callback what we are doing.
//
if(!Info->ExpandNotify(Info->SourceFileName,Info->TargetFileName,NOTIFY_START_EXPAND)) {
return(0); // skip this file.
}
//
// Remember the uncompressed size and open the file.
// Returns -1 if an error occurs opening the file.
//
Info->pLZI->cblOutSize = Parameters->cb;
h = _lcreat(Info->TargetFileName,0);
if(h == HFILE_ERROR) {
DiamondLastIoError = LZERROR_BADOUTHANDLE;
return(-1);
}
return(h);
}
case fdintCLOSE_FILE_INFO:
//
// Diamond is done with the target file and wants us to close it.
// (ie, this is the counterpart to fdint_COPY_FILE).
//
{
PDIAMOND_INFO Info = (PDIAMOND_INFO)Parameters->pv;
CopyDateTimeStamp(Info->SourceFileHandle,Parameters->hf);
_lclose(Parameters->hf);
}
return(TRUE);
}
}
void dbglog_eraselog ()
{
_lclose ( _lcreat ( DBGLOG_FILENAME, 0 ) );
}
BOOL FAR TMSRPT51(TMSRPTPassedDataDef *pPassedData)
{
REPORTPARMSDef REPORTPARMS;
PROPOSEDRUNDef PROPOSEDRUN;
COSTDef COST;
HFILE hfOutputFile;
BOOL bKeepGoing = FALSE;
BOOL bRC;
BOOL bCoach;
char outputString[512];
char szDate[16];
char szEmployee[16];
char szRunNumber[7];
char *ptr;
long numPieces;
long time;
long platformTime;
long reportTime;
long turninTime;
long travelTime;
long dd, mm, yyyy;
int nI;
int nJ;
int nK;
int rcode2;
int seq;
int numRosters;
pPassedData->nReportNumber = 48;
pPassedData->numDataFiles = 1;
//
// See what he wants
//
REPORTPARMS.nReportNumber = pPassedData->nReportNumber;
REPORTPARMS.DIVISIONSrecordID = m_DivisionRecordID;
REPORTPARMS.pDivisionList = NULL;
REPORTPARMS.flags = RPFLAG_DIVISIONS;
bRC = DialogBoxParam(hInst, MAKEINTRESOURCE(IDD_RPTPARMS),
hWndMain, (DLGPROC)RPTPARMSMsgProc, (LPARAM)&REPORTPARMS);
if(!bRC)
return(FALSE);
//
// Check the list of routes, services, and divisions
//
if(REPORTPARMS.numDivisions == 0)
goto deallocate;
//
// Open the output file
//
strcpy(tempString, szDatabaseFileName);
if((ptr = strrchr(tempString, '\\')) != NULL)
*ptr = '\0';
strcat(tempString, "\\Fleet-Net Payroll.txt");
hfOutputFile = _lcreat(tempString, 0);
if(hfOutputFile == HFILE_ERROR)
{
LoadString(hInst, ERROR_202, szFormatString, sizeof(szFormatString));
sprintf(szarString, szFormatString, tempString);
MessageBeep(MB_ICONSTOP);
MessageBox((HWND)NULL, szarString, TMS, MB_ICONSTOP);
goto deallocate;
}
//
// Fire up the status bar
//
LoadString(hInst, TEXT_117, tempString, TEMPSTRING_LENGTH);
StatusBarStart(hWndMain, tempString);
//
// Determine the extent of the status bar
//
rcode2 = btrieve(B_STAT, TMS_ROSTER, &BSTAT, outputString, 0);
if(rcode2 != 0 || BSTAT.numRecords == 0)
{
TMSError((HWND)NULL, MB_ICONSTOP, ERROR_319, (HANDLE)NULL);
goto deallocate;
}
numRosters = BSTAT.numRecords;
//
// Get today's date
//
if(CalendarDate(&dd, &mm, &yyyy) == NO_RECORD)
{
goto deallocate;
}
//
// Loop through all the divisions
//
bKeepGoing = TRUE;
seq = 0;
for(nI = 0; nI < REPORTPARMS.numDivisions; nI++)
{
if(StatusBarAbort())
{
goto deallocate;
}
DIVISIONSKey0.recordID = REPORTPARMS.pDivisionList[nI];
btrieve(B_GETEQUAL, TMS_DIVISIONS, &DIVISIONS, &DIVISIONSKey0, 0);
strncpy(tempString, DIVISIONS.name, DIVISIONS_NAME_LENGTH);
trim(tempString, DIVISIONS_NAME_LENGTH);
bCoach = (strstr(tempString, "Coach") > 0);
//
// Cycle through the roster
//
ROSTERKey1.DIVISIONSrecordID = DIVISIONS.recordID;
ROSTERKey1.rosterNumber = NO_RECORD;
rcode2 = btrieve(B_GETGREATER, TMS_ROSTER, &ROSTER, &ROSTERKey1, 1);
while(rcode2 == 0 &&
ROSTER.DIVISIONSrecordID == DIVISIONS.recordID)
{
if(StatusBarAbort())
{
goto deallocate;
}
//
// Get the employee - must be assigned
//
StatusBar((long)(seq + 1), (long)numRosters);
if(ROSTER.DRIVERSrecordID != NO_RECORD)
{
DRIVERSKey0.recordID = ROSTER.DRIVERSrecordID;
btrieve(B_GETEQUAL, TMS_DRIVERS, &DRIVERS, &DRIVERSKey0, 0);
strncpy(szEmployee, DRIVERS.badgeNumber, TMSRPT51_MAX_EMPLOYEENUMBERLENGTH);
szEmployee[TMSRPT51_MAX_EMPLOYEENUMBERLENGTH] = '\0';
//
// Loop through the runs
//
for(nJ = 0; nJ < ROSTER_MAX_DAYS; nJ++)
{
if(StatusBarAbort())
{
goto deallocate;
}
if(ROSTER.WEEK[m_RosterWeek].RUNSrecordIDs[nJ] == NO_RECORD)
{
continue;
}
//
// Establish "today's" date
//
strcpy(szDate, CalendarDateWithOffset(dd, mm, yyyy, nJ));
//
// Get the characteristics of the run
//
RUNSKey0.recordID = ROSTER.WEEK[m_RosterWeek].RUNSrecordIDs[nJ];
rcode2 = btrieve(B_GETEQUAL, TMS_RUNS, &RUNS, &RUNSKey0, 0);
if(rcode2 != 0)
{
continue;
}
sprintf(szRunNumber, "%6ld", RUNS.runNumber);
numPieces = GetRunElements(NULL, &RUNS, &PROPOSEDRUN, &COST, TRUE);
platformTime = 0;
reportTime = 0;
turninTime = 0;
travelTime = 0;
for(nK = 0; nK < numPieces; nK++)
{
platformTime += RUNSVIEW[nK].platformTime;
reportTime += RUNSVIEW[nK].reportTime;
turninTime += RUNSVIEW[nK].turninTime;
travelTime += RUNSVIEW[nK].travelTime;
}
//
// Spit out the various components
//
for(nK = 0; nK < TMSRPT51_NUMCOMPONENTS; nK++)
{
//
// Set up the output record
//
strcpy(outputString, szDate);
strcat(outputString, "\t");
strcat(outputString, szEmployee);
strcat(outputString, "\t");
switch(nK)
{
//
// Platform time
//
case TMSRPT51_PLATFORMTIME:
strcat(outputString, (bCoach ? "PLT" : "PLV"));
time = platformTime;
break;
//
// Makeup time
//
case TMSRPT51_MAKEUPTIME:
strcat(outputString, (bCoach ? "GCS" : "GUV"));
time = RUNSVIEW[numPieces - 1].makeUpTime;
break;
//
// Report time
//
case TMSRPT51_REPORTTIME:
strcat(outputString, (bCoach ? "REC" : "RPV"));
time = reportTime;
break;
//
// Turnin time
//
case TMSRPT51_TURNINTIME:
strcat(outputString, (bCoach ? "CHT" : "CHV"));
time = turninTime;
break;
//
// Travel time
//
case TMSRPT51_TRAVELTIME:
strcat(outputString, (bCoach ? "TRT" : "TRV"));
time = travelTime;
break;
//
// Overtime
//
case TMSRPT51_OVERTIME:
strcat(outputString, (bCoach ? "OCS" : "OVS"));
time = (long)(RUNSVIEW[numPieces - 1].overTime / 1.5);
break;
}
//
// Fill in the rest of the record
//
// Time
//
sprintf(tempString, "\t%5ld\t", time);
strcat(outputString, tempString);
//
// Run number
//
strcat(outputString, szRunNumber);
strcat(outputString, "\r\n");
//
// Write the record
//
_lwrite(hfOutputFile, outputString, strlen(outputString));
}
}
}
//
// Get the next roster record
//
seq++;
rcode2 = btrieve(B_GETNEXT, TMS_ROSTER, &ROSTER, &ROSTERKey1, 1);
}
} // nI loop on divisions
bKeepGoing = TRUE;
//
// Free allocated memory
//
deallocate:
TMSHeapFree(REPORTPARMS.pDivisionList);
StatusBarEnd();
_lclose(hfOutputFile);
SetCursor(hCursorArrow);
if(!bKeepGoing)
return(FALSE);
//
// Let him know
//
strcpy(tempString, "Fleet-Net Payroll.txt was written to:\n");
strcpy(szarString, szDatabaseFileName);
if((ptr = strrchr(szarString, '\\')) != NULL)
*ptr = '\0';
strcat(tempString, szarString);
MessageBox(hWndMain, tempString, TMS, MB_OK);
//
// All done
//
return(TRUE);
}
BOOL WritePalette(
/************************************************************************/
LPSTR lpFileName,
LPPALETTE lpPalette)
{
int ofh; /* file handle( unbuffered) */
FILEBUF ofd; /* file descriptor( buffered) */
int i;
VERSIONINFO version;
RECINFO rec;
if (!lpPalette)
return(FALSE);
/* open the output file */
if ( ( ofh = _lcreat( lpFileName, 0)) < 0 )
{
Message( IDS_EWRITE, lpFileName);
return( NO);
}
/* create a buffered stream to speed access */
FileFDOpenWrt( &ofd, ofh, (LPTR)LineBuffer[0], 16*1024);
// write palette version
version.Length = sizeof(version.Number);
version.Type = PALFILE_VERSION;
version.Number = CURRENT_VERSION;
FileWrite(&ofd, (LPTR)&version, sizeof(version));
while (lpPalette)
{
if (lpPalette->iColors || TRUE)
{
// write palette name
rec.Length = lstrlen(lpPalette->szName)+1;
rec.Type = PALFILE_NAME;
FileWrite(&ofd, (LPTR)&rec, sizeof(rec));
FileWrite(&ofd, (LPTR)lpPalette->szName, rec.Length);
// write palette colors
rec.Length = sizeof(WORD)+(lpPalette->iColors * sizeof(COLOR));
rec.Type = PALFILE_COLORS;
FileWrite(&ofd, (LPTR)&rec, sizeof(rec));
intelWriteWord( &ofd, lpPalette->iColors);
for (i = 0; i < lpPalette->iColors; ++i)
{
intelWriteDWord(&ofd, RGB2long(lpPalette->lpColorInfo[i].rgb));
}
// write color lables
if (lpPalette->lpLabels && lpPalette->LabelsLength)
{
rec.Length = lpPalette->LabelsLength;
rec.Type = PALFILE_LABELS;
FileWrite(&ofd, (LPTR)&rec, sizeof(rec));
FileWrite(&ofd, lpPalette->lpLabels,
rec.Length);
}
// write formating information
if (lstrlen(lpPalette->szFormat) > 0)
{
rec.Length = lstrlen(lpPalette->szFormat)+1;
rec.Type = PALFILE_FORMAT;
FileWrite(&ofd, (LPTR)&rec, sizeof(rec));
FileWrite(&ofd, (LPTR)lpPalette->szFormat,
rec.Length);
}
// write palette grouping
rec.Length = 4;
rec.Type = PALFILE_GROUP;
FileWrite(&ofd, (LPTR)&rec, sizeof(rec));
intelWriteDWord( &ofd, lpPalette->dwGroup);
lpPalette = lpPalette->lpNext;
}
}
// write palette end record
rec.Length = 0;
rec.Type = PALFILE_END;
FileWrite(&ofd, (LPTR)&rec, sizeof(rec));
FileFlush(&ofd);
_lclose(ofh);
if ( ofd.err)
{
Message( IDS_EWRITE, lpFileName);
return( NO);
}
return( YES);
}
int WINAPI
OpenFile(LPCSTR lpszFileName,OFSTRUCT *lpofs,UINT wFunction)
{
int fd;
const char *lpstr = lpszFileName;
/*
* The "lpstr" variable is needed as a workaround to a bug
* in the SunOS "acc" compiler, which treats the LPCSTR typedef
* as type "const char * const" rather than the requested
* "const char *".
*/
APISTR((LF_APICALL,"OpenFile(LPCSTR=%s,OFSTRUCT=%p,UINT=%x)\n",
lpszFileName,lpofs,wFunction));
if ((wFunction & OF_REOPEN)) {
lpstr = lpofs->szPathName;
}
if (!lpstr) {
APISTR((LF_APIFAIL,"OpenFile: returns int HFILE_ERROR\n"));
return HFILE_ERROR;
}
if(wFunction & OF_PARSE) {
memset((LPSTR)lpofs,0,sizeof(OFSTRUCT));
MFS_ALTPATH(lpofs->szPathName, lpstr);
APISTR((LF_APIFAIL,"OpenFile: returns int 0\n"));
return 0;
}
lpofs->fFixedDisk = 1;
if(wFunction & OF_DELETE) {
fd = _ldelete(lpstr);
if(fd == 0) {
APISTR((LF_APIRET,"OpenFile: returns int 1\n"));
return 1;
} else {
APISTR((LF_APIFAIL,"OpenFile: returns int HFILE_ERROR\n"));
return HFILE_ERROR;
}
}
if(wFunction & OF_CREATE)
fd = _lcreat(lpstr, 0);
else
fd = OpenEngine(lpstr,lpofs,wFunction);
#ifdef LATER
if(fd < 0) {
if((wFunction & (OF_PROMPT|OF_CREATE)) == OF_PROMPT) {
printf("prompting user for file %s cancel...\n",
wFunction&OF_CANCEL?"w/":"w/o ");
}
}
if((wFunction & (OF_READ|OF_VERIFY)) == (OF_READ|OF_VERIFY)) {
printf("checking for date/time...\n");
}
#endif
if(fd < 0) {
APISTR((LF_APIFAIL,"OpenFile: returns int %d\n",fd));
return fd;
}
if(wFunction & OF_EXIST)
_lclose(fd);
APISTR((LF_APIRET,"OpenFile: returns int %d\n",fd));
return fd;
}
/***********************************************************************
* _lcreat (KERNEL.83)
*/
HFILE16 WINAPI _lcreat16( LPCSTR path, INT16 attr )
{
return Win32HandleToDosFileHandle( (HANDLE)_lcreat( path, attr ) );
}
BOOL FAR TMSRPT01(TMSRPTPassedDataDef *pPassedData)
{
REPORTPARMSDef REPORTPARMS;
HFILE hfOutputFile;
BOOL bKeepGoing = FALSE;
BOOL bRC;
int maxSelectedPatternNodes = 100;
int nI;
int nJ;
int nK;
int nL;
int numSelectedPatternNodes;
int rcode2;
long *pSelectedPatternNodes = NULL;
pPassedData->nReportNumber = 0;
pPassedData->numDataFiles = 1;
//
// See what he wants
//
REPORTPARMS.nReportNumber = pPassedData->nReportNumber;
REPORTPARMS.ROUTESrecordID = m_RouteRecordID;
REPORTPARMS.SERVICESrecordID = m_ServiceRecordID;
REPORTPARMS.PATTERNNAMESrecordID = NO_RECORD;
REPORTPARMS.COMMENTSrecordID = NO_RECORD;
REPORTPARMS.pRouteList = NULL;
REPORTPARMS.pServiceList = NULL;
REPORTPARMS.flags = RPFLAG_ROUTES | RPFLAG_SERVICES | RPFLAG_PATTERNNAMES | RPFLAG_COMMENTS;
bRC = DialogBoxParam(hInst, MAKEINTRESOURCE(IDD_RPTPARMS),
hWndMain, (DLGPROC)RPTPARMSMsgProc, (LPARAM)&REPORTPARMS);
if(!bRC)
{
return(FALSE);
}
//
// Check the list of routes and services
//
if(REPORTPARMS.numRoutes == 0 || REPORTPARMS.numServices == 0)
{
goto deallocate;
}
//
// Open the output file
//
strcpy(tempString, szReportsTempFolder);
strcat(tempString, "\\tmsrpt01.txt");
hfOutputFile = _lcreat(tempString, 0);
if(hfOutputFile == HFILE_ERROR)
{
LoadString(hInst, ERROR_202, szFormatString, sizeof(szFormatString));
sprintf(szarString, szFormatString, tempString);
MessageBeep(MB_ICONSTOP);
MessageBox((HWND)NULL, szarString, TMS, MB_ICONSTOP);
goto deallocate;
}
strcpy(pPassedData->szReportDataFile[0], tempString);
//
// Allocate the nodes arrays
//
pSelectedPatternNodes = (long *)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(long) * maxSelectedPatternNodes);
if(pSelectedPatternNodes == NULL)
{
AllocationError(__FILE__, __LINE__, FALSE);
goto deallocate;
}
//
// Load any header and trailer special characters
//
LoadHeadersAndTrailers01();
//
// Loop through the routes
//
SetCursor(hCursorWait);
for(nI = 0; nI < REPORTPARMS.numRoutes; nI++)
{
ROUTESKey0.recordID = REPORTPARMS.pRouteList[nI];
rcode2 = btrieve(B_GETEQUAL, TMS_ROUTES, &ROUTES, &ROUTESKey0, 0);
if(rcode2 != 0)
{
continue;
}
//
// Loop through the services
//
for(nJ = 0; nJ < REPORTPARMS.numServices; nJ++)
{
SERVICESKey0.recordID = REPORTPARMS.pServiceList[nJ];
rcode2 = btrieve(B_GETEQUAL, TMS_SERVICES, &SERVICES, &SERVICESKey0, 0);
if(rcode2 != 0)
{
continue;
}
//
// Loop through the directions
//
for(nK = 0; nK < 2; nK++)
{
if(ROUTES.DIRECTIONSrecordID[nK] == NO_RECORD)
{
continue;
}
//
// Find the selected pattern nodes
//
numSelectedPatternNodes = 0;
PATTERNNAMESKey0.recordID = REPORTPARMS.PATTERNNAMESrecordID;
rcode2 = btrieve(B_GETEQUAL, TMS_PATTERNNAMES, &PATTERNNAMES, &PATTERNNAMESKey0, 0);
if(rcode2 == 0)
{
PATTERNSKey2.ROUTESrecordID = REPORTPARMS.pRouteList[nI];
PATTERNSKey2.SERVICESrecordID = REPORTPARMS.pServiceList[nJ];
PATTERNSKey2.directionIndex = nK;
PATTERNSKey2.PATTERNNAMESrecordID = PATTERNNAMES.recordID;
PATTERNSKey2.nodeSequence = NO_RECORD;
rcode2 = btrieve(B_GETGREATEROREQUAL, TMS_PATTERNS, &PATTERNS, &PATTERNSKey2, 2);
while(rcode2 == 0 &&
PATTERNS.ROUTESrecordID == REPORTPARMS.pRouteList[nI] &&
PATTERNS.SERVICESrecordID == REPORTPARMS.pServiceList[nJ] &&
PATTERNS.directionIndex == nK &&
PATTERNS.PATTERNNAMESrecordID == PATTERNNAMES.recordID)
{
if(!(PATTERNS.flags & PATTERNS_FLAG_BUSSTOP))
{
pSelectedPatternNodes[numSelectedPatternNodes++] = PATTERNS.NODESrecordID;
if(numSelectedPatternNodes >= maxSelectedPatternNodes)
{
maxSelectedPatternNodes += 50;
pSelectedPatternNodes = (long *)HeapReAlloc(GetProcessHeap(),
HEAP_ZERO_MEMORY, pSelectedPatternNodes, sizeof(long) * maxSelectedPatternNodes);
if(pSelectedPatternNodes == NULL)
{
AllocationError(__FILE__, __LINE__, TRUE);
goto deallocate;
}
}
}
rcode2 = btrieve(B_GETNEXT, TMS_PATTERNS, &PATTERNS, &PATTERNSKey2, 2);
}
}
if(numSelectedPatternNodes == 0)
{
continue;
}
//
// Write out the id record
//
strcpy(tempString, szRSDHeader);
strncpy(szarString, ROUTES.number, ROUTES_NUMBER_LENGTH);
trim(szarString, ROUTES_NUMBER_LENGTH);
strcat(tempString, szarString);
strcat(tempString, " ");
strncpy(szarString, ROUTES.name, ROUTES_NAME_LENGTH);
trim(szarString, ROUTES_NAME_LENGTH);
strcat(tempString, szarString);
strcat(tempString, " ");
DIRECTIONSKey0.recordID = ROUTES.DIRECTIONSrecordID[nK];
btrieve(B_GETEQUAL, TMS_DIRECTIONS, &DIRECTIONS, &DIRECTIONSKey0, 0);
strncpy(szarString, DIRECTIONS.abbrName, DIRECTIONS_ABBRNAME_LENGTH);
trim(szarString, DIRECTIONS_ABBRNAME_LENGTH);
strcat(tempString, szarString);
strcat(tempString, " ");
strncpy(szarString, SERVICES.name, SERVICES_NAME_LENGTH);
trim(szarString, SERVICES_NAME_LENGTH);
strcat(tempString, szarString);
strcat(tempString, szRSDTrailer);
strcat(tempString, "\r\n");
_lwrite(hfOutputFile, tempString, strlen(tempString));
//
// Write out the number of nodes record
//
strcpy(tempString, szNumNodesHeader);
if(strcmp(szNumNodesHeader, "") != 0)
{
strcat(tempString, " ");
}
sprintf(szarString, "%d", numSelectedPatternNodes);
strcat(tempString, szarString);
strcat(tempString, szNumNodesTrailer);
strcat(tempString, "\r\n");
_lwrite(hfOutputFile, tempString, strlen(tempString));
//
// Cycle through, and write out, the pattern nodes
//
for(nL = 0; nL < numSelectedPatternNodes; nL++)
{
strcpy(tempString, szEachNodeHeader);
NODESKey0.recordID = pSelectedPatternNodes[nL];
btrieve(B_GETEQUAL, TMS_NODES, &NODES, &NODESKey0, 0);
strncpy(szarString, NODES.intersection, NODES_INTERSECTION_LENGTH);
trim(szarString, NODES_INTERSECTION_LENGTH);
strcat(tempString, szarString);
strcat(tempString, szEachNodeTrailer);
strcat(tempString, "\r\n");
_lwrite(hfOutputFile, tempString, strlen(tempString));
} // nL
} // nK
} // nJ
} // nI
bKeepGoing = TRUE;
//
// Free allocated memory
//
deallocate:
TMSHeapFree(REPORTPARMS.pRouteList);
TMSHeapFree(REPORTPARMS.pServiceList);
TMSHeapFree(pSelectedPatternNodes);
_lclose(hfOutputFile);
SetCursor(hCursorArrow);
if(!bKeepGoing)
{
return(FALSE);
}
//
// All done
//
return(TRUE);
}
