home *** CD-ROM | disk | FTP | other *** search
/ PC Online 1997 February / PCO2_97.ISO / filesbbs / os2 / sysb091c.arj / SYSBENCH / SRC / PMB_MAIN.C < prev    next >
Encoding:
C/C++ Source or Header  |  1996-12-23  |  96.5 KB  |  3,001 lines
  1. // Sysbench main file
  2. #define INCL_DOSMISC
  3. #define INCL_DOSDEVICES
  4. #define INCL_DOSFILEMGR
  5. #define INCL_DOSERRORS
  6. #define INCL_DOSPROCESS
  7. #define INCL_DOSSEMAPHORES   /* Semaphore values */
  8.  
  9. #define INCL_WIN
  10. #define INCL_PM
  11. #define IDM_RESOURCE 1
  12. #define INCL_GPI
  13. #define INCL_GPILCIDS
  14. #define INCL_GPIPRIMITIVES
  15. #define INCL_GPICONTROL
  16.  
  17. #include <os2.h>
  18. #include <time.h>
  19. #include <stdio.h>
  20. #include <stdlib.h>
  21. #include <string.h>
  22.  
  23. #include <dive.h>
  24. #include <fourcc.h>
  25. #include "types.h"
  26. #include "pmb.h"
  27. #include "pmb_bench.h"
  28. #include "pmb_datatype.h"
  29.  
  30. #define CLS_CLIENT   "SysBenchWindowClass"
  31. #define SYSB_VER     "0.9.1c"
  32. #define THR_DONE     (WM_USER + 1)
  33. #define THR_UPDATE   (WM_USER + 2)
  34. #define DISP_LINES (119)
  35. #define MB           (1048576)
  36. #define KB            1024
  37. #define MN            1000000
  38.  
  39. // ********** IMPORTED FUNCTIONS
  40. extern double pmb_diskio_disksize(int nr);
  41. extern int pmb_diskio_nrdisks(void);
  42. extern void logit(char* s);
  43. extern void DoFileIOAll(void*);
  44. extern void DoFileIO4(void*);
  45. extern void DoFileIO8(void*);
  46. extern void DoFileIO16(void*);
  47. extern void DoFileIO32(void*);
  48. extern void DoFileIO64(void*);
  49.  
  50. // ********** EXPORTED FUNCTIONS
  51. void err(char* s);
  52. void InfoBox(char* s);
  53. void WarnBox(char* s);
  54. void ErrorBox(char* s);
  55. int gtWarp = 0;
  56. ULONG ulDriveNum = 1;
  57. ULONG ulDriveMap = 0;
  58. ULONG ulDriveMap1 = 0;
  59.  
  60. // ********** LOCAL FUNCTIONS
  61. static void SetTitle(char* s);
  62. static void UpdateWindow(HPS hpsPaint, PRECTL pRect, s32 scrollValue);
  63. static void Print(s32 row, s32 col, char* string, PRECTL pRect,
  64.                   s32 scrollValue, HPS hpsPaint, s32 color);
  65. static void SetMenuState(bool active);
  66. static void UpdateAll(void);
  67. static void SaveResults(void);
  68. static void PrintFile(s32 newlines, s32 col, char* string, FILE* fp);
  69. void _Optlink ShowWaitWindow(void*);
  70. void _Optlink Flashlight(void*);
  71. MRESULT APIENTRY fnShowWait(HWND, ULONG, MPARAM, MPARAM);
  72. void _Optlink GetDriveInfo(void*);
  73. PSZ DoScanConfigSys(PSZ, int);
  74. void GetMachineStuff(HWND);
  75. MRESULT APIENTRY fnMachineStuff (HWND, ULONG, MPARAM, MPARAM);
  76.  
  77. ULONG BootDriveLetter;
  78. ULONG action, minfree, pdisknum, swapfilegrown = 0, maxswapfilesize = 0;
  79. float startsize, fatcachesize, hpfscachesize;
  80. char CSpath[_MAX_PATH];
  81. ULONG value[QSV_MAX] = {0};
  82. BYTE coproc;
  83. int fatdisks = 0, hpfsdisks = 0, curdiskFAT = 0;
  84. double fatdiskspace = 0, hpfsdiskspace = 0;
  85. BOOL fileiodisabled = 0;
  86. HWND hwndDlgB;
  87. volatile int  flashit  = 0;
  88. HEV hevEvent2 = 0, hevEvent3 = 0;
  89.  
  90. MRESULT EXPENTRY ClientWindowProc ( HWND hwndWnd,
  91.    ULONG ulMsg,
  92.    MPARAM mpParm1,
  93.    MPARAM mpParm2 );
  94.  
  95. // ********** EXPORTED DATA
  96. double test_time;
  97. static HWND   hwndClient = NULLHANDLE;
  98. static HWND   hwndVertScroll;
  99. static HWND   hwndMenu;
  100.  
  101. // ********** LOCAL DATA
  102. static bool thread_running;
  103. static s32  fontW;
  104. static s32  fontH;
  105. static HPS  mainHps = NULLHANDLE;
  106. //static HAB  hab = NULLHANDLE;
  107. static s32 scroll = 0;
  108. static s32 oldscroll = 0;
  109. static  HWND        hwndFrame = NULLHANDLE;
  110. ULONG       vernum[QSV_MAX] = {0};
  111. char pszFullFile[CCHMAXPATH] = "RESULT.TXT";/* File filter string       */
  112.  
  113. HINI hini;
  114. char* szIniFileName   = "SYSBENCH.INI";
  115. char* pszApp          = "SYSBENCH";
  116. char* pszKeyName      = "Name";
  117. char* pszKeyMobo      = "Mobo";
  118. char* pszKeyProcessor = "Processor";
  119. char* pszKeyMake      = "Make";
  120. char* pszKeyCache     = "Cache";
  121. char* pszKeyChipset   = "Chipset";
  122. char* pszKeyGraphics  = "Graphics";
  123. char* pszKeyDisk      = "Disk";
  124.  
  125. char Machinename[100]     = "Unknown machine name";
  126. char Moboname[100]        = "Unknown motherboard make";
  127. char Processor[100]       = "Unknown processor";
  128. char MachineMake[100]     = "Unknown machine manufacturer";
  129. char CacheAmount[100]     = "Unknown external cache";
  130. char Chipset[100]         = "Unknown motherboard chipset";
  131. char Graphicscard[100]    = "Unknown graphics card";
  132. char DiskController[100]  = "Unknown disk controller";
  133.  
  134. int NamedC = 0, MobodC = 0, ChipdC = 0, MakedC = 0, CachdC = 0, ProcdC = 0, GrapdC = 0, DiskdC = 0;
  135. int MDataPrompt = 0;
  136. ULONG Machnlen, Mobonlen, Procnlen, Mmaknlen, Cachnlen, Chipnlen, Grapnlen, Disknlen;
  137.  
  138. int AutoBench = 0;
  139.  
  140. struct glob_data data = {
  141.   1,
  142.   1,
  143.   { 100, 100, 100, 100, 100, 100, 100, 100, 100, 100 },
  144.   {
  145.     {
  146.       "Graphics",
  147.       8,
  148.       {
  149.         { "BitBlt S->S cpy",  -1.0, MN, "Mpixels/s" },
  150.         { "BitBlt M->S cpy",  -1.0, MN, "Mpixels/s" },
  151.         { "Filled Rectangle", -1.0, MN, "Mpixels/s" },
  152.         { "Pattern Fill",     -1.0, MN, "Mpixels/s" },
  153.         { "Vertical Lines",   -1.0, MN, "Mpixels/s" },
  154.         { "Horizontal Lines", -1.0, MN, "Mpixels/s" },
  155.         { "Diagonal Lines",   -1.0, MN, "Mpixels/s" },
  156.         { "Text Render",      -1.0, MN, "Mpixels/s" }
  157.       },
  158.       -1.0,
  159.       "PM-marks"
  160.     },
  161.     {
  162.       "CPU integer",
  163.       4,
  164.       {
  165.         { "Dhrystone",      -1.0, MN, "VAX 11/780 MIPS" },
  166.         { "Hanoi",          -1.0, 1, "moves/25 usec" },
  167.         { "Heapsort",       -1.0, MN, "MIPS" },
  168.         { "Sieve",          -1.0, MN, "MIPS" }
  169.       },
  170.       -1.0,
  171.       "CPUint-marks"
  172.     },
  173.     {
  174.       "CPU float",
  175.       3,
  176.       {
  177.         { "Linpack",            -1.0, 1000, "MFLOPS" },
  178.         { "Flops",              -1.0, MN, "MFLOPS" },
  179.         { "Fast Fourier Tr.",   -1.0, 1, "VAX FFT's" }
  180.       },
  181.       -1.0,
  182.       "CPUfloat-marks"
  183.     },
  184.     {
  185.       "Direct Interface to video extensions - DIVE",
  186.       3,
  187.       {
  188.         { "Video bus bandw.",    -1.0, MB, "MB/s" },
  189.         { "DIVE fun",            -1.0, 1, "fps at 640x480x256"  },
  190.         { "M->S, DD,   1.00:1",  -1.0, 1, "fps at 640x480x256"  }
  191.       },
  192.       -1.0,
  193.       "DIVE-marks"
  194.     },
  195.     {
  196.       "Disk I/O",
  197.       4,
  198.       {
  199.         { "Avg. data access time",   -1.0, 1.0e-03, "ms" },
  200.         { "Cache/Bus xfer rate  ",   -1.0, MB, "MB/s" },
  201.         { "Average Transfer rate",   -1.0, MB, "MB/s" },
  202.         { "Disk use CPU load    ",   -1.0, 1, "percent" }
  203.       },
  204.       -1.0,
  205.       "DiskIO-marks"
  206.     },
  207.      {
  208.       "File I/O - cache read - Drive C:",
  209.       40,
  210.       {
  211.         { "4Kb seq.   N     N   ",  -1.0, KB, "KB/sec" },
  212.         { "4Kb seq.   N     Y   ",  -1.0, KB, "KB/sec" },
  213.         { "4Kb random N     N   ",  -1.0, KB, "KB/sec" },
  214.         { "4Kb random N     Y   ",  -1.0, KB, "KB/sec" },
  215.         { "4Kb seq.   Y     N   ",  -1.0, KB, "KB/sec" },
  216.         { "4Kb seq.   Y     Y   ",  -1.0, KB, "KB/sec" },
  217.         { "4Kb random Y     N   ",  -1.0, KB, "KB/sec" },
  218.         { "4Kb random Y     Y   ",  -1.0, KB, "KB/sec" },
  219.         { "8Kb seq.   N     N   ",  -1.0, KB, "KB/sec" },
  220.         { "8Kb seq.   N     Y   ",  -1.0, KB, "KB/sec" },
  221.         { "8Kb random N     N   ",  -1.0, KB, "KB/sec" },
  222.         { "8Kb random N     Y   ",  -1.0, KB, "KB/sec" },
  223.         { "8Kb seq.   Y     N   ",  -1.0, KB, "KB/sec" },
  224.         { "8Kb seq.   Y     Y   ",  -1.0, KB, "KB/sec" },
  225.         { "8Kb random Y     N   ",  -1.0, KB, "KB/sec" },
  226.         { "8Kb random Y     Y   ",  -1.0, KB, "KB/sec" },
  227.         { "16K seq.   N     N   ",  -1.0, KB, "KB/sec" },
  228.         { "16K seq.   N     Y   ",  -1.0, KB, "KB/sec" },
  229.         { "16K random N     N   ",  -1.0, KB, "KB/sec" },
  230.         { "16K random N     Y   ",  -1.0, KB, "KB/sec" },
  231.         { "16K seq.   Y     N   ",  -1.0, KB, "KB/sec" },
  232.         { "16K seq.   Y     Y   ",  -1.0, KB, "KB/sec" },
  233.         { "16K random Y     N   ",  -1.0, KB, "KB/sec" },
  234.         { "16K random Y     Y   ",  -1.0, KB, "KB/sec" },
  235.         { "32K seq.   N     N   ",  -1.0, KB, "KB/sec" },
  236.         { "32K seq.   N     Y   ",  -1.0, KB, "KB/sec" },
  237.         { "32K random N     N   ",  -1.0, KB, "KB/sec" },
  238.         { "32K random N     Y   ",  -1.0, KB, "KB/sec" },
  239.         { "32K seq.   Y     N   ",  -1.0, KB, "KB/sec" },
  240.         { "32K seq.   Y     Y   ",  -1.0, KB, "KB/sec" },
  241.         { "32K random Y     N   ",  -1.0, KB, "KB/sec" },
  242.         { "32K random Y     Y   ",  -1.0, KB, "KB/sec" },
  243.         { "64K seq.   N     N   ",  -1.0, KB, "KB/sec" },
  244.         { "64K seq.   N     Y   ",  -1.0, KB, "KB/sec" },
  245.         { "64K random N     N   ",  -1.0, KB, "KB/sec" },
  246.         { "64K random N     Y   ",  -1.0, KB, "KB/sec" },
  247.         { "64K seq.   Y     N   ",  -1.0, KB, "KB/sec" },
  248.         { "64K seq.   Y     Y   ",  -1.0, KB, "KB/sec" },
  249.         { "64K random Y     N   ",  -1.0, KB, "KB/sec" },
  250.         { "64K random Y     Y   ",  -1.0, KB, "KB/sec" },
  251.       },
  252.       -1.0,
  253.       "File I/O-marks"
  254.     },
  255.     {
  256.       "Memory",
  257.       27,
  258.       {
  259.         { "5    kB copy", -1.0, MB, "MB/s" },
  260.         { "10   kB copy", -1.0, MB, "MB/s" },
  261.         { "20   kB copy", -1.0, MB, "MB/s" },
  262.         { "40   kB copy", -1.0, MB, "MB/s" },
  263.         { "80   kB copy", -1.0, MB, "MB/s" },
  264.         { "160  kB copy", -1.0, MB, "MB/s" },
  265.         { "320  kB copy", -1.0, MB, "MB/s" },
  266.         { "640  kB copy", -1.0, MB, "MB/s" },
  267.         { "1280 kB copy", -1.0, MB, "MB/s" },
  268.         { "5    kB read", -1.0, MB, "MB/s" },
  269.         { "10   kB read", -1.0, MB, "MB/s" },
  270.         { "20   kB read", -1.0, MB, "MB/s" },
  271.         { "40   kB read", -1.0, MB, "MB/s" },
  272.         { "80   kB read", -1.0, MB, "MB/s" },
  273.         { "160  kB read", -1.0, MB, "MB/s" },
  274.         { "320  kB read", -1.0, MB, "MB/s" },
  275.         { "640  kB read", -1.0, MB, "MB/s" },
  276.         { "1280 kB read", -1.0, MB, "MB/s" },
  277.         { "5    kB write", -1.0, MB, "MB/s" },
  278.         { "10   kB write", -1.0, MB, "MB/s" },
  279.         { "20   kB write", -1.0, MB, "MB/s" },
  280.         { "40   kB write", -1.0, MB, "MB/s" },
  281.         { "80   kB write", -1.0, MB, "MB/s" },
  282.         { "160  kB write", -1.0, MB, "MB/s" },
  283.         { "320  kB write", -1.0, MB, "MB/s" },
  284.         { "640  kB write", -1.0, MB, "MB/s" },
  285.         { "1280 kB write", -1.0, MB, "MB/s" },
  286.       },
  287.       -1.0,
  288.       "Mem-marks"
  289.     },
  290.   }
  291. };
  292.  
  293.  
  294. INT main (int argc, char * argv[])
  295. {
  296.   FATTRS      fat;
  297.   LONG        match;
  298.   HMQ         hmq          = NULLHANDLE;
  299.   HAB         hab          = NULLHANDLE;      /* PM anchor block handle         */
  300.   HWND        hwndDeskTop;
  301.   ERRORID     erridErrorCode;/* last error id code                   */
  302.   ULONG       flCreate     = 0UL, ulPostCount = 0;
  303.   BOOL        bLoop;
  304.   QMSG        qmsg;
  305.   RECTL       rect;
  306.   s32         x,y,w,h, i;
  307.   CHAR        tmp[256];
  308.   int         rc           = 1, index = 0;
  309.   APIRET      ulrc         = 0;
  310.   BOOL        drivechecked = 0;
  311.   DATETIME    datetime     = {0};
  312.   FONTMETRICS fmMetrics ;
  313.  
  314.   if (argc > 1)
  315.     {                                             /* if any argument passed */
  316.     for(index = 1;index < argc;index++)
  317.        {
  318.        if (strcmpi(argv[index],"/all") == 0)
  319.           {
  320.           AutoBench = 1;                 /* set auto mode on */
  321.           }
  322.        else
  323.           {
  324.           if (strstr(strupr(argv[index]),"/R:"))
  325.              {
  326.              char* n1 = strstr(strupr(argv[index]), "/R:");
  327.              n1 = n1 +3;
  328.              strcpy(pszFullFile, n1);
  329.              }
  330.           }
  331.        }                                 /* end for */
  332.     }
  333.  
  334.   rc = DosQuerySysInfo(QSV_VERSION_MAJOR,
  335.                       QSV_VERSION_MINOR,
  336.                       (PVOID)vernum,
  337.                       sizeof(ULONG)*QSV_MAX);
  338.  
  339.   if ((vernum[0] <= 20) &&
  340.       (vernum[1] <  30))     /* if prior to Warp */
  341.      {
  342.      gtWarp = 0;
  343.      }
  344.   else
  345.      {
  346.      gtWarp = 1;
  347.      }
  348.  
  349.   rc = DosCreateEventSem(NULL,          /* Unnamed semaphore            */
  350.                         &hevEvent2,     /* Handle of semaphore returned */
  351.                         DC_SEM_SHARED,  /* Indicate a shared semaphore  */
  352.                         FALSE);         /* Put in RESET state           */
  353.  
  354.   _beginthread(ShowWaitWindow, NULL, START_STACKSIZE, NULL); /* show Wait... window */
  355.  
  356.   GetMachineInfo();                /* scan CONFIG.SYS for SWAPPATH etc. */
  357.  
  358.   DosSleep(500);                   /* give time for show wait thread to display dialog */
  359.  
  360.   ulrc = DosQueryCurrentDisk(&ulDriveNum, &ulDriveMap);
  361.  
  362.   DosError(FERR_DISABLEHARDERR);
  363.  
  364.   for (i = 2; i <= 25; i++)   /* do from first possible HD upwards */
  365.      {
  366.      if ( ((ulDriveMap << (31-i)) >> 31) ) /* if bit in drive array is on */
  367.         {
  368.         typedef struct _FSINFOBUF
  369.            {  ULONG        ulVolser;   /* Volume serial number */
  370.            VOLUMELABEL  vol;        /* Volume label         */
  371.            } FSINFOBUF;
  372.         typedef FSINFOBUF *PFSINFOBUF;
  373.         char szDeviceName[3];
  374.         FSINFOBUF VolumeInfo          = {0};        /* File system info buffer */
  375.         BYTE         fsqBuffer[sizeof(FSQBUFFER2) + (3 * CCHMAXPATH)] = {0};
  376.         ULONG        cbBuffer         = sizeof(fsqBuffer);        /* Buffer length) */
  377.         PFSQBUFFER2  pfsqBuffer       = (PFSQBUFFER2) fsqBuffer;
  378.         ULONG        ulOrdinal        = 0;     /* Ordinal of entry in name list      */
  379.         PBYTE        pszFSDName       = NULL;  /* pointer to FS name                 */
  380.         ULONG        aulFSInfoBuf[40] = {0};         /* File system info buffer     */
  381.  
  382.         ulrc = DosQueryFSInfo(i+1,
  383.                              FSIL_VOLSER,      /* Request volume information */
  384.                              &VolumeInfo,      /* Buffer for information     */
  385.                              sizeof(FSINFOBUF));  /* Size of buffer          */
  386.  
  387.         if (ulrc != NO_ERROR)
  388.            {
  389.            if (ulrc == ERROR_BAD_NETPATH || ulrc == ERROR_NOT_READY || ulrc == ERROR_BAD_NET_NAME)
  390.               {
  391.               continue;
  392.               }
  393.            else
  394.               {
  395.               sprintf(tmp, "DosQueryFSInfo error: return code = %u\n", ulrc);
  396.               logit(tmp);
  397.               continue;
  398.               }
  399.            }
  400.  
  401.         szDeviceName[0] = 'A'+i;
  402.         szDeviceName[1] = ':';
  403.         szDeviceName[2] = (char)NULL;
  404.  
  405.         ulrc = DosQueryFSAttach(szDeviceName,   /* Logical drive of attached FS      */
  406.                              ulOrdinal,       /* ignored for FSAIL_QUERYNAME       */
  407.                              FSAIL_QUERYNAME, /* Return data for a Drive or Device */
  408.                              pfsqBuffer,      /* returned data                     */
  409.                              &cbBuffer);      /* returned data length              */
  410.  
  411.         if (ulrc != NO_ERROR)
  412.            {
  413.            sprintf(tmp, "DosQueryFSAttach error: return code = %u\n", ulrc);
  414.            logit(tmp);
  415.            return 1;
  416.            }
  417.         else
  418.            {
  419.            pszFSDName = (PBYTE)(pfsqBuffer->szName + pfsqBuffer->cbName + 1);
  420.            }
  421.  
  422.         if (!strcmp(pszFSDName, "FAT"))
  423.            {
  424.            fatdisks++;
  425.            curdiskFAT = 1;
  426.            }
  427.         else
  428.            {
  429.            if (!strcmp(pszFSDName, "HPFS"))
  430.               {
  431.               hpfsdisks++;
  432.               curdiskFAT = 2;
  433.               }
  434.            else
  435.               {
  436.               curdiskFAT = 0; /*  if anything except FAT or HPFS */
  437.               }
  438.            }
  439.  
  440.  
  441.         if (curdiskFAT)
  442.            {
  443.            rc = DosQueryFSInfo(i+1,            /* Drive number      */
  444.                               FSIL_ALLOC,             /* Level 1 allocation info */
  445.                               (PVOID)aulFSInfoBuf,    /* Buffer                  */
  446.                               sizeof(aulFSInfoBuf));  /* Size of buffer          */
  447.  
  448.            if (rc != NO_ERROR)
  449.               {
  450.               sprintf(tmp, "DosQueryFSInfo error: return code = %u\n", rc);
  451.               logit(tmp);
  452.               return 1;
  453.               }
  454.            else
  455.               {
  456.               if (curdiskFAT == 1)
  457.                  {
  458.                  fatdiskspace = fatdiskspace + (aulFSInfoBuf[1] * aulFSInfoBuf[2] * (USHORT)aulFSInfoBuf[4])/(MB);
  459.                  }
  460.               if (curdiskFAT == 2)
  461.                  {
  462.                  hpfsdiskspace = hpfsdiskspace + (aulFSInfoBuf[1] * aulFSInfoBuf[2] * (USHORT)aulFSInfoBuf[4])/(MB);
  463.                  }
  464.               }
  465.  
  466.            if ((aulFSInfoBuf[1] * aulFSInfoBuf[3] * (USHORT)aulFSInfoBuf[4]) > (10 * MB)) /* if freespace > 10Mb */
  467.               {
  468.               ulDriveMap1 = ulDriveMap1 | (0x80000000 >> 31-i);
  469.               }
  470.            }
  471.         }
  472.      }
  473.  
  474.   DosError(FERR_ENABLEHARDERR);
  475.  
  476.   hab = WinInitialize ( 0UL );
  477.  
  478.   if (hab == NULLHANDLE)
  479.      {
  480.      erridErrorCode = WinGetLastError(hab);
  481.      printf("WinGetLastError after WinInitialize returned %x\n", erridErrorCode);
  482.      exit(2);
  483.      }
  484.  
  485.   hmq = WinCreateMsgQueue ( hab, 0UL );
  486.  
  487.   if (hmq == NULLHANDLE)
  488.      {
  489.      erridErrorCode = WinGetLastError(hab);
  490.      printf("WinGetLastError after WinCreateMsgQueue returned %x\n", erridErrorCode);
  491.      exit(2);
  492.      }
  493.  
  494.   rc = DosWaitEventSem(hevEvent2, 60000); /* wait 1 minute for flashlight thread */
  495.  
  496.   if (rc != NO_ERROR)
  497.      {
  498.      sprintf(tmp, "DosWaitEventSem returned rc = %d", rc);
  499.      logit(tmp);
  500.      return 1;
  501.      }
  502.   else
  503.      {
  504.      WinSendMsg(hwndDlgB, /* simulate pushing the non-existent button */
  505.                WM_COMMAND,
  506.                (MPARAM)MPFROMSHORT(IDD_SHOWWAIT5),
  507.                (MPARAM)MPFROM2SHORT(CMDSRC_PUSHBUTTON, TRUE));
  508.      rc = DosResetEventSem(hevEvent2,            /* reset him so we can wait again */
  509.                           &ulPostCount);
  510.      }
  511.  
  512.   rc = WinRegisterClass(hab,
  513.                        CLS_CLIENT,
  514.                        ClientWindowProc,
  515.                        CS_SIZEREDRAW,       /*  CS_SYNCPAINT |  */
  516.                        0UL );
  517.  
  518.   if ( rc != TRUE )
  519.      {
  520.      logit("WinRegisterClass failed") ;
  521.      exit(4);
  522.      }
  523.  
  524.   flCreate = FCF_TITLEBAR    |
  525.              FCF_SYSMENU     |
  526.              FCF_SIZEBORDER  |
  527.              FCF_MENU        |
  528.              FCF_MINMAX      |
  529.              FCF_TASKLIST    |
  530.              FCF_NOBYTEALIGN |
  531.              FCF_VERTSCROLL;
  532.  
  533.   hwndDeskTop = WinQueryDesktopWindow(hab,
  534.                                      NULLHANDLE);
  535.  
  536.   hwndFrame = WinCreateStdWindow(hwndDeskTop,
  537.                                 WS_VISIBLE,
  538.                                 &flCreate,
  539.                                 CLS_CLIENT,
  540.                                 SYSB_VER,
  541.                                 CS_SIZEREDRAW,
  542.                                 NULLHANDLE,
  543.                                 WND_MAIN,
  544.                                 &hwndClient );
  545.  
  546.   if ( hwndFrame == NULLHANDLE )
  547.      {
  548.      logit("hwndFrame is NULLHANDLE");
  549.      exit(6);
  550.      }
  551.  
  552.   mainHps = WinGetPS(hwndClient);
  553.  
  554.   fat.usRecordLength  = sizeof(FATTRS); /* sets size of structure   */
  555.   fat.fsSelection     = 0;              /* uses default selection           */
  556.   fat.lMatch          = 0;              /* does not force match             */
  557.   fat.idRegistry      = 0;              /* uses default registry            */
  558.   fat.usCodePage      = 0;              /* code-page 850                    */
  559.   fat.lMaxBaselineExt = 12L;            /* requested font height is 12 pels */
  560.   fat.lAveCharWidth   = 8L;             /* requested font width is 12 pels  */
  561.   fat.fsType          = 0;              /* uses default type                */
  562.   fat.fsFontUse       = 0;              /* doesn't mix with graphics */
  563.  
  564.   strcpy(fat.szFacename ,"System VIO");
  565.  
  566.   match = GpiCreateLogFont(mainHps,        /* presentation space               */
  567.                           NULL,       /* does not use logical font name   */
  568.                           1L,         /* local identifier                 */
  569.                           &fat);      /* structure with font attributes   */
  570.  
  571.   // match should now be 2 == FONT_MATCH */
  572.  
  573.    if (match != FONT_MATCH)
  574.       {
  575.       logit("Can't get the right font");
  576.       exit(1);
  577.       }
  578.  
  579.   hwndMenu = WinWindowFromID(hwndFrame, FID_MENU);
  580.  
  581.   thread_running = true;               /* set drives info running */
  582.   SetTitle("Initialising");
  583.   SetMenuState(false);
  584.  
  585.   _beginthread(GetDriveInfo, NULL, START_STACKSIZE, NULL); /* get Drive information */
  586.  
  587.   GpiSetCharSet(mainHps, 1L);      /* sets font for presentation space */
  588.  
  589.   GpiQueryFontMetrics(mainHps,
  590.                      sizeof ( fmMetrics ) ,
  591.                      &fmMetrics ) ;
  592.  
  593.   fontH = (14 * fmMetrics.lMaxBaselineExt)/10;
  594.   fontW = fmMetrics.lMaxCharInc;
  595.  
  596.   GpiSetBackMix( mainHps, BM_OVERPAINT );  // how it mixes,
  597.   GpiSetMix( mainHps, FM_OVERPAINT );  // how it mixes,
  598.  
  599.   hwndVertScroll = WinWindowFromID( hwndFrame, FID_VERTSCROLL);
  600.  
  601.   WinQueryWindowRect(HWND_DESKTOP, &rect);
  602.  
  603.   w = 636;
  604.   h = (rect.yTop-rect.yBottom) - 40;
  605.   x = (rect.xRight-rect.xLeft)/2 - w/2;
  606.   y = 40;
  607.  
  608.   WinSetWindowPos(hwndFrame,
  609.                  false,
  610.                  x,
  611.                  y,
  612.                  w,
  613.                  h,
  614.                  SWP_SIZE |
  615.                  SWP_MOVE |
  616.                  SWP_SHOW |
  617.                  SWP_ACTIVATE);
  618.  
  619.   WinQueryWindowRect(hwndClient,
  620.                     &rect);
  621.  
  622.   WinSendMsg( hwndVertScroll,
  623.               SBM_SETSCROLLBAR,
  624.               MPFROMSHORT(0),
  625.               MPFROM2SHORT(0, (DISP_LINES * fontH) - (rect.yTop - rect.yBottom)));
  626.  
  627.   WinSendMsg( hwndVertScroll,
  628.               SBM_SETTHUMBSIZE,
  629.               MPFROM2SHORT(rect.yTop - rect.yBottom, DISP_LINES * fontH),
  630.               NULL);
  631.  
  632.   rc = DosCloseEventSem(hevEvent2); /* close and delete semaphore */
  633.  
  634.   UpdateAll();
  635.  
  636.   if ( hwndFrame != NULLHANDLE )
  637.      {
  638.      bLoop = WinGetMsg ( hab,
  639.                         &qmsg,
  640.                         NULLHANDLE,
  641.                         0,
  642.                         0 );
  643.      while ( bLoop )
  644.         {
  645.         WinDispatchMsg ( hab, &qmsg );
  646.         bLoop = WinGetMsg ( hab,
  647.                            &qmsg,
  648.                            NULLHANDLE,
  649.                            0,
  650.                            0 );
  651.         }
  652.  
  653.      WinReleasePS(mainHps);
  654.      WinDestroyWindow ( hwndFrame );
  655.      }
  656.  
  657.   WinDestroyMsgQueue ( hmq );
  658.   WinTerminate ( hab );
  659.   return 0;
  660. }
  661.  
  662. MRESULT EXPENTRY ClientWindowProc ( HWND hwndWnd,
  663.                                  ULONG ulMsg,
  664.                                  MPARAM mpParm1,
  665.                                  MPARAM mpParm2 )
  666. {
  667.   void *pv = null;
  668.   static bool initialized = false;
  669.   RECTL rect;
  670.   s32 tmp, tmp1;
  671.   bool updateScroll;
  672.   QMSG qmsgPeek;
  673.   bool fDone, exitmsg = 0;
  674.   char tmps[512];
  675.   HAB hab;
  676.  
  677.   switch ( ulMsg ) {
  678.  
  679.   case WM_CREATE:
  680.     /* The client window has been created but is not visible yet.        */
  681.     /* Initialize the window here.                                       */
  682.     hab  = WinQueryAnchorBlock( hwndWnd);
  683.     hini = PrfOpenProfile(hab, szIniFileName); /* open our profile file */
  684.  
  685.     Machnlen = sizeof(Machinename);
  686.     if (!PrfQueryProfileData(hini,             /* get the contents of machine name field */
  687.                             pszApp,
  688.                             pszKeyName,
  689.                             &Machinename,
  690.                             &Machnlen))
  691.        {
  692.        strcpy(Machinename,    "Unknown machine");  /* fill in with defaults if not found */
  693.        MDataPrompt = 1;
  694.        }
  695.  
  696.     Mobonlen = sizeof(Moboname);
  697.     if (!PrfQueryProfileData(hini,             /* get the contents of machine name field */
  698.                             pszApp,
  699.                             pszKeyMobo,
  700.                             &Moboname,
  701.                             &Mobonlen))
  702.        {
  703.        strcpy(Moboname,       "Unknown motherboard");
  704.        MDataPrompt = 1;
  705.        }
  706.  
  707.     Procnlen = sizeof(Processor);
  708.     if (!PrfQueryProfileData(hini,             /* get the contents of machine name field */
  709.                             pszApp,
  710.                             pszKeyProcessor,
  711.                             &Processor,
  712.                             &Procnlen))
  713.        {
  714.        strcpy(Processor,      "Unknown processor");
  715.        MDataPrompt = 1;
  716.        }
  717.  
  718.     Mmaknlen = sizeof(MachineMake);
  719.     if (!PrfQueryProfileData(hini,             /* get the contents of machine name field */
  720.                             pszApp,
  721.                             pszKeyMake,
  722.                             &MachineMake,
  723.                             &Mmaknlen))
  724.        {
  725.        strcpy(MachineMake,    "Unknown manufacturer");
  726.        MDataPrompt = 1;
  727.        }
  728.  
  729.     Cachnlen = sizeof(CacheAmount);
  730.     if (!PrfQueryProfileData(hini,             /* get the contents of machine name field */
  731.                             pszApp,
  732.                             pszKeyCache,
  733.                             &CacheAmount,
  734.                             &Cachnlen))
  735.        {
  736.        strcpy(CacheAmount,    "Unknown external cache amount");
  737.        MDataPrompt = 1;
  738.        }
  739.  
  740.     Chipnlen = sizeof(Chipset);
  741.     if (!PrfQueryProfileData(hini,             /* get the contents of machine name field */
  742.                             pszApp,
  743.                             pszKeyChipset,
  744.                             &Chipset,
  745.                             &Chipnlen))
  746.        {
  747.        strcpy(Chipset,        "Unknown motherboard chipset");
  748.        MDataPrompt = 1;
  749.        }
  750.  
  751.     Grapnlen = sizeof(Graphicscard);
  752.     if (!PrfQueryProfileData(hini,             /* get the contents of machine name field */
  753.                             pszApp,
  754.                             pszKeyGraphics,
  755.                             &Graphicscard,
  756.                             &Grapnlen))
  757.        {
  758.        strcpy(Graphicscard,   "Unknown graphics card");
  759.        MDataPrompt = 1;
  760.        }
  761.  
  762.     Disknlen = sizeof(DiskController);
  763.     if (!PrfQueryProfileData(hini,             /* get the contents of machine name field */
  764.                             pszApp,
  765.                             pszKeyDisk,
  766.                             &DiskController,
  767.                             &Disknlen))
  768.        {
  769.        strcpy(DiskController, "Unknown disk controller");
  770.        MDataPrompt = 1;
  771.        }
  772.  
  773.     PrfCloseProfile(hini);
  774.  
  775.     if (MDataPrompt)
  776.        {
  777.        WinPostMsg(hwndClient,
  778.                  WM_COMMAND,                        /* and send ourselves a message to display dialog box */
  779.                  (MPARAM)MPFROMSHORT(MI_MACHINE_DATA),  /* to be processed when we're initialised */
  780.                  (MPARAM)0);
  781.        }
  782.     break;
  783.  
  784.   case WM_COMMAND:
  785.  
  786.     if (thread_running)
  787.        {
  788.        switch (SHORT1FROMMP(mpParm1))
  789.           {
  790.           case MI_PROJ_QUIT:
  791.              WinPostMsg(hwndWnd, WM_CLOSE, NULL, NULL);
  792.              break;
  793.  
  794.           case MI_PROJ_ABOUT:
  795.           InfoBox("SysBench "SYSB_VER" maintained by\nTrevor Hemsley : 1996-05-18\nEmail: Trevor-Hemsley@dial.pipex.com\n\nOriginal code by Henrik Harmsen 1994-10-01.\n"
  796.                 "\nThanks to Kai Uwe Rommel for the disk IO tests, and Al Aburto for the CPU tests.");
  797.              break;
  798.  
  799.           case MI_MACHINE_DATA:
  800.              GetMachineStuff(hwndWnd);
  801.              break;
  802.           }
  803.        return false;
  804.        }
  805.  
  806.     tmp = MI_MENU_DISKIO_SELECT;
  807.     tmp = data.nr_fixed_disks + MI_MENU_DISKIO_SELECT;
  808.  
  809.     if ((SHORT1FROMMP(mpParm1) > MI_MENU_DISKIO_SELECT) &&
  810.         (SHORT1FROMMP(mpParm1) <= (data.nr_fixed_disks + MI_MENU_DISKIO_SELECT)))
  811.        {
  812.        s32 i, disk;
  813.        i = data.nr_fixed_disks + MI_MENU_DISKIO_SELECT;
  814.        disk = SHORT1FROMMP(mpParm1) - (MI_MENU_DISKIO_SELECT + 1);
  815.        if (disk == data.selected_disk)
  816.           return false;
  817.        data.selected_disk = disk;
  818.        for (i = 0; i < data.nr_fixed_disks; i++)
  819.           {
  820.           WinCheckMenuItem(hwndMenu,
  821.                           MI_MENU_DISKIO_SELECT + i + 1,
  822.                           false);
  823.            }
  824.        WinCheckMenuItem(hwndMenu,
  825.                        MI_MENU_DISKIO_SELECT + data.selected_disk + 1,
  826.                        true);
  827.        sprintf(data.c[comp_disk].title,
  828.               "Disk I/O - disk %d: %5.0f MB",
  829.               data.selected_disk+1,
  830.               data.fixed_disk_size[data.selected_disk]/(KB));
  831.  
  832.        data.c[comp_disk].datalines[disk_avseek].value = -1.0;
  833.        data.c[comp_disk].datalines[disk_busxfer].value = -1.0;
  834.        data.c[comp_disk].datalines[disk_transf].value = -1.0;
  835.        data.c[comp_disk].datalines[disk_cpupct].value = -1.0;
  836.        data.c[comp_disk].total = -1.0;
  837.        UpdateAll();
  838.        return false;
  839.        }
  840.  
  841.     if ((SHORT1FROMMP(mpParm1) > MI_MENU_FILEIO_SELECT) &&
  842.         (SHORT1FROMMP(mpParm1) <= (MI_MENU_FILEIO_SELECT + 26)))
  843.        {
  844.        ULONG ulDriveNum1;
  845.        ulDriveNum1 = SHORT1FROMMP(mpParm1) - MI_MENU_FILEIO_SELECT;
  846.        WinCheckMenuItem(hwndMenu,
  847.                        MI_MENU_FILEIO_SELECT + ulDriveNum,
  848.                        false);
  849.        WinCheckMenuItem(hwndMenu,
  850.                        MI_MENU_FILEIO_SELECT + ulDriveNum1,
  851.                        true);
  852.        ulDriveNum = ulDriveNum1;
  853.        DosSetDefaultDisk(ulDriveNum);
  854.        sprintf(tmps, "File I/O - cache read - Drive %c:", 'A'+ ulDriveNum-1);
  855.        strcpy(data.c[comp_file].title, tmps);
  856.        UpdateAll();
  857.        return false;
  858.        }
  859.  
  860.  
  861.     switch (SHORT1FROMMP(mpParm1))
  862.        {
  863.        case MI_PROJ_QUIT:
  864.           sprintf(tmps,"");
  865.           if (swapfilegrown)
  866.              {
  867.              sprintf(tmps, "Swapfile was larger than initial allocation after %u of these tests (maximum size was %uKB).\n\n",
  868.                     swapfilegrown,
  869.                     (maxswapfilesize/1024));
  870.              exitmsg = 1;
  871.              }
  872.  
  873.           if (fatcachesize)                           /* if any FAT cache allocated */
  874.              {
  875.              float ramsize = value[QSV_TOTPHYSMEM - QSV_BOOT_DRIVE];
  876.              float cachepercent = ramsize / fatcachesize;
  877.              BOOL cachewarn = 0;
  878.  
  879.              if (fatdisks)
  880.                 {
  881.                 if (ramsize >= (4 * MB) &&
  882.                     ramsize <= (8 * MB) &&
  883.                     fatcachesize >= (256 * KB))
  884.                     {
  885.                     cachewarn = 1;
  886.                     sprintf(tmps, "%sWith 4-8Mb RAM you might want to set DISKCACHE=256 or less\n\n", tmps);
  887.                     }
  888.                 if (ramsize >= ((8 * MB)+1) &&
  889.                     ramsize <= (12 * MB) &&
  890.                     fatcachesize >= (384 * KB))
  891.                     {
  892.                     cachewarn = 1;
  893.                     sprintf(tmps, "%sWith 8-12Mb RAM you might want to set DISKCACHE=384 or less\n\n", tmps);
  894.                     }
  895.                 if (ramsize >= ((12 * MB)+1) &&
  896.                     ramsize <= (16 * MB) &&
  897.                     fatcachesize >= (512 * KB))
  898.                     {
  899.                     cachewarn = 1;
  900.                     sprintf(tmps, "%sWith 12-16Mb RAM you might want to set DISKCACHE=512 or less\n\n", tmps);
  901.                     }
  902.                 if (ramsize >= ((16 * MB)+1) &&
  903.                    cachepercent <= 10.1)
  904.                    {
  905.                    cachewarn = 1;
  906.                    sprintf(tmps, "%sYour FAT diskcache is set to 10%% or more of your RAM\n\n", tmps);
  907.                    }
  908.                 if (cachewarn)
  909.                    {
  910.                    sprintf(tmps, "%sDISKCACHE is set to %.0fKb of your total %.0uKb RAM\n\n",
  911.                           tmps,
  912.                           (fatcachesize/KB),
  913.                           (value[QSV_TOTPHYSMEM - QSV_BOOT_DRIVE]/KB));
  914.                    exitmsg = 1;
  915.                    }
  916.                 }
  917.              else
  918.                 {
  919.                 sprintf(tmps, "%sDISKCACHE is set to %.0fKb but you have no FAT disks\n\n",
  920.                        tmps,
  921.                        (fatcachesize/KB));
  922.                 exitmsg = 1;
  923.                 }
  924.              }
  925.  
  926.           if (hpfscachesize)
  927.              {
  928.              float ramsize = value[QSV_TOTPHYSMEM - QSV_BOOT_DRIVE];
  929.              float cachepercent = ramsize / hpfscachesize;
  930.              BOOL cachewarn = 0;
  931.  
  932.              if (hpfsdisks)
  933.                 {
  934.                 if (ramsize >= (4 * MB) &&
  935.                     ramsize <= (8 * MB) &&
  936.                     (hpfscachesize >= (48 * KB) && hpfscachesize <= (128 * KB) ))
  937.                     {
  938.                     cachewarn = 1;
  939.                     sprintf(tmps, "%sWith 4-8Mb RAM you might want to set IFS=HPFS.IFS /CACHE between 48 and 128\n\n", tmps);
  940.                     }
  941.                 if (ramsize >= ((8 * MB)+1) &&
  942.                     ramsize <= (12 * MB) &&
  943.                     (hpfscachesize >= (128 * KB) && hpfscachesize <= (384 * KB)))
  944.                     {
  945.                     cachewarn = 1;
  946.                     sprintf(tmps, "%sWith 8-12Mb RAM you might want to set IFS=HPFS.IFS /CACHE between 128 and 384\n\n", tmps);
  947.                     }
  948.                 if (ramsize >= ((12 * MB)+1) &&
  949.                     ramsize <= (16 * MB) &&
  950.                     (hpfscachesize >= (512 * KB) && hpfscachesize <= (1024 * KB)))
  951.                     {
  952.                     cachewarn = 1;
  953.                     sprintf(tmps, "%sWith 12-16Mb RAM you might want to set IFS=HPFS.IFS /CACHE between 512 and 1024\n\n", tmps);
  954.                     }
  955.                 if (ramsize >= ((16 * MB)+1) &&
  956.                     ramsize <= (24 * MB) &&
  957.                     (hpfscachesize >= (1024 * KB) && hpfscachesize <= (1536 * KB)))
  958.                     {
  959.                     cachewarn = 1;
  960.                     sprintf(tmps, "%sWith 16-24Mb RAM you might want to set IFS=HPFS.IFS /CACHE between 1024 and 1536\n\n", tmps);
  961.                     }
  962.                 if (ramsize >= ((24 * MB)+1) &&
  963.                    (hpfscachesize >= (1536 * KB) && hpfscachesize <= (2048 * KB)-1 ))
  964.                    {
  965.                    cachewarn = 1;
  966.                    sprintf(tmps, "%sWith more than 24Mb RAM you might want to set IFS=HPFS.IFS /CACHE between 1536 and 2048\n\n", tmps);
  967.                    }
  968.  
  969.                 if (cachewarn)
  970.                    {
  971.                    sprintf(tmps, "%sHPFS.IFS /CACHE is set to %.0fKb of your total %.0uKb RAM\n\n",
  972.                           tmps,
  973.                           (hpfscachesize/KB),
  974.                           (value[QSV_TOTPHYSMEM - QSV_BOOT_DRIVE]/KB));
  975.                    exitmsg = 1;
  976.                    }
  977.                 }
  978.              else
  979.                 {
  980.                 sprintf(tmps, "%sIFS=HPFS.IFS /CACHE is set to %.0fKb but you have no HPFS disks\n\n",
  981.                        tmps,
  982.                        (hpfscachesize/KB));
  983.                 exitmsg = 1;
  984.                 }
  985.              }
  986.  
  987.           if (fatdiskspace > hpfsdiskspace)
  988.              {
  989.              if (fatcachesize < hpfscachesize)
  990.                 {
  991.                 sprintf(tmps, "%sYou have more FAT diskspace than HPFS but your DISKCACHE is less than your HPFS cache.\n\n", tmps);
  992.                 }
  993.              }
  994.           if (fatdiskspace < hpfsdiskspace)
  995.              {
  996.              if (fatcachesize > hpfscachesize)
  997.                 {
  998.                 sprintf(tmps, "%sYou have more HPFS diskspace than FAT but your DISKCACHE is greater than your HPFS cache.\n\n", tmps);
  999.                 }
  1000.              }
  1001.  
  1002.           if (data.c[comp_cpuint].total > 0)
  1003.              {
  1004.              if (data.c[comp_cpuint].total >= 40 &&
  1005.                  value[QSV_MAX_WAIT - QSV_BOOT_DRIVE] > 2)
  1006.                 {
  1007.                 sprintf(tmps, "%sBased on integer score consider setting MAXWAIT=2 instead of current setting of %d\n\n",
  1008.                        tmps,
  1009.                        value[QSV_MAX_WAIT - QSV_BOOT_DRIVE]);
  1010.                 exitmsg = 1;
  1011.                 }
  1012.  
  1013.              if (data.c[comp_cpuint].total >= 70 &&
  1014.                  value[QSV_MAX_WAIT - QSV_BOOT_DRIVE] > 1)
  1015.                 {
  1016.                 sprintf(tmps, "%sBased on integer score consider setting MAXWAIT=1 instead of current setting of %d\n\n",
  1017.                        tmps,
  1018.                        value[QSV_MAX_WAIT - QSV_BOOT_DRIVE]);
  1019.                 exitmsg = 1;
  1020.                 }
  1021.  
  1022.              if (data.c[comp_cpuint].total <= 39 &&
  1023.                  value[QSV_MAX_WAIT - QSV_BOOT_DRIVE] < 3)
  1024.                 {
  1025.                 sprintf(tmps, "%sBased on integer score consider setting MAXWAIT=3 instead of current setting of %d\n\n",
  1026.                        tmps,
  1027.                        value[QSV_MAX_WAIT - QSV_BOOT_DRIVE]);
  1028.                 exitmsg = 1;
  1029.                 }
  1030.              }
  1031.  
  1032.           if (exitmsg)
  1033.              {
  1034.              if (!AutoBench)
  1035.                 {
  1036.                 InfoBox(tmps); /* display diagnostic messages about system */
  1037.                 }
  1038.              }
  1039.  
  1040.           WinPostMsg(hwndWnd, WM_CLOSE, NULL, NULL);
  1041.           break;
  1042.  
  1043.        case MI_PROJ_ABOUT:
  1044.           InfoBox("SysBench "SYSB_VER" maintained by\nTrevor Hemsley : 1996-05-18\nEmail: Trevor-Hemsley@dial.pipex.com\n\nOriginal code by Henrik Harmsen 1994-10-01.\n"
  1045.                 "\nThanks to Kai Uwe Rommel for the disk IO tests, and Al Aburto for the CPU tests.");
  1046.           break;
  1047.  
  1048.        case MI_PROJ_SAVE:
  1049.           SaveResults();
  1050.           break;
  1051.  
  1052.        case MI_PROJ_ALL:
  1053.           SetTitle("Running All tests");
  1054.           SetMenuState(false);
  1055.           _beginthread(DoAll, null, START_STACKSIZE, pv);
  1056.           break;
  1057.  
  1058.        case MI_GFX_BITBLIT_SS:
  1059.           SetTitle("Running BitBlit S->S");
  1060.           SetMenuState(false);
  1061.           _beginthread(DoGfxBlitBlitSS, null, START_STACKSIZE, pv);
  1062.           break;
  1063.  
  1064.        case MI_GFX_BITBLIT_MS:
  1065.           SetTitle("Running BitBlit M->S");
  1066.           SetMenuState(false);
  1067.           _beginthread(DoGfxBlitBlitMS, null, START_STACKSIZE, pv);
  1068.           break;
  1069.  
  1070.        case MI_GFX_FILLRECT:
  1071.           SetTitle("Running Filled Rectangle");
  1072.           SetMenuState(false);
  1073.           _beginthread(DoGfxFillRect, null, START_STACKSIZE, pv);
  1074.           break;
  1075.  
  1076.        case MI_GFX_PATFIL:
  1077.           SetTitle("Running Pattern Fill");
  1078.           SetMenuState(false);
  1079.           _beginthread(DoGfxPatFil, null, START_STACKSIZE, pv);
  1080.           break;
  1081.  
  1082.        case MI_GFX_VLINES:
  1083.           SetTitle("Running VerticalLines");
  1084.           SetMenuState(false);
  1085.           _beginthread(DoGfxVLines, null, START_STACKSIZE, pv);
  1086.           break;
  1087.  
  1088.        case MI_GFX_HLINES:
  1089.           SetTitle("Running HorizontalLines");
  1090.           SetMenuState(false);
  1091.           _beginthread(DoGfxHLines, null, START_STACKSIZE, pv);
  1092.           break;
  1093.  
  1094.        case MI_GFX_DLINES:
  1095.           SetTitle("Running DiagonalLines");
  1096.           SetMenuState(false);
  1097.           _beginthread(DoGfxDLines, null, START_STACKSIZE, pv);
  1098.           break;
  1099.  
  1100.        case MI_GFX_TEXTRENDER:
  1101.           SetTitle("Running TextRender");
  1102.           SetMenuState(false);
  1103.           _beginthread(DoGfxTextRender, null, START_STACKSIZE, pv);
  1104.           break;
  1105.  
  1106.        case MI_GFX_ALL:
  1107.           SetTitle("Running All Graphics tests");
  1108.           SetMenuState(false);
  1109.           _beginthread(DoAllGraphics, null, START_STACKSIZE, pv);
  1110.           break;
  1111.  
  1112.        case MI_CPUINT_DHRY:
  1113.           SetTitle("Running Dhrystone");
  1114.           SetMenuState(false);
  1115.           _beginthread(DoCPUIntDhry, null, START_STACKSIZE, pv);
  1116.           break;
  1117.  
  1118.        case MI_CPUINT_HANOI:
  1119.           SetTitle("Running Hanoi");
  1120.           SetMenuState(false);
  1121.           _beginthread(DoCPUIntHanoi, null, START_STACKSIZE, pv);
  1122.           break;
  1123.  
  1124.        case MI_CPUINT_HEAPS:
  1125.           SetTitle("Running Heapsort");
  1126.           SetMenuState(false);
  1127.           _beginthread(DoCPUIntHeaps, null, START_STACKSIZE, pv);
  1128.           break;
  1129.  
  1130.        case MI_CPUINT_SIEVE:
  1131.           SetTitle("Running Sieve");
  1132.           SetMenuState(false);
  1133.           _beginthread(DoCPUIntSieve, null, START_STACKSIZE, pv);
  1134.           break;
  1135.  
  1136.        case MI_CPUINT_ALL:
  1137.           SetTitle("Running All CPU integer tests");
  1138.           SetMenuState(false);
  1139.           _beginthread(DoAllCPUInt, null, START_STACKSIZE, pv);
  1140.           break;
  1141.  
  1142.        case MI_CPUFLOAT_LINPACK:
  1143.           SetTitle("Running Linpack");
  1144.           SetMenuState(false);
  1145.           _beginthread(DoCPUFloatLinpack, null, START_STACKSIZE, pv);
  1146.           break;
  1147.  
  1148.        case MI_CPUFLOAT_FLOPS:
  1149.           SetTitle("Running FLOPS");
  1150.           SetMenuState(false);
  1151.           _beginthread(DoCPUFloatFlops, null, START_STACKSIZE, pv);
  1152.           break;
  1153.  
  1154.        case MI_CPUFLOAT_FFT:
  1155.           SetTitle("Running FFT");
  1156.           SetMenuState(false);
  1157.           _beginthread(DoCPUFloatFFT, null, START_STACKSIZE, pv);
  1158.           break;
  1159.  
  1160.        case MI_CPUFLOAT_ALL:
  1161.           SetTitle("Running All CPU float tests");
  1162.           SetMenuState(false);
  1163.           _beginthread(DoAllCPUFloat, null, START_STACKSIZE, pv);
  1164.           break;
  1165.  
  1166.        case MI_MEM_5:
  1167.           SetTitle("Running Memcopy 5kB");
  1168.           SetMenuState(false);
  1169.           _beginthread(DoMem5, null, START_STACKSIZE, pv);
  1170.           break;
  1171.  
  1172.        case MI_MEM_10:
  1173.           SetTitle("Running Memcopy 10kB");
  1174.           SetMenuState(false);
  1175.           _beginthread(DoMem10, null, START_STACKSIZE, pv);
  1176.           break;
  1177.  
  1178.        case MI_MEM_20:
  1179.           SetTitle("Running Memcopy 20kB");
  1180.           SetMenuState(false);
  1181.           _beginthread(DoMem20, null, START_STACKSIZE, pv);
  1182.           break;
  1183.  
  1184.        case MI_MEM_40:
  1185.           SetTitle("Running Memcopy 40kB");
  1186.           SetMenuState(false);
  1187.           _beginthread(DoMem40, null, START_STACKSIZE, pv);
  1188.           break;
  1189.  
  1190.        case MI_MEM_80:
  1191.           SetTitle("Running Memcopy 80kB");
  1192.           SetMenuState(false);
  1193.           _beginthread(DoMem80, null, START_STACKSIZE, pv);
  1194.           break;
  1195.  
  1196.        case MI_MEM_160:
  1197.           SetTitle("Running Memcopy 160kB");
  1198.           SetMenuState(false);
  1199.           _beginthread(DoMem160, null, START_STACKSIZE, pv);
  1200.           break;
  1201.  
  1202.        case MI_MEM_320:
  1203.           SetTitle("Running Memcopy 320kB");
  1204.           SetMenuState(false);
  1205.           _beginthread(DoMem320, null, START_STACKSIZE, pv);
  1206.           break;
  1207.  
  1208.        case MI_MEM_640:
  1209.           SetTitle("Running Memcopy 640kB");
  1210.           SetMenuState(false);
  1211.           _beginthread(DoMem640, null, START_STACKSIZE, pv);
  1212.           break;
  1213.  
  1214.        case MI_MEM_1280:
  1215.           SetTitle("Running Memcopy 1280kB");
  1216.           SetMenuState(false);
  1217.           _beginthread(DoMem1280, null, START_STACKSIZE, pv);
  1218.           break;
  1219.  
  1220.        case MI_MEMR_5:
  1221.           SetTitle("Running Memory Read 5kB");
  1222.           SetMenuState(false);
  1223.           _beginthread(DoMemR5, null, START_STACKSIZE, pv);
  1224.           break;
  1225.  
  1226.        case MI_MEMR_10:
  1227.           SetTitle("Running Memory Read 10kB");
  1228.           SetMenuState(false);
  1229.           _beginthread(DoMemR10, null, START_STACKSIZE, pv);
  1230.           break;
  1231.  
  1232.        case MI_MEMR_20:
  1233.           SetTitle("Running Memory Read 20kB");
  1234.           SetMenuState(false);
  1235.           _beginthread(DoMemR20, null, START_STACKSIZE, pv);
  1236.           break;
  1237.  
  1238.        case MI_MEMR_40:
  1239.           SetTitle("Running Memory Read 40kB");
  1240.           SetMenuState(false);
  1241.           _beginthread(DoMemR40, null, START_STACKSIZE, pv);
  1242.           break;
  1243.  
  1244.        case MI_MEMR_80:
  1245.           SetTitle("Running Memory Read 80kB");
  1246.           SetMenuState(false);
  1247.           _beginthread(DoMemR80, null, START_STACKSIZE, pv);
  1248.           break;
  1249.  
  1250.        case MI_MEMR_160:
  1251.           SetTitle("Running Memory Read 160kB");
  1252.           SetMenuState(false);
  1253.           _beginthread(DoMemR160, null, START_STACKSIZE, pv);
  1254.           break;
  1255.  
  1256.        case MI_MEMR_320:
  1257.           SetTitle("Running Memory Read 320kB");
  1258.           SetMenuState(false);
  1259.           _beginthread(DoMemR320, null, START_STACKSIZE, pv);
  1260.           break;
  1261.  
  1262.        case MI_MEMR_640:
  1263.           SetTitle("Running Memory Read 640kB");
  1264.           SetMenuState(false);
  1265.           _beginthread(DoMemR640, null, START_STACKSIZE, pv);
  1266.           break;
  1267.  
  1268.        case MI_MEMR_1280:
  1269.           SetTitle("Running Memory Read 1280kB");
  1270.           SetMenuState(false);
  1271.           _beginthread(DoMemR1280, null, START_STACKSIZE, pv);
  1272.           break;
  1273.  
  1274.        case MI_MEMW_5:
  1275.           SetTitle("Running Memory Write 5kB");
  1276.           SetMenuState(false);
  1277.           _beginthread(DoMemW5, null, START_STACKSIZE, pv);
  1278.           break;
  1279.  
  1280.        case MI_MEMW_10:
  1281.           SetTitle("Running Memory Write 10kB");
  1282.           SetMenuState(false);
  1283.           _beginthread(DoMemW10, null, START_STACKSIZE, pv);
  1284.           break;
  1285.  
  1286.        case MI_MEMW_20:
  1287.           SetTitle("Running Memory Write 20kB");
  1288.           SetMenuState(false);
  1289.           _beginthread(DoMemW20, null, START_STACKSIZE, pv);
  1290.           break;
  1291.  
  1292.        case MI_MEMW_40:
  1293.           SetTitle("Running Memory Write 40kB");
  1294.           SetMenuState(false);
  1295.           _beginthread(DoMemW40, null, START_STACKSIZE, pv);
  1296.           break;
  1297.  
  1298.        case MI_MEMW_80:
  1299.           SetTitle("Running Memory Write 80kB");
  1300.           SetMenuState(false);
  1301.           _beginthread(DoMemW80, null, START_STACKSIZE, pv);
  1302.           break;
  1303.  
  1304.        case MI_MEMW_160:
  1305.           SetTitle("Running Memory Write 160kB");
  1306.           SetMenuState(false);
  1307.           _beginthread(DoMemW160, null, START_STACKSIZE, pv);
  1308.           break;
  1309.  
  1310.        case MI_MEMW_320:
  1311.           SetTitle("Running Memory Write 320kB");
  1312.           SetMenuState(false);
  1313.           _beginthread(DoMemW320, null, START_STACKSIZE, pv);
  1314.           break;
  1315.  
  1316.        case MI_MEMW_640:
  1317.           SetTitle("Running Memory Write 640kB");
  1318.           SetMenuState(false);
  1319.           _beginthread(DoMemW640, null, START_STACKSIZE, pv);
  1320.           break;
  1321.  
  1322.        case MI_MEMW_1280:
  1323.           SetTitle("Running Memory Write 1280kB");
  1324.           SetMenuState(false);
  1325.           _beginthread(DoMemW1280, null, START_STACKSIZE, pv);
  1326.           break;
  1327.  
  1328.        case MI_MEM_ALL:
  1329.           SetTitle("Running All Memory tests");
  1330.           SetMenuState(false);
  1331.           _beginthread(DoAllMem, null, START_STACKSIZE, pv);
  1332.           break;
  1333.  
  1334.        case MI_DIVE_VIDEO_BW:
  1335.           SetTitle("Running Video Bandwidth");
  1336.           SetMenuState(false);
  1337.           _beginthread(DoDiveVBW, null, START_STACKSIZE, pv);
  1338.           break;
  1339.  
  1340.        case MI_DIVE_ROTATE_SCREEN:
  1341.           SetTitle("Running DIVE fun");
  1342.           SetMenuState(false);
  1343.           _beginthread(DoDiveRot, null, START_STACKSIZE, pv);
  1344.           break;
  1345.  
  1346.        case MI_DIVE_MS_11:
  1347.           SetTitle("Running DIVE M->S 1:1");
  1348.           SetMenuState(false);
  1349.           _beginthread(DoDiveMS11, null, START_STACKSIZE, pv);
  1350.           break;
  1351.  
  1352.        case MI_DIVE_ALL:
  1353.           SetTitle("Running All DIVE tests");
  1354.           SetMenuState(false);
  1355.           _beginthread(DoAllDIVE, null, START_STACKSIZE, pv);
  1356.           break;
  1357.  
  1358.        case MI_DISKIO_AVSEEK:
  1359.           SetTitle("Running Average Data Access Time");
  1360.           SetMenuState(false);
  1361.           _beginthread(DoDiskIOAvSeek, null, START_STACKSIZE, pv);
  1362.           break;
  1363.  
  1364.        case MI_DISKIO_CBXFER:
  1365.           SetTitle("Running Cache/Bus Transfer");
  1366.           SetMenuState(false);
  1367.           _beginthread(DoDiskCacheXfer, null, START_STACKSIZE, pv);
  1368.           break;
  1369.  
  1370.        case MI_DISKIO_TRANS_SPEED:
  1371.           SetTitle("Running Max. transfer speed");
  1372.           SetMenuState(false);
  1373.           _beginthread(DoDiskIOTransSpeed, null, START_STACKSIZE, pv);
  1374.           break;
  1375.  
  1376.        case MI_DISKIO_CPU_USAGE:
  1377.           SetTitle("Running CPU Usage percentage");
  1378.           SetMenuState(false);
  1379.           _beginthread(DoDiskIOCPUUsage, null, START_STACKSIZE, pv);
  1380.           break;
  1381.  
  1382.        case MI_DISKIO_ALL:
  1383.           SetTitle("Running All disk I/O tests");
  1384.           SetMenuState(false);
  1385.           _beginthread(DoAllDiskIO, null, START_STACKSIZE, pv);
  1386.           break;
  1387.  
  1388.        case MI_FILEIO_ALL:
  1389.           SetTitle("Running All file I/O tests");
  1390.           SetMenuState(false);
  1391.           _beginthread(DoFileIOAll, null, START_STACKSIZE, pv);
  1392.           break;
  1393.  
  1394.        case MI_FILEIO_4KB:
  1395.           SetTitle("Running 4KB file I/O tests");
  1396.           SetMenuState(false);
  1397.           _beginthread(DoFileIO4, null, START_STACKSIZE, pv);
  1398.           break;
  1399.  
  1400.        case MI_FILEIO_8KB:
  1401.           SetTitle("Running 8KB file I/O tests");
  1402.           SetMenuState(false);
  1403.           _beginthread(DoFileIO8, null, START_STACKSIZE, pv);
  1404.           break;
  1405.  
  1406.        case MI_FILEIO_16KB:
  1407.           SetTitle("Running 16KB file I/O tests");
  1408.           SetMenuState(false);
  1409.           _beginthread(DoFileIO16, null, START_STACKSIZE, pv);
  1410.           break;
  1411.  
  1412.        case MI_FILEIO_32KB:
  1413.           SetTitle("Running 32KB file I/O tests");
  1414.           SetMenuState(false);
  1415.           _beginthread(DoFileIO32, null, START_STACKSIZE, pv);
  1416.           break;
  1417.  
  1418.        case MI_FILEIO_64KB:
  1419.           SetTitle("Running 64KB file I/O tests");
  1420.           SetMenuState(false);
  1421.           _beginthread(DoFileIO64, null, START_STACKSIZE, pv);
  1422.           break;
  1423.  
  1424.        case MI_MACHINE_DATA:
  1425.           GetMachineStuff(hwndWnd);
  1426.           break;
  1427.  
  1428. /*       default:
  1429.           tmp = 1;
  1430.           break; */
  1431.        }
  1432.        break;
  1433.  
  1434.   case WM_PAINT:
  1435.      {
  1436.      FATTRS      fat;
  1437.      LONG        match;
  1438.      FONTMETRICS fmMetrics ;
  1439.      HPS               hpsPaint ;
  1440.      RECTL             rclRect ;
  1441.      RECTL             rclWindow ;
  1442.      ULONG             ulCharHeight ;
  1443.      HWND              hwndEnum ;
  1444.      HWND              hwndFrame ;
  1445.      HENUM             heEnum ;
  1446.      POINTL            point;
  1447.      HRGN              newHrgn, oldHrgn, dummy;
  1448.      s32               complexity;
  1449.      RECTL             clipRect;
  1450.  
  1451.      if (!initialized)
  1452.         {
  1453.         initialized = true;
  1454.         }
  1455.  
  1456.      hpsPaint = WinBeginPaint ( hwndWnd,
  1457.                              NULLHANDLE,
  1458.                              &rclRect ) ;
  1459.  
  1460. // This should work, but there was a bug in Warp II
  1461. //      newHrgn = GpiQueryClipRegion(hpsPaint);
  1462. //      complexity = GpiSetClipRegion(mainHps, newHrgn, &oldHrgn);
  1463. //      WinEndPaint(hpsPaint);
  1464.  
  1465.      GpiQueryClipBox(hpsPaint, &clipRect);
  1466.      clipRect.xRight++;
  1467.      clipRect.yTop++;
  1468.      newHrgn = GpiCreateRegion(mainHps, 1, &clipRect);
  1469.      GpiSetClipRegion(mainHps, newHrgn, &oldHrgn);
  1470.      if (NULLHANDLE != oldHrgn)
  1471.         {
  1472.         GpiDestroyRegion(mainHps, oldHrgn);
  1473.         }
  1474.  
  1475.      WinFillRect(mainHps, &rclRect, CLR_BLACK);
  1476.  
  1477.      WinQueryWindowRect ( hwndWnd, &rclWindow );
  1478.      UpdateWindow(mainHps,
  1479.                  &rclWindow,
  1480.                  scroll);
  1481.  
  1482.      oldscroll = scroll;
  1483.      WinEndPaint(hpsPaint);
  1484.      }
  1485.      break;
  1486.  
  1487.   case THR_DONE:
  1488.      SetTitle("Ready");
  1489.      SetMenuState(true);
  1490.      thread_running = false;
  1491.      if (AutoBench)
  1492.         {
  1493.         if (AutoBench == 2)
  1494.            {
  1495.            WinPostMsg(hwndClient,
  1496.                      WM_COMMAND,
  1497.                      (MPARAM)MPFROMSHORT(MI_PROJ_SAVE),
  1498.                      (MPARAM)MPFROM2SHORT(CMDSRC_MENU, TRUE));
  1499.            AutoBench++;
  1500.            }
  1501.         }
  1502.  
  1503.      break;
  1504.  
  1505.   case THR_UPDATE:
  1506.      UpdateAll();
  1507.      if (AutoBench)
  1508.         {
  1509.         if (AutoBench == 1)
  1510.            {
  1511.            WinPostMsg(hwndClient,
  1512.                      WM_COMMAND,
  1513.                      (MPARAM)MPFROMSHORT(MI_PROJ_ALL),
  1514.                      (MPARAM)MPFROM2SHORT(CMDSRC_MENU, TRUE));
  1515.            AutoBench++;
  1516.            }
  1517.         }
  1518.      break;
  1519.  
  1520.   case WM_SIZE:
  1521.      {
  1522.      s32 tmp;
  1523.  
  1524.      WinQueryWindowRect(hwndClient, &rect);
  1525.  
  1526.      tmp = DISP_LINES * fontH - (rect.yTop - rect.yBottom);
  1527.  
  1528.      if (tmp < 0)
  1529.         tmp = 0;
  1530.      if (scroll > tmp)
  1531.         scroll = tmp;
  1532.  
  1533.      WinSendMsg( hwndVertScroll,
  1534.                SBM_SETSCROLLBAR,
  1535.                MPFROMSHORT(scroll),
  1536.                MPFROM2SHORT(0, tmp));
  1537.  
  1538.      WinSendMsg( hwndVertScroll,
  1539.                SBM_SETTHUMBSIZE,
  1540.                MPFROM2SHORT(rect.yTop - rect.yBottom, DISP_LINES * fontH),
  1541.                NULL);
  1542.  
  1543.      }
  1544.      break;
  1545.  
  1546.   case WM_VSCROLL:
  1547.      updateScroll = false;
  1548.      WinQueryWindowRect(hwndClient, &rect);
  1549.      switch( SHORT2FROMMP( mpParm2) )
  1550.         {
  1551.         case SB_LINEUP:
  1552.           scroll -= fontH;
  1553.           updateScroll = true;;
  1554.           break;
  1555.  
  1556.         case SB_LINEDOWN:
  1557.           scroll += fontH;
  1558.           updateScroll = true;;
  1559.           break;
  1560.  
  1561.         case SB_PAGEUP:
  1562.           scroll -= rect.yTop-rect.yBottom;
  1563.           updateScroll = true;;
  1564.           break;
  1565.  
  1566.         case SB_PAGEDOWN:
  1567.           scroll += rect.yTop-rect.yBottom;
  1568.           updateScroll = true;;
  1569.           break;
  1570.  
  1571.         case SB_SLIDERTRACK:
  1572.         case SB_SLIDERPOSITION:
  1573.            scroll = SHORT1FROMMP( mpParm2);
  1574.            break;
  1575.  
  1576.         case SB_ENDSCROLL:
  1577.            break;
  1578.         default:
  1579.            break;
  1580.         }
  1581.  
  1582.     if (updateScroll)
  1583.        {
  1584.        WinQueryWindowRect(hwndClient, &rect);
  1585.        tmp = DISP_LINES * fontH - (rect.yTop - rect.yBottom);
  1586.        if (tmp < 0)
  1587.           tmp = 0;
  1588.        if (scroll > tmp)
  1589.           scroll = tmp;
  1590.        WinSendMsg( hwndVertScroll,
  1591.                   SBM_SETSCROLLBAR,
  1592.                   MPFROMSHORT(scroll),
  1593.                   MPFROM2SHORT(0, tmp));
  1594.        WinSendMsg( hwndVertScroll,
  1595.                   SBM_SETTHUMBSIZE,
  1596.                   MPFROM2SHORT(rect.yTop - rect.yBottom, DISP_LINES * fontH),
  1597.                   NULL);
  1598.        }
  1599.  
  1600.     tmp = DISP_LINES * fontH - (rect.yTop - rect.yBottom);
  1601.     if (scroll > tmp)
  1602.        scroll = tmp;
  1603.     if (scroll < 0)
  1604.        scroll = 0;
  1605.  
  1606.     WinScrollWindow(hwndClient,
  1607.                    0,
  1608.                    scroll-oldscroll,
  1609.                    NULL,
  1610.                    NULL,
  1611.                    NULLHANDLE,
  1612.                    NULL,
  1613.                    SW_INVALIDATERGN);
  1614.  
  1615.     WinUpdateWindow(hwndClient);
  1616.     break;
  1617.  
  1618.   case WM_ERASEBACKGROUND:
  1619.      return MRFROMSHORT ( false );  // No, we'll do this ourselves
  1620.  
  1621.   case WM_CHAR:
  1622.      if (!(CHARMSG(&ulMsg)->fs & KC_KEYUP))
  1623.         {
  1624.         switch (CHARMSG(&ulMsg)->vkey)
  1625.            {
  1626.            case VK_UP:
  1627.            case VK_DOWN:
  1628.            case VK_PAGEUP:
  1629.            case VK_PAGEDOWN:
  1630.               return WinSendMsg(hwndVertScroll, ulMsg, mpParm1, mpParm2);
  1631.            }
  1632.         }
  1633.  
  1634.   default:
  1635.      return WinDefWindowProc ( hwndWnd,
  1636.                               ulMsg,
  1637.                               mpParm1,
  1638.                               mpParm2 );
  1639.   }
  1640.  
  1641.   return MRFROMSHORT ( FALSE );
  1642. }
  1643.  
  1644. void PostFin(int onlyupdate)
  1645. {
  1646. if (onlyupdate)
  1647.    {
  1648.    WinPostMsg(hwndClient, THR_UPDATE, NULL, NULL);
  1649.    }
  1650. else
  1651.    {
  1652.    WinPostMsg(hwndClient, THR_DONE, NULL, NULL);
  1653.    }
  1654. }
  1655.  
  1656. void err(char* s)
  1657. {
  1658. logit(s);
  1659. ErrorBox(s);
  1660. exit(1);
  1661. }
  1662.  
  1663. void warn(char* s)
  1664. {
  1665. WarnBox(s);
  1666. }
  1667.  
  1668. static void SetTitle(char* s)
  1669.   {
  1670.   char tmp[100];
  1671.   sprintf(tmp, "SysBench %s - %s", SYSB_VER, s);
  1672.   WinSetWindowText(hwndFrame, tmp);
  1673.   }
  1674.  
  1675. static void UpdateWindow(HPS hpsPaint, PRECTL pRect, s32 scrollValue)
  1676.   {
  1677.   static char tmp[256];
  1678.   s32 i, comp;
  1679.   s32 line = 0;
  1680.  
  1681.   // print header
  1682.  
  1683.   line++;
  1684.   //  line++;
  1685.  
  1686.   for (comp = 0; comp < NUM_COMPONENTS; comp++)
  1687.      {
  1688.      // print title
  1689.      Print(line,
  1690.           1,
  1691.           data.c[comp].title,
  1692.           pRect,
  1693.           scrollValue,
  1694.           hpsPaint,
  1695.           CLR_GREEN);
  1696.  
  1697.      line++;
  1698.      // print lines of data
  1699.      for (i = 0; i < data.c[comp].ndatalines; i++)
  1700.         {
  1701.         if (data.c[comp].datalines[i].value < 0.0)
  1702.            sprintf(tmp, "%-21s :       --.---    %s",
  1703.                   data.c[comp].datalines[i].entry,
  1704.                   data.c[comp].datalines[i].unit);
  1705.         else
  1706.            sprintf(tmp, "%-21s : %12.3f    %s",
  1707.                   data.c[comp].datalines[i].entry,
  1708.                   data.c[comp].datalines[i].value / data.c[comp].datalines[i].unit_val,
  1709.                   data.c[comp].datalines[i].unit);
  1710.         Print(line,
  1711.              3,
  1712.              tmp,
  1713.              pRect,
  1714.              scrollValue,
  1715.              hpsPaint,
  1716.              CLR_WHITE);
  1717.  
  1718.         line++;
  1719.         }
  1720.  
  1721.      Print(line,
  1722.           3,
  1723.           "────────────────────────────────────────────────────────────",
  1724.           pRect,
  1725.           scrollValue,
  1726.           hpsPaint,
  1727.           CLR_PALEGRAY);
  1728.  
  1729.      line++;
  1730.      if (data.c[comp].total < 0.0)
  1731.         sprintf(tmp, "Total                 :       --.---    %s",
  1732.                data.c[comp].unit_total);
  1733.      else
  1734.         sprintf(tmp, "Total                 : %12.3f    %s",
  1735.                data.c[comp].total,
  1736.                data.c[comp].unit_total);
  1737.  
  1738.      Print(line,
  1739.           3,
  1740.           tmp,
  1741.           pRect,
  1742.           scrollValue,
  1743.           hpsPaint,
  1744.           CLR_YELLOW);
  1745.  
  1746.      line++;
  1747.      line++;
  1748.      }
  1749. }
  1750.  
  1751. static void Print(s32 row, s32 col, char* string, PRECTL pRect, s32 scrollValue, HPS hpsPaint, s32 color)
  1752.   {
  1753.   RECTL printRect;
  1754.  
  1755.   printRect.xLeft = col * fontW;
  1756.   printRect.xRight = pRect->xRight;
  1757.   printRect.yTop = pRect->yTop - row * fontH + scrollValue;
  1758.   printRect.yBottom = printRect.yTop - fontH;
  1759.  
  1760.   WinDrawText(hpsPaint,
  1761.              -1,
  1762.              (PCH)string,
  1763.              &printRect,
  1764.              color,
  1765.              CLR_BLACK,
  1766.              DT_TOP |
  1767.              DT_LEFT);
  1768.   }
  1769.  
  1770. static void PrintFile(s32 newlines, s32 col, char* string, FILE* fp)
  1771.   {
  1772.   s32 i;
  1773.   for (i = 0; i < col; i++)
  1774.       fprintf(fp, " ");
  1775.  
  1776.   fprintf(fp, "%s", string);
  1777.  
  1778.   for (i = 0; i < newlines; i++)
  1779.       fprintf(fp, "\n");
  1780.   }
  1781.  
  1782. void InfoBox(char* s)
  1783.   {
  1784.   WinMessageBox(HWND_DESKTOP,
  1785.                 hwndFrame,
  1786.                 s,
  1787.                 "Info",
  1788.                 WND_MESSAGEB,
  1789.                 MB_OK | MB_INFORMATION | MB_APPLMODAL | MB_MOVEABLE);
  1790.   }
  1791.  
  1792.  
  1793. void ErrorBox(char* s)
  1794.   {
  1795.   WinMessageBox(HWND_DESKTOP,
  1796.                 hwndFrame,
  1797.                 s,
  1798.                 "Error !",
  1799.                 WND_MESSAGEB,
  1800.                 MB_OK | MB_ERROR | MB_APPLMODAL | MB_MOVEABLE);
  1801.   }
  1802.  
  1803.  
  1804. void WarnBox(char* s)
  1805.   {
  1806.   WinMessageBox(HWND_DESKTOP,
  1807.                 hwndFrame,
  1808.                 s,
  1809.                 "Warning !",
  1810.                 WND_MESSAGEB,
  1811.                 MB_OK | MB_WARNING | MB_APPLMODAL | MB_MOVEABLE);
  1812.   }
  1813.  
  1814. void UpdateAll(void)
  1815.   {
  1816.   RECTL rclWindow, cliprect;
  1817.   HRGN  newHrgn, oldHrgn, dummy;
  1818.   s32 i, comp;
  1819.   bool calcav = true;
  1820.  
  1821.   // calculate averages
  1822.   for (comp = 0; comp < NUM_COMPONENTS; comp++)
  1823.      {
  1824.      calcav = true;
  1825.      for (i = 0; i < data.c[comp].ndatalines; i++)
  1826.         {
  1827.         calcav = calcav && (data.c[comp].datalines[i].value >= 0.0);
  1828.         }
  1829.      if (!calcav)
  1830.         continue;
  1831.      switch (comp)
  1832.         {
  1833.         case comp_gfx:
  1834.            data.c[comp_gfx].total = CalcGfxAv();
  1835.            break;
  1836.         case comp_cpuint:
  1837.            data.c[comp_cpuint].total = CalcCPUIntAv();
  1838.            break;
  1839.         case comp_cpufloat:
  1840.            data.c[comp_cpufloat].total = CalcCPUFloatAv();
  1841.            break;
  1842.         case comp_dive:
  1843.            data.c[comp_dive].total = CalcDIVEAv();
  1844.            break;
  1845.         case comp_disk:
  1846.            data.c[comp_disk].total = CalcDiskIOAv();
  1847.            break;
  1848.         case comp_file:
  1849.            data.c[comp_file].total = CalcFileIOAv();
  1850.            break;
  1851.         case comp_mem:
  1852.            data.c[comp_mem].total = CalcMemAv();
  1853.            break;
  1854.         }
  1855.      }
  1856.  
  1857.   // update screen
  1858.   WinQueryWindowRect ( hwndClient, &rclWindow ); // update whole window
  1859.   cliprect.xLeft = rclWindow.xLeft;
  1860.   cliprect.xRight = rclWindow.xRight+1;
  1861.   cliprect.yBottom = rclWindow.yBottom;
  1862.   cliprect.yTop = rclWindow.yTop+1;
  1863.   newHrgn = GpiCreateRegion(mainHps, 1, &cliprect);
  1864.   GpiSetClipRegion(mainHps, newHrgn, &oldHrgn);
  1865.   if (NULLHANDLE != oldHrgn)
  1866.      GpiDestroyRegion(mainHps, oldHrgn);
  1867.   UpdateWindow(mainHps, &rclWindow, scroll);
  1868.   oldscroll = scroll;
  1869.   }
  1870.  
  1871. static void SetMenuState(bool active)
  1872.   { // if active == true => all items enabled
  1873.     // otherw. all items but the about and close are disabled
  1874.   WinEnableMenuItem(hwndMenu, MI_PROJ_SAVE, active);
  1875.   WinEnableMenuItem(hwndMenu, MI_PROJ_ALL, active);
  1876.   WinEnableMenuItem(hwndMenu, MI_MENU_GFX, active);
  1877.   WinEnableMenuItem(hwndMenu, MI_MENU_CPUINT, active);
  1878.   WinEnableMenuItem(hwndMenu, MI_MENU_CPUFLOAT, active);
  1879.   WinEnableMenuItem(hwndMenu, MI_MENU_MEM, active);
  1880.   if (gtWarp)
  1881.      {
  1882.      WinEnableMenuItem(hwndMenu,
  1883.                       MI_MENU_DIVE,
  1884.                       active);
  1885.      }
  1886.   else
  1887.      {
  1888.      WinEnableMenuItem(hwndMenu,
  1889.                       MI_MENU_DIVE,
  1890.                       false);
  1891.      }
  1892.   if (data.nr_fixed_disks)
  1893.      WinEnableMenuItem(hwndMenu, MI_MENU_DISKIO, active);
  1894.   else
  1895.      WinEnableMenuItem(hwndMenu, MI_MENU_DISKIO, FALSE);
  1896.   if (!fileiodisabled)
  1897.      WinEnableMenuItem(hwndMenu, MI_MENU_FILEIO, active);
  1898. }
  1899.  
  1900.  
  1901. static void SaveResults(void)
  1902.   {
  1903.   FILE* fp;
  1904.   static char tmp[256];
  1905.   s32 i, comp;
  1906.   struct tm *newtime;
  1907.   time_t ltime;
  1908.  
  1909.   FILEDLG fild;            /* File dialog info structure           */
  1910.   char pszTitle[24] = "Save Results to file..."; /* Title of dialog              */
  1911.   HWND hwndDlg;            /* File dialog window */
  1912.  
  1913.   APIRET rc = 0UL, ret;
  1914.   double meg = MB;
  1915.   static DIVE_CAPS dc;
  1916.   float size;
  1917.   char  IDrive[2];
  1918.  
  1919.   memset(&fild, 0, sizeof(FILEDLG)); /* set fields in file dlg to zero */
  1920.  
  1921.   fild.cbSize   = sizeof(FILEDLG);       /* Size of structure        */
  1922.   fild.fl       = FDS_CENTER | FDS_SAVEAS_DIALOG | FDS_ENABLEFILELB      ;
  1923.                                     /* FDS_* flags              */
  1924.   fild.pszTitle = pszTitle;         /* Dialog title string         */
  1925.   if (pszFullFile[1] == ':')
  1926.      {
  1927.      fild.pszIDrive = (char*)&IDrive;
  1928.      IDrive[0] = pszFullFile[0];
  1929.      IDrive[1] = pszFullFile[1];
  1930.      IDrive[2] = 0;
  1931.      strcpy(fild.szFullFile, pszFullFile+2);  /* Initial path,file name, or file filter */
  1932.      }
  1933.   else
  1934.      {
  1935.      strcpy(fild.szFullFile, pszFullFile);  /* Initial path,file name, or file filter */
  1936.      }
  1937.  
  1938.   if (!AutoBench)
  1939.      {
  1940.      hwndDlg = WinFileDlg(HWND_DESKTOP, hwndClient, &fild);
  1941.  
  1942.      if (hwndDlg && (fild.lReturn == DID_OK))
  1943.         {
  1944.         fp = fopen(fild.szFullFile, "wb");
  1945.         }
  1946.      else
  1947.         {
  1948.         return;
  1949.         }
  1950.      }
  1951.   else
  1952.      {
  1953.      fp = fopen(pszFullFile, "wb");
  1954.      }
  1955.  
  1956.   if (!fp)
  1957.      {
  1958.      WarnBox("Cannot open output file");
  1959.      return;
  1960.      }
  1961.  
  1962.   time(<ime);
  1963.   newtime = localtime(<ime);
  1964.   fprintf(fp, "\n\nSysbench " SYSB_VER " result file created %s\n", asctime(newtime));
  1965.  
  1966.   fprintf(fp, "Machine name    - %s\n"
  1967.               "Manufacturer    - %s\n"
  1968.               "Motherboard     - %s\n"
  1969.               "Chipset         - %s\n"
  1970.               "Processor       - %s\n"
  1971.               "External cache  - %s\n"
  1972.               "Graphics card   - %s\n"
  1973.               "Disk Controller - %s\n\n",
  1974.               Machinename,
  1975.               MachineMake,
  1976.               Moboname,
  1977.               Chipset,
  1978.               Processor,
  1979.               CacheAmount,
  1980.               Graphicscard,
  1981.               DiskController);
  1982.  
  1983.   fprintf(fp, "Machine data\n"
  1984.               "Coprocessor     = %s\n"
  1985.               "RAM             = %3.2f MB\n"
  1986.               "Priority        = %s\n"
  1987.               "Maxwait         = %d\n"
  1988.               "Timeslice       = (%d,%d)\n",
  1989.                (coproc ? "Yes" : "No"),
  1990.                (double)(value[QSV_TOTPHYSMEM - QSV_BOOT_DRIVE]+(384*KB))/meg,
  1991.                (value[QSV_DYN_PRI_VARIATION - QSV_BOOT_DRIVE] ? "Dynamic" : "Absolute"),
  1992.                value[QSV_MAX_WAIT - QSV_BOOT_DRIVE],
  1993.                value[QSV_MIN_SLICE - QSV_BOOT_DRIVE],
  1994.                value[QSV_MAX_SLICE - QSV_BOOT_DRIVE]);
  1995.  
  1996.   size = GetSwapFileSize();
  1997.  
  1998.   if (size)
  1999.      {
  2000.      fprintf(fp, "Swap file size  = %4.2fMB\n"
  2001.                  "  ...initially  = %4.2fMB\n",
  2002.                  (float)size/MB,
  2003.                  (float)startsize/MB);
  2004.      }
  2005.   else
  2006.      {
  2007.      fprintf(fp, "Unable to determine current swapfile size\n"
  2008.                  "   ...initially = %4.2fMB\n",
  2009.                  (float)startsize/MB);
  2010.      }
  2011.  
  2012.    if (gtWarp)
  2013.      {
  2014.      memset(&dc, 0, sizeof(dc));
  2015.      dc.ulStructLen    = sizeof(dc);
  2016.      dc.ulFormatLength = 0;
  2017.      ret = DiveQueryCaps(&dc, DIVE_BUFFER_SCREEN);
  2018.      if (DIVE_SUCCESS != ret)
  2019.         {
  2020.         if (ret == DIVE_ERR_INSUFFICIENT_LENGTH)
  2021.            {
  2022.            dc.pFormatData = calloc(dc.ulFormatLength,1);
  2023.            ret = DiveQueryCaps(&dc, DIVE_BUFFER_SCREEN); // let's try again
  2024.            if (DIVE_SUCCESS != ret)
  2025.               {
  2026.               err("Error in call to DiveQueryCaps()");
  2027.               }
  2028.            }
  2029.         else
  2030.            {
  2031.            err("Error in call to DiveQueryCaps()");
  2032.            }
  2033.         }
  2034.  
  2035.      fprintf(fp, "\nVideo data\n"
  2036.                  "Resolution      = %dx%dx%d bits/pixel\n",
  2037.             dc.ulHorizontalResolution,
  2038.             dc.ulVerticalResolution,
  2039.             dc.ulDepth);
  2040.  
  2041.      fprintf(fp, "Number planes   = %d\n"
  2042.                  "Screen Access   = %s\n"
  2043.                  "Bank Switched   = %s\n"
  2044.                  "Bytes/scanline  = %d\n"
  2045.                  "Aperture size   = %d\n\n",
  2046.             dc.ulPlaneCount,
  2047.             (dc.fScreenDirect ? "Direct" : "Not Direct"),
  2048.             (dc.fBankSwitched ? "Yes" : "No"),
  2049.             dc.ulScanLineBytes,
  2050.             dc.ulApertureSize);
  2051.      }
  2052.   else
  2053.      {
  2054.      fprintf(fp, "Video data not listed because OS/2 release less than Warp\n");
  2055.      }
  2056.  
  2057.   for (comp = 0; comp < NUM_COMPONENTS; comp++)
  2058.      {
  2059.      // print title
  2060.      PrintFile(1, 1, data.c[comp].title, fp);
  2061.      // print lines of data
  2062.      for (i = 0; i < data.c[comp].ndatalines; i++)
  2063.         {
  2064.         if (data.c[comp].datalines[i].value < 0.0)
  2065.            sprintf(tmp, "%-21s :       --.---    %s",
  2066.                   data.c[comp].datalines[i].entry,
  2067.                   data.c[comp].datalines[i].unit);
  2068.         else
  2069.            sprintf(tmp, "%-21s : %12.3f    %s",
  2070.                   data.c[comp].datalines[i].entry,
  2071.                   data.c[comp].datalines[i].value / data.c[comp].datalines[i].unit_val,
  2072.                   data.c[comp].datalines[i].unit);
  2073.  
  2074.         PrintFile(1, 3, tmp, fp);
  2075.         }
  2076. //  PrintFile(1, 3, "────────────────────────────────────────────────────────────", fp);
  2077.      PrintFile(1, 3, "------------------------------------------------------------", fp);
  2078.      if (data.c[comp].total < 0.0)
  2079.         sprintf(tmp, "Total                 :       --.---    %s",
  2080.                 data.c[comp].unit_total);
  2081.      else
  2082.         sprintf(tmp, "Total                 : %12.3f    %s",
  2083.                data.c[comp].total,
  2084.                data.c[comp].unit_total);
  2085.      PrintFile(2, 3, tmp, fp);
  2086.      }
  2087.  
  2088.   fclose(fp);
  2089.  
  2090.   if (AutoBench)
  2091.      {
  2092.      WinPostMsg(hwndClient,
  2093.                WM_COMMAND,
  2094.                (MPARAM)MPFROMSHORT(MI_PROJ_QUIT),
  2095.                (MPARAM)MPFROM2SHORT(CMDSRC_MENU, TRUE));
  2096.      }
  2097. }
  2098.  
  2099. PSZ DoScanConfigSys(PSZ Keyword, int notstart)
  2100.   {
  2101.   char CSPath[_MAX_PATH];
  2102.   FILE *fp;
  2103.   static char Buffer[1025];
  2104.   char *p;
  2105.   char* n1;
  2106.   int notstop = 1;
  2107.  
  2108.   CSPath[0] = (char)(BootDriveLetter + 'A'- 1);
  2109.   CSPath[1] = 0;
  2110.   strcat(CSPath, ":\\CONFIG.SYS");
  2111.  
  2112.   fp = fopen(CSPath, "r");
  2113.   if (!fp)
  2114.      {
  2115.      return  0;
  2116.      }
  2117.  
  2118.   while(fgets(Buffer, sizeof(Buffer), fp) )
  2119.      {
  2120.      if (Buffer[strlen(Buffer)-1] == '\n')
  2121.         {
  2122.         Buffer[strlen(Buffer)-1] = 0;
  2123.         }
  2124.  
  2125.      p = strupr(Buffer);
  2126.      n1 = strstr((char*)p, (char*)Keyword);
  2127.  
  2128.      if (n1)
  2129.         {
  2130.         if (n1 == p)               /* if keyword at start of line */
  2131.            {
  2132.            n1 = strstr(n1, "=");
  2133.            n1 = n1+1;
  2134.            fclose (fp);
  2135.            return (PSZ)n1;
  2136.            }
  2137.         else
  2138.            {
  2139.            if (notstart)
  2140.               {
  2141.               fclose(fp);
  2142.               return (PSZ)n1;
  2143.               }
  2144.            }
  2145.         }
  2146.      }
  2147.   fclose (fp); /* close file at end */
  2148.   return 0;
  2149. }
  2150.  
  2151. void GetMachineInfo(void)
  2152. {
  2153. PSZ Swappath, charsp = "SWAPPATH";
  2154. PSZ diskcache, hpfscache;
  2155.  
  2156.   char* n1;
  2157.   DosDevConfig(&coproc,DEVINFO_COPROCESSOR);
  2158.  
  2159.   DosQuerySysInfo(QSV_BOOT_DRIVE,
  2160.                  QSV_TOTPHYSMEM,
  2161.                  (PVOID)value,
  2162.                  sizeof(ULONG)*QSV_MAX);
  2163.  
  2164.   BootDriveLetter = value[QSV_BOOT_DRIVE - QSV_BOOT_DRIVE];
  2165.  
  2166.   Swappath = DoScanConfigSys(charsp, false);
  2167.  
  2168.   pdisknum = Swappath[0] - 'A' +1;
  2169.  
  2170.   sscanf(Swappath, "%s %u %f", CSpath, &minfree, &startsize);
  2171.  
  2172.   if (CSpath[strlen(CSpath)-1] == '\\')  /* if last character of path \ */
  2173.      {
  2174.      CSpath[strlen(CSpath)-1] = 0;       /* back up a bit */
  2175.      }
  2176.  
  2177.   startsize = startsize * 1024;
  2178.  
  2179.   strcat(CSpath, "\\swapper.dat");
  2180.  
  2181.   diskcache = DoScanConfigSys("DISKCACHE", false);
  2182.  
  2183.   if (diskcache)
  2184.      {
  2185.      char cache[12], rest[100];
  2186.      sscanf(diskcache, "%[^, ]s %s", cache, rest);
  2187.      if (strcmp(strupr(cache), "D"))
  2188.         {
  2189.         fatcachesize = atoi(cache) * KB;          /* hard coded cache size */
  2190.         }
  2191.      else
  2192.         {
  2193.         fatcachesize = value[QSV_TOTPHYSMEM - QSV_BOOT_DRIVE] / 10;  /* cache size is 10% of RAM */
  2194.         if (fatcachesize > (14400 * KB))
  2195.            {
  2196.            fatcachesize = 14400 * KB;
  2197.            }
  2198.         if (value[QSV_TOTPHYSMEM - QSV_BOOT_DRIVE] >= ((6 * MB) +1) &&
  2199.             value[QSV_TOTPHYSMEM - QSV_BOOT_DRIVE] <= (8 * MB))
  2200.            {
  2201.            fatcachesize = 512 * KB;
  2202.            }
  2203.         if (value[QSV_TOTPHYSMEM - QSV_BOOT_DRIVE] >= ((5 * MB) +1) &&
  2204.             value[QSV_TOTPHYSMEM - QSV_BOOT_DRIVE] <= (6 * MB))
  2205.            {
  2206.            fatcachesize = 128 * KB;
  2207.            }
  2208.         if (value[QSV_TOTPHYSMEM - QSV_BOOT_DRIVE] <= (5 * MB))
  2209.            {
  2210.            fatcachesize = 64 * KB;
  2211.            }
  2212.         }
  2213.      }
  2214.   else
  2215.      {
  2216.      fatcachesize = 0;
  2217.      }
  2218.  
  2219.   hpfscache = DoScanConfigSys("HPFS.IFS", true);
  2220.  
  2221.   if (hpfscache)
  2222.      {
  2223.      n1 = strstr((char*)hpfscache, "/CACHE");
  2224.      if (!n1)
  2225.         {
  2226.         n1 = strstr((char*)hpfscache, "/C:");
  2227.         }
  2228.  
  2229.      if (n1)
  2230.         {
  2231.         char cache[12], rest[100];
  2232.         n1 = strstr(n1, ":");
  2233.         n1 = n1+1;
  2234.         sscanf(n1, "%s %s", cache, rest);
  2235.         hpfscachesize = atoi(cache) * KB;
  2236.         }
  2237.      else
  2238.         {
  2239.         hpfscachesize = value[QSV_TOTPHYSMEM - QSV_BOOT_DRIVE] / 10;  /* cache size is 10% of RAM */
  2240.         if (hpfscachesize > (2048 * KB))
  2241.            {
  2242.            hpfscachesize = 2048 * KB;
  2243.            }
  2244.         }
  2245.      }
  2246.   else
  2247.      {
  2248.      hpfscachesize = 0;
  2249.      }
  2250. }
  2251.  
  2252.  
  2253. float GetSwapFileSize(void)
  2254. {
  2255. FILESTATUS3 pInfoBuf1;
  2256. if (!DosQueryPathInfo(CSpath,
  2257.                   FIL_STANDARD,
  2258.                   &pInfoBuf1,
  2259.                   sizeof(FILESTATUS3)))
  2260.      {
  2261.      return (float)pInfoBuf1.cbFile;
  2262.      }
  2263.   else
  2264.      {
  2265.      return 0;
  2266.      }
  2267. }
  2268.  
  2269.  
  2270. void _Optlink ShowWaitWindow(void* arg)
  2271. {
  2272.   HMQ         hmq = NULLHANDLE;
  2273.   HAB         hab = NULLHANDLE;      /* PM anchor block handle         */
  2274.   ERRORID erridErrorCode;
  2275.   APIRET      rc  = 0 ;
  2276.  
  2277.   hab = WinInitialize ( 0UL );
  2278.   if (hab == NULLHANDLE)
  2279.      {
  2280.      erridErrorCode = WinGetLastError(hab);
  2281.      printf("ShowWaitWindow WinInitialize returned %x\n", erridErrorCode);
  2282.      exit(2);
  2283.      }
  2284.   hmq = WinCreateMsgQueue ( hab, 0UL );
  2285.   if (hmq == NULLHANDLE)
  2286.      {
  2287.      erridErrorCode = WinGetLastError(hab);
  2288.      printf("ShowWaitWindow WinCreateMsgQueue returned %x\n", erridErrorCode);
  2289.      exit(2);
  2290.      }
  2291.  
  2292.   flashit = 1;
  2293.  
  2294.   rc = DosCreateEventSem(NULL,          /* Unnamed semaphore            */
  2295.                         &hevEvent3,     /* Handle of semaphore returned */
  2296.                         DC_SEM_SHARED,  /* Indicate a shared semaphore  */
  2297.                         FALSE);         /* Put in RESET state           */
  2298.  
  2299.   _beginthread(Flashlight, NULL, START_STACKSIZE, NULL); /* show Wait... window */
  2300.  
  2301.   hwndDlgB = WinLoadDlg(HWND_DESKTOP,
  2302.            HWND_DESKTOP,
  2303.            fnShowWait,
  2304.            NULLHANDLE,
  2305.            IDD_SHOWWAIT,
  2306.            NULL);
  2307.  
  2308.   rc = WinProcessDlg(hwndDlgB);
  2309.  
  2310.   flashit = 0;
  2311.  
  2312.   rc = DosWaitEventSem(hevEvent3, 60000);  /* wait for flashlight thread to end */
  2313.  
  2314.   rc = DosCloseEventSem(hevEvent3);
  2315.  
  2316.   WinDestroyMsgQueue ( hmq );
  2317.   WinTerminate ( hab );
  2318.   _endthread();
  2319. }
  2320.  
  2321.  
  2322. /* routine to handle messages from gathering info  box */
  2323. MRESULT APIENTRY fnShowWait (HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
  2324. {
  2325. int rc = 0;
  2326.  switch (msg)
  2327.     {
  2328.     case WM_INITDLG:
  2329.        rc = DosPostEventSem(hevEvent2);  /* say we're ready to take close msg */
  2330.        break;
  2331.  
  2332.     case WM_COMMAND:
  2333.        switch (COMMANDMSG(&msg)->cmd)
  2334.           {
  2335.           case IDD_SHOWWAIT5:
  2336.              rc = WinSetFocus(HWND_DESKTOP,    /* due to an apparent bug in OS/2 that means that
  2337.                                                   the WinProcessDlg that invokes this msg handling routine
  2338.                                                   never ends if it doesn't have the focus when the
  2339.                                                   WinDismissDlg() is issued, let's give it the focus */
  2340.                              hwndDlgB);
  2341.              rc = WinDismissDlg(hwndDlgB, 0UL);  /* dismiss the dialog */
  2342.              flashit = 0;
  2343.              return 0L;
  2344.           }
  2345.        break;
  2346.  
  2347.     default:
  2348.        break;
  2349.     }
  2350.  return (MRESULT)WinDefDlgProc (hwnd, msg, mp1, mp2);
  2351. }                                       /* end PromptWinProc     */
  2352.  
  2353.  
  2354. void _Optlink Flashlight(void* arg)
  2355. {
  2356.   HMQ         hmq = NULLHANDLE;
  2357.   HAB         hab = NULLHANDLE;      /* PM anchor block handle         */
  2358.   ERRORID erridErrorCode;
  2359.   BOOL i = 0;
  2360.  
  2361.   hab = WinInitialize ( 0UL );
  2362.   if (hab == NULLHANDLE)
  2363.      {
  2364.      erridErrorCode = WinGetLastError(hab);
  2365.      printf("Flashlight WinInitialize returned %x\n", erridErrorCode);
  2366.      exit(2);
  2367.      }
  2368.   hmq = WinCreateMsgQueue ( hab, 0UL );
  2369.   if (hmq == NULLHANDLE)
  2370.      {
  2371.      erridErrorCode = WinGetLastError(hab);
  2372.      printf("Flashlight WinCreateMsgQueue returned %x\n", erridErrorCode);
  2373.      exit(2);
  2374.      }
  2375.  
  2376.   while (flashit)
  2377.      {
  2378.      WinShowWindow(WinWindowFromID(hwndDlgB, IDD_SHOWICON2), /* toggle LED window visibility */
  2379.                   (i%2));
  2380.      i++;
  2381.      DosSleep(500);
  2382.      }
  2383.  
  2384.   DosPostEventSem(hevEvent3);    /* allow parent thread to end */
  2385.  
  2386.   WinDestroyMsgQueue ( hmq );
  2387.   WinTerminate ( hab );
  2388.   _endthread();
  2389. }
  2390.  
  2391.  
  2392. void _Optlink GetDriveInfo(void* arg)
  2393. {
  2394.   HWND        hwndPullDown;
  2395.   CHAR        tmp[256];
  2396.   APIRET      ulrc         = 0;
  2397.   BOOL        drivechecked = 0;
  2398.   int         i            = 0;
  2399.   MENUITEM    mi;
  2400.   ERRORID     erridErrorCode;
  2401.   HMQ         hmq          = NULLHANDLE;
  2402.   HAB         hab          = NULLHANDLE;      /* PM anchor block handle         */
  2403.  
  2404.   hab = WinInitialize ( 0UL );
  2405.   if (hab == NULLHANDLE)
  2406.      {
  2407.      erridErrorCode = WinGetLastError(hab);
  2408.      printf("GetDriveInfo WinInitialize returned %x\n", erridErrorCode);
  2409.      exit(2);
  2410.      }
  2411.   hmq = WinCreateMsgQueue ( hab, 0UL );
  2412.   if (hmq == NULLHANDLE)
  2413.      {
  2414.      erridErrorCode = WinGetLastError(hab);
  2415.      printf("GetDriveInfo WinCreateMsgQueue returned %x\n", erridErrorCode);
  2416.      exit(2);
  2417.      }
  2418.  
  2419.   for (i = 2; i <= 25; i++)   /* do from first possible HD upwards */
  2420.      {
  2421.      if ( ((ulDriveMap1 << (31-i)) >> 31) ) /* if bit in drive array is on */
  2422.         {
  2423.         typedef struct _FSINFOBUF
  2424.            {  ULONG        ulVolser;   /* Volume serial number */
  2425.            VOLUMELABEL  vol;        /* Volume label         */
  2426.            } FSINFOBUF;
  2427.         typedef FSINFOBUF *PFSINFOBUF;
  2428.         double drivesize = 300;
  2429.         char szDeviceName[3];
  2430.         FSINFOBUF VolumeInfo = {0};        /* File system info buffer */
  2431.         BYTE         fsqBuffer[sizeof(FSQBUFFER2) + (3 * CCHMAXPATH)] = {0};
  2432.         ULONG        cbBuffer   = sizeof(fsqBuffer);        /* Buffer length) */
  2433.         PFSQBUFFER2  pfsqBuffer = (PFSQBUFFER2) fsqBuffer;
  2434.         ULONG        ulOrdinal        = 0;     /* Ordinal of entry in name list      */
  2435.         PBYTE        pszFSDName       = NULL;  /* pointer to FS name                 */
  2436.         ULONG        aulFSInfoBuf[40] = {0};         /* File system info buffer     */
  2437.  
  2438.         ulrc = DosQueryFSInfo(i+1,
  2439.                              FSIL_VOLSER,      /* Request volume information */
  2440.                              &VolumeInfo,      /* Buffer for information     */
  2441.                              sizeof(FSINFOBUF));  /* Size of buffer          */
  2442.  
  2443.         if (ulrc != NO_ERROR)
  2444.            {
  2445.            if (ulrc == ERROR_BAD_NETPATH || ulrc == ERROR_NOT_READY || ulrc == ERROR_BAD_NET_NAME)
  2446.               {
  2447.               continue;
  2448.               }
  2449.            else
  2450.               {
  2451.               sprintf(tmp, "DosQueryFSInfo error: return code = %u\n", ulrc);
  2452.               logit(tmp);
  2453.               continue;
  2454.               }
  2455.            }
  2456.  
  2457.         szDeviceName[0] = 'A'+i;
  2458.         szDeviceName[1] = ':';
  2459.         szDeviceName[2] = (char)NULL;
  2460.  
  2461.         ulrc = DosQueryFSAttach(szDeviceName,   /* Logical drive of attached FS      */
  2462.                              ulOrdinal,       /* ignored for FSAIL_QUERYNAME       */
  2463.                              FSAIL_QUERYNAME, /* Return data for a Drive or Device */
  2464.                              pfsqBuffer,      /* returned data                     */
  2465.                              &cbBuffer);      /* returned data length              */
  2466.  
  2467.         if (ulrc != NO_ERROR)
  2468.            {
  2469.            sprintf(tmp, "DosQueryFSAttach error: return code = %u\n", ulrc);
  2470.            logit(tmp);
  2471.            return;
  2472.            }
  2473.         else
  2474.            {
  2475.            pszFSDName = (PBYTE)(pfsqBuffer->szName + pfsqBuffer->cbName + 1);
  2476.            }
  2477.  
  2478.         if (!strcmp(pszFSDName, "FAT"))
  2479.            {
  2480.            curdiskFAT = 1;
  2481.            }
  2482.         else
  2483.            {
  2484.            if (!strcmp(pszFSDName, "HPFS"))
  2485.               {
  2486.               curdiskFAT = 2;
  2487.               }
  2488.            else
  2489.               {
  2490.               curdiskFAT = 0; /*  if anything except FAT or HPFS */
  2491.               }
  2492.            }
  2493.  
  2494.         if (curdiskFAT)
  2495.            {
  2496.            ulrc = DosQueryFSInfo(i+1,            /* Drive number      */
  2497.                                 FSIL_ALLOC,             /* Level 1 allocation info */
  2498.                                 (PVOID)aulFSInfoBuf,    /* Buffer                  */
  2499.                                 sizeof(aulFSInfoBuf));  /* Size of buffer          */
  2500.  
  2501.            if (ulrc != NO_ERROR)
  2502.               {
  2503.               sprintf(tmp, "DosQueryFSInfo error: return code = %u\n", ulrc);
  2504.               logit(tmp);
  2505.               }
  2506.            else
  2507.               {
  2508.               drivesize = (aulFSInfoBuf[1] * aulFSInfoBuf[2] * (USHORT)aulFSInfoBuf[4])/(MB);
  2509.               /* (Sectors per allocation unit) * number of allocationunits * (Bytes per sector) */
  2510.               }
  2511.  
  2512.            if ((aulFSInfoBuf[1] * aulFSInfoBuf[3] * (USHORT)aulFSInfoBuf[4]) > (10 * MB)) /* if freespace > 10Mb */
  2513.               {
  2514.               char drive[3];
  2515.               drive[0] = 'A'+i;
  2516.               drive[1] = ':';
  2517.               drive[2] = 0;
  2518.               sprintf(tmp, "Drive % 4s % 7.0f MB", drive, drivesize);  /* print menu item inc. size */
  2519.               if (WinSendMsg(hwndMenu,
  2520.                             MM_QUERYITEM,
  2521.                             MPFROM2SHORT(MI_MENU_FILEIO_SELECT, TRUE),
  2522.                             (MPARAM)&mi))
  2523.                  {
  2524.                  hwndPullDown   = mi.hwndSubMenu;
  2525.                  mi.iPosition   = MIT_END;
  2526.                  mi.afStyle     = MIS_TEXT;
  2527.                  mi.afAttribute = (ULONG)NULL;
  2528.                  mi.id          = (ULONG)MI_MENU_FILEIO_SELECT+1+i;
  2529.                  mi.hwndSubMenu = (HWND)NULL;
  2530.                  mi.hItem       = (ULONG)NULL;
  2531.                  WinSendMsg(hwndPullDown,
  2532.                            MM_INSERTITEM,
  2533.                            (MPARAM)&mi,
  2534.                            (MPARAM)tmp);
  2535.                  if (i == ulDriveNum-1)
  2536.                     {
  2537.                     sprintf(tmp, "File I/O - cache read - Drive %c:", 'A'+ulDriveNum-1);
  2538.                     strcpy(data.c[comp_file].title, tmp);
  2539.                     drivechecked = 1;
  2540.                     WinCheckMenuItem(hwndMenu,
  2541.                                     MI_MENU_FILEIO_SELECT + ulDriveNum,
  2542.                                     true);
  2543.                     }
  2544.                  }
  2545.               else
  2546.                  {
  2547.                  erridErrorCode = WinGetLastError(hab);
  2548.                  }
  2549.               }
  2550.            }
  2551.         }
  2552.      }
  2553.  
  2554.   if (!drivechecked)      /* if current drive didn't have enough space */
  2555.      {
  2556.      SHORT sState;
  2557.      for (i = 3; i <= 26; i++)
  2558.         {
  2559.         sState = (SHORT)WinSendMsg(hwndMenu,
  2560.                                   MM_ISITEMVALID,
  2561.                                   MPFROM2SHORT(MI_MENU_FILEIO_SELECT + i, TRUE),
  2562.                                   MPFROMSHORT(0));
  2563.         if (sState)
  2564.            {
  2565.            ulDriveNum = i; /* set to first drive with enough space */
  2566.            sprintf(tmp, "File I/O - cache read - Drive %c:", 'A'+ulDriveNum-1);
  2567.            strcpy(data.c[comp_file].title, tmp);
  2568.            drivechecked = 1;
  2569.            WinCheckMenuItem(hwndMenu,
  2570.                            MI_MENU_FILEIO_SELECT + ulDriveNum,
  2571.                            true);
  2572.            DosSetDefaultDisk(ulDriveNum);
  2573.            break;         /* drop out of for (i = 3; i <= 26) */
  2574.            }
  2575.         }
  2576.      }
  2577.  
  2578.   if (!drivechecked) /* still ?! */
  2579.      {
  2580.      fileiodisabled = 1;
  2581.      }
  2582.  
  2583.   data.nr_fixed_disks = pmb_diskio_nrdisks();
  2584.   if (data.nr_fixed_disks > MAX_FIXED_DISKS)
  2585.      {
  2586.      logit("Number of fixed disks is too high");
  2587.      exit(1);
  2588.      }
  2589.  
  2590.   for (i = 0; i < data.nr_fixed_disks; i++)
  2591.      {
  2592.      data.fixed_disk_size[i] = pmb_diskio_disksize(i);
  2593.      sprintf(tmp, "Disk %d: %5.0f MB", i+1, data.fixed_disk_size[i]/(KB));
  2594.      if (WinSendMsg(hwndMenu,
  2595.                MM_QUERYITEM,
  2596.                MPFROM2SHORT(MI_MENU_DISKIO_SELECT, TRUE),
  2597.                (MPARAM)&mi))
  2598.         {
  2599.         hwndPullDown   = mi.hwndSubMenu;
  2600.         mi.iPosition   = MIT_END;
  2601.         mi.afStyle     = MIS_TEXT;
  2602.         mi.afAttribute = (ULONG)NULL;
  2603.         mi.id          = (ULONG)MI_MENU_DISKIO_SELECT+1+i;
  2604.         mi.hwndSubMenu = (HWND)NULL;
  2605.         mi.hItem       = (ULONG)NULL;
  2606.         WinSendMsg(hwndPullDown,
  2607.                   MM_INSERTITEM,
  2608.                   (MPARAM)&mi,
  2609.                   (MPARAM)tmp);
  2610.         }
  2611.      }
  2612.  
  2613.   if (!data.nr_fixed_disks)
  2614.      {
  2615.      WinSendMsg(hwndMenu,
  2616.                MM_QUERYITEM,
  2617.                MPFROM2SHORT(MI_MENU_DISKIO_SELECT, TRUE),
  2618.                (MPARAM) &mi);
  2619.  
  2620.     hwndPullDown   = mi.hwndSubMenu;
  2621.     mi.iPosition   = MIT_END;
  2622.     mi.afStyle     = MIS_TEXT;
  2623.     mi.afAttribute = 0;
  2624.     mi.id          = MI_MENU_DISKIO_SELECT+1;
  2625.     mi.hwndSubMenu = null;
  2626.     mi.hItem       = 0;
  2627.     WinSendMsg(hwndPullDown,
  2628.               MM_INSERTITEM,
  2629.               (MPARAM) &mi,
  2630.               (MPARAM)"No fixed disks found");
  2631.     }
  2632.  else
  2633.     {
  2634.     WinCheckMenuItem(hwndMenu,
  2635.                     MI_MENU_DISKIO_SELECT + 1,
  2636.                     true);
  2637.     data.selected_disk = 0;
  2638.     sprintf(data.c[comp_disk].title,
  2639.            "Disk I/O - disk %d: %5.0f MB",
  2640.            data.selected_disk+1,
  2641.            data.fixed_disk_size[data.selected_disk]/(KB));
  2642.     }
  2643. // DosSleep(30000);
  2644.  WinSendMsg(hwndClient,
  2645.            THR_DONE,
  2646.            (MPARAM)0,
  2647.            (MPARAM)0);
  2648.  
  2649.  WinSendMsg(hwndClient,
  2650.            THR_UPDATE,
  2651.            (MPARAM)0,
  2652.            (MPARAM)0);
  2653.  
  2654.  WinDestroyMsgQueue ( hmq );
  2655.  WinTerminate ( hab );
  2656.  
  2657.  _endthread();
  2658. }
  2659.  
  2660.  
  2661. void GetMachineStuff(HWND hwnd)
  2662. {
  2663.   HAB         hab = NULLHANDLE;      /* PM anchor block handle         */
  2664.   ERRORID erridErrorCode;
  2665.   APIRET      rc  = 0 ;
  2666.   HWND        hwndDlgM;
  2667.  
  2668.   hab = WinQueryAnchorBlock( hwnd );
  2669.   if (hab == NULLHANDLE)
  2670.      {
  2671.      erridErrorCode = WinGetLastError(hab);
  2672.      printf("GetMachineInfo WinQueryAnchorBlock returned %x\n", erridErrorCode);
  2673.      exit(2);
  2674.      }
  2675.  
  2676.   hwndDlgM = WinLoadDlg(HWND_DESKTOP,
  2677.            HWND_DESKTOP,
  2678.            fnMachineStuff,
  2679.            NULLHANDLE,
  2680.            IDD_MACHINE_DATA,
  2681.            NULL);
  2682.  
  2683.   rc = WinProcessDlg(hwndDlgM);
  2684. }
  2685.  
  2686.  
  2687. /* routine to handle messages from gathering info  box */
  2688. MRESULT APIENTRY fnMachineStuff (HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
  2689. {
  2690. int rc = 0;
  2691. HAB hab = WinQueryAnchorBlock(hwnd);
  2692.  
  2693.  switch (msg)
  2694.     {
  2695.     case WM_INITDLG:
  2696.        WinSendDlgItemMsg(hwnd, IDD_MACH_NAMED,
  2697.                         EM_SETTEXTLIMIT,
  2698.                         (MPARAM)99,
  2699.                         (MPARAM)0);
  2700.        WinSetWindowText(WinWindowFromID(hwnd, IDD_MACH_NAMED),
  2701.                        Machinename);
  2702.        WinSendDlgItemMsg(hwnd, IDD_MACH_MOBOD,
  2703.                         EM_SETTEXTLIMIT,
  2704.                         (MPARAM)99,
  2705.                         (MPARAM)0);
  2706.        WinSetWindowText(WinWindowFromID(hwnd, IDD_MACH_MOBOD),
  2707.                        Moboname);
  2708.        WinSendDlgItemMsg(hwnd, IDD_MACH_CHIPD,
  2709.                         EM_SETTEXTLIMIT,
  2710.                         (MPARAM)99,
  2711.                         (MPARAM)0);
  2712.        WinSetWindowText(WinWindowFromID(hwnd, IDD_MACH_CHIPD),
  2713.                        Chipset);
  2714.        WinSendDlgItemMsg(hwnd, IDD_MACH_MAKED,
  2715.                         EM_SETTEXTLIMIT,
  2716.                         (MPARAM)99,
  2717.                         (MPARAM)0);
  2718.        WinSetWindowText(WinWindowFromID(hwnd, IDD_MACH_MAKED),
  2719.                        MachineMake);
  2720.        WinSendDlgItemMsg(hwnd, IDD_MACH_CACHD,
  2721.                         EM_SETTEXTLIMIT,
  2722.                         (MPARAM)99,
  2723.                         (MPARAM)0);
  2724.        WinSetWindowText(WinWindowFromID(hwnd, IDD_MACH_CACHD),
  2725.                        CacheAmount);
  2726.        WinSendDlgItemMsg(hwnd, IDD_MACH_PROCD,
  2727.                         EM_SETTEXTLIMIT,
  2728.                         (MPARAM)99,
  2729.                         (MPARAM)0);
  2730.        WinSetWindowText(WinWindowFromID(hwnd, IDD_MACH_PROCD),
  2731.                        Processor);
  2732.        WinSendDlgItemMsg(hwnd, IDD_MACH_GRAPD,
  2733.                         EM_SETTEXTLIMIT,
  2734.                         (MPARAM)99,
  2735.                         (MPARAM)0);
  2736.        WinSetWindowText(WinWindowFromID(hwnd, IDD_MACH_GRAPD),
  2737.                        Graphicscard);
  2738.        WinSendDlgItemMsg(hwnd, IDD_MACH_DISKD,
  2739.                         EM_SETTEXTLIMIT,
  2740.                         (MPARAM)99,
  2741.                         (MPARAM)0);
  2742.        WinSetWindowText(WinWindowFromID(hwnd, IDD_MACH_DISKD),
  2743.                        DiskController);
  2744.        break;
  2745.  
  2746.     case WM_CONTROL:
  2747.         {
  2748.         switch (SHORT1FROMMP(mp1))
  2749.            {
  2750.            case IDD_MACH_NAMED:                         /* if text box event */
  2751.               {
  2752.               if (SHORT2FROMMP(mp1) == EN_CHANGE)       /* if text has changed */
  2753.                  {
  2754.                  NamedC = 1;                            /* remember that */
  2755.                  }
  2756.               if (SHORT2FROMMP(mp1) == EN_SETFOCUS)     /* if focus given to this box */
  2757.                  {
  2758.                  WinSendMsg(WinWindowFromID(hwnd, IDD_MACH_NAMED), /* select text between... */
  2759.                             EM_SETSEL,
  2760.                             (MPARAM)MPFROM2SHORT(0,99), (MPARAM)0);      /* position 0 and 99 (all of it) */
  2761.                  }
  2762.               }
  2763.               break;
  2764.  
  2765.            case IDD_MACH_MOBOD:                         /* if text box event */
  2766.               {
  2767.               if (SHORT2FROMMP(mp1) == EN_CHANGE)       /* if text has changed */
  2768.                  {
  2769.                  MobodC = 1;                            /* remember that */
  2770.                  }
  2771.               if (SHORT2FROMMP(mp1) == EN_SETFOCUS)     /* if focus given to this box */
  2772.                  {
  2773.                  WinSendMsg(WinWindowFromID(hwnd, IDD_MACH_MOBOD), /* select text between... */
  2774.                             EM_SETSEL,
  2775.                             (MPARAM)MPFROM2SHORT(0,99), (MPARAM)0);      /* position 0 and 99 (all of it) */
  2776.                  }
  2777.               }
  2778.               break;
  2779.  
  2780.            case IDD_MACH_CHIPD:                         /* if text box event */
  2781.               {
  2782.               if (SHORT2FROMMP(mp1) == EN_CHANGE)       /* if text has changed */
  2783.                  {
  2784.                  ChipdC = 1;                            /* remember that */
  2785.                  }
  2786.               if (SHORT2FROMMP(mp1) == EN_SETFOCUS)     /* if focus given to this box */
  2787.                  {
  2788.                  WinSendMsg(WinWindowFromID(hwnd, IDD_MACH_CHIPD), /* select text between... */
  2789.                             EM_SETSEL,
  2790.                             (MPARAM)MPFROM2SHORT(0,99), (MPARAM)0);      /* position 0 and 99 (all of it) */
  2791.                  }
  2792.               }
  2793.               break;
  2794.  
  2795.            case IDD_MACH_MAKED:                         /* if text box event */
  2796.               {
  2797.               if (SHORT2FROMMP(mp1) == EN_CHANGE)       /* if text has changed */
  2798.                  {
  2799.                  MakedC = 1;                            /* remember that */
  2800.                  }
  2801.               if (SHORT2FROMMP(mp1) == EN_SETFOCUS)     /* if focus given to this box */
  2802.                  {
  2803.                  WinSendMsg(WinWindowFromID(hwnd, IDD_MACH_MAKED), /* select text between... */
  2804.                             EM_SETSEL,
  2805.                             (MPARAM)MPFROM2SHORT(0,99), (MPARAM)0);      /* position 0 and 99 (all of it) */
  2806.                  }
  2807.               }
  2808.               break;
  2809.  
  2810.            case IDD_MACH_CACHD:                         /* if text box event */
  2811.               {
  2812.               if (SHORT2FROMMP(mp1) == EN_CHANGE)       /* if text has changed */
  2813.                  {
  2814.                  CachdC = 1;                            /* remember that */
  2815.                  }
  2816.               if (SHORT2FROMMP(mp1) == EN_SETFOCUS)     /* if focus given to this box */
  2817.                  {
  2818.                  WinSendMsg(WinWindowFromID(hwnd, IDD_MACH_CACHD), /* select text between... */
  2819.                             EM_SETSEL,
  2820.                             (MPARAM)MPFROM2SHORT(0,99), (MPARAM)0);      /* position 0 and 99 (all of it) */
  2821.                  }
  2822.               }
  2823.               break;
  2824.  
  2825.            case IDD_MACH_PROCD:                         /* if text box event */
  2826.               {
  2827.               if (SHORT2FROMMP(mp1) == EN_CHANGE)       /* if text has changed */
  2828.                  {
  2829.                  ProcdC = 1;                            /* remember that */
  2830.                  }
  2831.               if (SHORT2FROMMP(mp1) == EN_SETFOCUS)     /* if focus given to this box */
  2832.                  {
  2833.                  WinSendMsg(WinWindowFromID(hwnd, IDD_MACH_PROCD), /* select text between... */
  2834.                             EM_SETSEL,
  2835.                             (MPARAM)MPFROM2SHORT(0,99), (MPARAM)0);      /* position 0 and 99 (all of it) */
  2836.                  }
  2837.               }
  2838.               break;
  2839.  
  2840.            case IDD_MACH_GRAPD:                         /* if text box event */
  2841.               {
  2842.               if (SHORT2FROMMP(mp1) == EN_CHANGE)       /* if text has changed */
  2843.                  {
  2844.                  GrapdC = 1;                            /* remember that */
  2845.                  }
  2846.               if (SHORT2FROMMP(mp1) == EN_SETFOCUS)     /* if focus given to this box */
  2847.                  {
  2848.                  WinSendMsg(WinWindowFromID(hwnd, IDD_MACH_GRAPD), /* select text between... */
  2849.                             EM_SETSEL,
  2850.                             (MPARAM)MPFROM2SHORT(0,99), (MPARAM)0);      /* position 0 and 99 (all of it) */
  2851.                  }
  2852.               }
  2853.               break;
  2854.  
  2855.            case IDD_MACH_DISKD:                         /* if text box event */
  2856.               {
  2857.               if (SHORT2FROMMP(mp1) == EN_CHANGE)       /* if text has changed */
  2858.                  {
  2859.                  DiskdC = 1;                            /* remember that */
  2860.                  }
  2861.               if (SHORT2FROMMP(mp1) == EN_SETFOCUS)     /* if focus given to this box */
  2862.                  {
  2863.                  WinSendMsg(WinWindowFromID(hwnd, IDD_MACH_DISKD), /* select text between... */
  2864.                             EM_SETSEL,
  2865.                             (MPARAM)MPFROM2SHORT(0,99), (MPARAM)0);      /* position 0 and 99 (all of it) */
  2866.                  }
  2867.               }
  2868.               break;
  2869.            }
  2870.         }
  2871.  
  2872.     case WM_COMMAND:
  2873.        switch (COMMANDMSG(&msg)->cmd)
  2874.           {
  2875.           case IDD_DID_OK:
  2876.              {
  2877.              if (NamedC)                      /* if contents of text window changed */
  2878.                 {
  2879.                 WinQueryWindowText(           /* get text from display window */
  2880.                                   WinWindowFromID(hwnd, IDD_MACH_NAMED),
  2881.                                   sizeof(Machinename),
  2882.                                   Machinename);
  2883.                  }
  2884.  
  2885.              if (MobodC)                      /* if contents of text window changed */
  2886.                 {
  2887.                 WinQueryWindowText(           /* get text from display window */
  2888.                                   WinWindowFromID(hwnd, IDD_MACH_MOBOD),
  2889.                                   sizeof(Moboname),
  2890.                                   Moboname);
  2891.                  }
  2892.  
  2893.              if (ChipdC)                      /* if contents of text window changed */
  2894.                 {
  2895.                 WinQueryWindowText(           /* get text from display window */
  2896.                                   WinWindowFromID(hwnd, IDD_MACH_CHIPD),
  2897.                                   sizeof(Chipset),
  2898.                                   Chipset);
  2899.                  }
  2900.  
  2901.              if (MakedC)                      /* if contents of text window changed */
  2902.                 {
  2903.                 WinQueryWindowText(           /* get text from display window */
  2904.                                   WinWindowFromID(hwnd, IDD_MACH_MAKED),
  2905.                                   sizeof(MachineMake),
  2906.                                   MachineMake);
  2907.                  }
  2908.  
  2909.              if (CachdC)                      /* if contents of text window changed */
  2910.                 {
  2911.                 WinQueryWindowText(           /* get text from display window */
  2912.                                   WinWindowFromID(hwnd, IDD_MACH_CACHD),
  2913.                                   sizeof(CacheAmount),
  2914.                                   CacheAmount);
  2915.                  }
  2916.  
  2917.              if (ProcdC)                      /* if contents of text window changed */
  2918.                 {
  2919.                 WinQueryWindowText(           /* get text from display window */
  2920.                                   WinWindowFromID(hwnd, IDD_MACH_PROCD),
  2921.                                   sizeof(Processor),
  2922.                                   Processor);
  2923.                  }
  2924.  
  2925.              if (GrapdC)                      /* if contents of text window changed */
  2926.                 {
  2927.                 WinQueryWindowText(           /* get text from display window */
  2928.                                   WinWindowFromID(hwnd, IDD_MACH_GRAPD),
  2929.                                   sizeof(Graphicscard),
  2930.                                   Graphicscard);
  2931.                  }
  2932.  
  2933.              if (DiskdC)                      /* if contents of text window changed */
  2934.                 {
  2935.                 WinQueryWindowText(           /* get text from display window */
  2936.                                   WinWindowFromID(hwnd, IDD_MACH_DISKD),
  2937.                                   sizeof(DiskController),
  2938.                                   DiskController);
  2939.                  }
  2940.              hini = PrfOpenProfile(hab, szIniFileName); /* open our profile file */
  2941.              PrfWriteProfileData(hini,
  2942.                                 pszApp,
  2943.                                 pszKeyName,
  2944.                                 &Machinename,
  2945.                                 sizeof(Machinename));
  2946.              PrfWriteProfileData(hini,
  2947.                                 pszApp,
  2948.                                 pszKeyMobo,
  2949.                                 &Moboname,
  2950.                                 sizeof(Moboname));
  2951.              PrfWriteProfileData(hini,
  2952.                                 pszApp,
  2953.                                 pszKeyProcessor,
  2954.                                 &Processor,
  2955.                                 sizeof(Processor));
  2956.              PrfWriteProfileData(hini,
  2957.                                 pszApp,
  2958.                                 pszKeyMake,
  2959.                                 &MachineMake,
  2960.                                 sizeof(MachineMake));
  2961.              PrfWriteProfileData(hini,
  2962.                                 pszApp,
  2963.                                 pszKeyCache,
  2964.                                 &CacheAmount,
  2965.                                 sizeof(CacheAmount));
  2966.              PrfWriteProfileData(hini,
  2967.                                 pszApp,
  2968.                                 pszKeyChipset,
  2969.                                 &Chipset,
  2970.                                 sizeof(Chipset));
  2971.              PrfWriteProfileData(hini,
  2972.                                 pszApp,
  2973.                                 pszKeyGraphics,
  2974.                                 &Graphicscard,
  2975.                                 sizeof(Graphicscard));
  2976.              PrfWriteProfileData(hini,
  2977.                                 pszApp,
  2978.                                 pszKeyDisk,
  2979.                                 &DiskController,
  2980.                                 sizeof(DiskController));
  2981.              PrfCloseProfile(hini);
  2982.  
  2983.              rc = WinDismissDlg(hwnd, 0UL);  /* dismiss the dialog */
  2984.              return 0L;
  2985.              }
  2986.              break;
  2987.  
  2988.           case IDD_DID_CANCEL:
  2989.              rc = WinDismissDlg(hwnd, 0UL);  /* dismiss the dialog */
  2990.              return 0L;
  2991.           }
  2992.        break;
  2993.  
  2994.     default:
  2995.        break;
  2996.     }
  2997.  return (MRESULT)WinDefDlgProc (hwnd, msg, mp1, mp2);
  2998. }                                       /* end PromptWinProc     */
  2999.  
  3000.  
  3001.