home *** CD-ROM | disk | FTP | other *** search
/ ProfitPress Mega CDROM2 …eeware (MSDOS)(1992)(Eng) / ProfitPress-MegaCDROM2.B6I / MISC / OS2 / PMVIEW3.ZIP / PMVIEW.C next >
Encoding:
C/C++ Source or Header  |  1990-09-10  |  88.0 KB  |  2,481 lines
  1. //UTILITIES
  2. //DOUGLAS BOLING
  3. //PMVIEW.C
  4.  
  5. //=============================================================================
  6. // PMVIEW.C -- A file browse program for the OS/2 Presentation Manager.
  7. //
  8. // Copyright (c) 1990 Ziff Communications
  9. //
  10. // Written by Douglas Boling
  11. // Modified by K. L. Singer as follows:
  12. //  1. Fixed bug when displaying ASCII bytes > 7F in Hex display.
  13. //  2. Corrected to display found search string as top line of Hex display.
  14. //  3. Added Hex string search option.
  15. //  4. Corrected inability to scroll past 64K using vertical scroll slider.
  16. //  5. Corrected random posiition in top line when using vert. scroll slider.
  17. //  6. Added Hex offset and Line No. options in Search Goto command.
  18. //  7. Corrected expanding of Tabs.
  19. //  8. Corrected Hex display when jumping to/near end of file.
  20. //  9. Modified End key to go to start of last line (ASCII)/16-byte para (Hex).
  21. // 10. Corrected repeating lines of text between last CR and last byte of file.
  22. // 11. Corrected to prevent scrolling of Hex display beyond end of file.
  23. // 12. Added Hex-EBCDIC display option.
  24. // 13. Corrected to ensure vertical scroll slider visibility in Hex display.
  25. // 14. Corrected problem introduced by item 5.
  26. // 15. Modified Open File Dialog to put name of viewed file at top of list box.
  27. // 16. Corrected incorrect file name displayed in "Unable to open file" msg.
  28. // 17. Added file name filter retention between Open File dialogs.
  29. // 18. Added "New" item on File sub-menu to close file and leave PMVIEW active.
  30. // 19. Changed shortcut key for Exit to Alt-X (from Alt-E) to conform to CUA.
  31. //=============================================================================
  32.  
  33. #define  INCL_WIN
  34. #define  INCL_VIO
  35. #define  INCL_AVIO
  36. #define  INCL_WINERRORS
  37.  
  38. #define  AVIOROWS 98
  39. #define  AVIOCOLS 255
  40. #define  PATHLENGTH 255
  41. #define  BUFFERSIZE 16384
  42.  
  43. #include <os2.h>
  44. #include <stdio.h>
  45. #include <string.h>
  46. #include <stdlib.h>
  47.  
  48. #include "pmview.h"
  49.  
  50. MRESULT  EXPENTRY ClientWndProc (HWND, USHORT, MPARAM, MPARAM);
  51. MRESULT  EXPENTRY AboutDlgProc (HWND, USHORT, MPARAM, MPARAM);
  52. MRESULT  EXPENTRY FileDlgProc (HWND, USHORT, MPARAM, MPARAM);
  53. MRESULT  EXPENTRY ConfigDlgProc (HWND, USHORT, MPARAM, MPARAM);
  54. MRESULT  EXPENTRY GotoDlgProc (HWND, USHORT, MPARAM, MPARAM);
  55. MRESULT  EXPENTRY SearchDlgProc (HWND, USHORT, MPARAM, MPARAM);
  56. MRESULT  EXPENTRY FontDlgProc (HWND, USHORT, MPARAM, MPARAM);
  57.  
  58. BOOL OpenFile (PCHAR);
  59. PCHAR GetFileDataPtr (LONG lFilePtr, BOOL fForward, USHORT *usLimit,
  60.                       BOOL *fEndOfFile);
  61. LONG MoveViewPtr (LONG lFilePtr, LONG *ptrRow, BOOL fDispASCII);
  62. SHORT ComputeLines (LONG lOldPtr, LONG lNewPtr, BOOL fDispASCII);
  63. VOID btoa (UCHAR cNum, UCHAR szOut[], BOOL fBlank);
  64. VOID Myltoa (ULONG lNum, UCHAR szOut[]);
  65. SHORT atob (UCHAR szHStr[], UCHAR szStr[]);
  66. SHORT DisplayLine (HVPS hvps, SHORT sRow, LONG lLinePtr, BOOL fDispASCII);
  67. BOOL SearchFile (LONG *lFilePtr);
  68. VOID ScrollVis (HWND hwndFrame, HWND hwndHScroll, HWND hwndVScroll,
  69.                 HWND hwndMenu);
  70. VOID SetASCII (HWND hwndMenu, LONG *lViewPtr);
  71. VOID SetFontSize (HWND hwndMenu, HVPS hvps, SHORT *psCharWidth,
  72.                   SHORT *psCharHeight);
  73. VOID FillDriveListBox (HWND hwnd, CHAR *pcCurrentPath);
  74. VOID FillDirListBox (HWND hwnd, CHAR *pcCurPath, BOOL fIncHidden);
  75. VOID FillFileListBox (HWND hwnd, CHAR *pcSearchParam, BOOL fIncHidden);
  76. VOID FillColorBox (HWND hwnd, SHORT iListID);
  77. VOID FillCellSizeBox (HWND hwnd, SHORT iListID);
  78. SHORT GetCellSize (SHORT sHeight, SHORT sWidth);
  79.  
  80. struct VideoStruct {
  81.    USHORT   uslength;
  82.    USHORT   usAdapterType;
  83.    USHORT   usDisplayType;
  84. } VideoData = { 6, 0, 0};
  85.  
  86. struct ParamStruct {
  87.    CHAR     szAttribute[2];
  88.    SHORT    sxWinPos;
  89.    SHORT    syWinPos;
  90.    SHORT    sWinHeight;
  91.    SHORT    sWinWidth;
  92.    SHORT    sCellHeight;
  93.    SHORT    sCellWidth;
  94.    SHORT    sTabStop;
  95.    BOOL     fDispASCII;
  96.    BOOL     fScrollBars;
  97.    BOOL     fIncHiddenFiles;
  98.    BOOL     fDispEBCDIC;
  99. } Default = {{0x20,0xf0}, -1, 0, 0, 0, 17, 8, 8, TRUE, TRUE, FALSE, FALSE};
  100.  
  101. struct FileStruct {
  102.    CHAR     szName [PATHLENGTH];
  103.    HFILE    hHandle;
  104.    LONG     lSize;
  105.    BOOL     fValid;
  106. } File = {"", 0, 0L, FALSE};
  107.  
  108. FILESTATUS FileInfo;
  109.  
  110. struct MemBuff {
  111.    USHORT   usBSel;
  112.    USHORT   usBOff;
  113.    USHORT   usDSize;
  114.    LONG     lFilePtr;
  115.    SHORT    sUseCnt;
  116.    BOOL     fValid;
  117. } Buff[4];
  118.  
  119. SHORT sCellSize [10][2] = {{8, 8}, {8, 12}, {8, 14}, {7, 15},
  120.       {7, 25}, {8, 17}, {12, 16}, {12, 20}, {12, 22}, {12, 30}};
  121.  
  122. HAB      hab;
  123.  
  124. CHAR     szNewFile[PATHLENGTH];
  125. LONG     lNewViewPtr;
  126.  
  127. CHAR     szSearchStr[80];
  128. CHAR     sSearchStr[80];
  129. CHAR     szSearchHStr[80];
  130. SHORT    cbSearchStrLen;
  131. BOOL     fCheckCase = FALSE;
  132. BOOL     fTopSearch = FALSE;
  133. BOOL     fHexString = FALSE;
  134. BOOL     fHexGoto = FALSE;
  135. BOOL     fLineGoto = FALSE;
  136. BOOL     fDecGoto = TRUE;
  137. LONG     lLastFound = -1;
  138.  
  139. BOOL     fSaveWinPos;
  140. BOOL     fSaveToDisk = FALSE;
  141. BOOL     fMinimized;
  142. CHAR     szAppName[] = "PMVIEW by Douglas Boling";
  143. CHAR     szKeyName[] = "Profile type 1";
  144.  
  145. CHAR     szStartTitleText[80];
  146.  
  147. //                          0/8  1/9  2/A  3/B  4/C  5/D  6/E  7/F
  148. UCHAR caEBtoASCII[256] = { 0x22,0x22,0x22,0x22,0x22,0x9E,0x22,0x22, //0
  149.                            0x22,0x22,0x22,0x22,0x22,0x22,0x22,0x22, //0
  150.                            0x22,0x22,0x22,0x22,0x22,0x22,0x22,0x22, //1
  151.                            0x22,0x22,0x22,0x22,0x22,0x22,0x22,0x22, //1
  152.                            0x22,0x22,0x22,0x22,0x22,0x22,0x22,0x22, //2
  153.                            0x22,0x22,0x22,0x22,0x22,0x22,0x22,0x22, //2
  154.                            0x22,0x22,0x22,0x22,0x22,0x22,0x22,0x22, //3
  155.                            0x22,0x22,0x22,0x22,0x22,0x22,0x22,0x22, //3
  156.                            0x20,0x5B,0x5D,0x9C,0x9D,0x9E,0x0F,0xE1, //4
  157.                            0x15,0xC4,0x9B,0x2E,0x3C,0x28,0x2B,0xB3, //4
  158.                            0x26,0xF8,0x20,0x5E,0x22,0x27,0x87,0x85, //5
  159.                            0x8A,0x8D,0x21,0x24,0x2A,0x29,0x2B,0xAA, //5
  160.                            0x2D,0x2F,0x95,0x97,0x61,0x6F,0x98,0x85, //6
  161.                            0x84,0x82,0x7C,0x2C,0x25,0x5F,0x3E,0x3F, //6
  162.                            0x8D,0x95,0x97,0x81,0x87,0x84,0x89,0x8B, //7
  163.                            0x94,0x60,0x3A,0x23,0x40,0x27,0x3D,0x22, //7
  164.                            0x81,0x61,0x62,0x63,0x64,0x65,0x66,0x67, //8
  165.                            0x68,0x69,0x83,0x88,0x8C,0x93,0x96,0xA0, //8
  166.                            0x82,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,0x70, //9
  167.                            0x71,0x72,0xA1,0xA2,0xA3,0xA4,0x41,0x45, //9
  168.                            0x49,0x7E,0x73,0x74,0x75,0x76,0x77,0x78, //A
  169.                            0x79,0x7A,0x4F,0x55,0x41,0x4F,0x59,0x4A, //A
  170.                            0x45,0x45,0x49,0x4F,0x55,0x59,0x53,0x8E, //B
  171.                            0x45,0x49,0x99,0x9A,0x41,0x45,0x49,0x4F, //B
  172.                            0x7B,0x41,0x42,0x43,0x44,0x45,0x46,0x47, //C
  173.                            0x48,0x49,0x55,0x41,0x90,0x49,0x20,0x20, //C
  174.                            0x7D,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,0x50, //D
  175.                            0x51,0x52,0x4F,0x55,0xA5,0x20,0x20,0x20, //D
  176.                            0x5C,0x91,0x53,0x54,0x55,0x56,0x57,0x58, //E
  177.                            0x59,0x5A,0xED,0x86,0x87,0x20,0x20,0x3B, //E
  178.                            0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37, //F
  179.                            0x38,0x39,0x91,0xED,0x8F,0x80,0x2A,0x20};//F
  180.  
  181. //=======================================================================
  182. // Main Proceedure.  Create message queue, parse the command line,
  183. //    allocate memory buffers, create the window, and process the
  184. //    message queue.
  185. //=======================================================================
  186. int main (int argc, char *argv[])
  187.    {
  188.    static   CHAR  szClientClass [] = "PMVIEW";
  189.  
  190.    static   ULONG flFrameFlags = FCF_TITLEBAR      | FCF_SYSMENU  |
  191.                                  FCF_SIZEBORDER    | FCF_MINMAX   |
  192.                                  FCF_TASKLIST      | FCF_ICON     |
  193.                                  FCF_MENU          | FCF_ACCELTABLE |
  194.                                  FCF_VERTSCROLL    | FCF_HORZSCROLL |
  195.                                  FCF_SHELLPOSITION;
  196.  
  197.    static   SHORT    fsWinPosFlags = SWP_SHOW;
  198.    static   USHORT   usSelector;
  199.    static   HWND     hwndFrame;
  200.    HMQ      hmq;
  201.    HWND     hwndClient;
  202.    QMSG     qmsg;
  203.    SHORT    i;
  204.  
  205.    if ( !(hab = WinInitialize (0)) )
  206.      exit((USHORT)ERRORIDERROR(WinGetLastError(hab)));
  207.  
  208.    if ( !(hmq = WinCreateMsgQueue (hab, 0)) )
  209.      exit((USHORT)ERRORIDERROR(WinGetLastError(hab)));
  210.  
  211.    for (i = 1; i < argc && i < 4; i++)
  212.       if (strcmp(argv[i],"\\i") == 0 || strcmp (argv[i],"-i") == 0) {
  213.          fMinimized = TRUE;
  214.          fsWinPosFlags |= SWP_MINIMIZE;
  215.       } else
  216.          if (strlen (szNewFile) == 0)
  217.             DosQPathInfo (argv[i], 5, szNewFile, sizeof szNewFile, 0L);
  218.  
  219.    DosAllocSeg( (USHORT) 0, &usSelector, 0 );
  220.    for (i = 0; i < 4; i++) {
  221.       Buff[i].usBSel = usSelector;
  222.       Buff[i].usBOff = i * BUFFERSIZE;
  223.       Buff[i].fValid = FALSE;
  224.    }
  225.    i = sizeof Default;
  226.    WinQueryProfileData (hab, szAppName, szKeyName, &Default, &i);
  227.  
  228.    WinRegisterClass (
  229.                hab,                 // Anchor block handle
  230.                szClientClass,       // Name of class being registered
  231.                ClientWndProc,       // Window procedure for class
  232.                CS_SIZEREDRAW,       // Class style
  233.                0);                  // Extra bytes to reserve
  234.  
  235.    hwndFrame = WinCreateStdWindow (
  236.                HWND_DESKTOP,        // Parent window handle
  237.                0L,                  // Style of frame window
  238.                &flFrameFlags,       // Pointer to control data
  239.                szClientClass,       // Client window class name
  240.                "",                  // Title bar text
  241.                0L,                  // Style of client window
  242.                NULL,                // Module handle for resources
  243.                ID_RESOURCE,         // ID of resources for window
  244.                &hwndClient);        // Pointer to client window handle
  245.  
  246.    if ((NULL == hwndFrame) || (NULL == hwndClient)) {
  247.       /* Make sure the window was created.      */
  248.       exit((USHORT)ERRORIDERROR(WinGetLastError(hab)));
  249.    } /* endif */
  250.  
  251.    if (Default.sxWinPos != -1)
  252.       fsWinPosFlags |= SWP_MOVE | SWP_SIZE;
  253.  
  254.    WinSetWindowPos (hwndFrame, HWND_TOP, Default.sxWinPos, Default.syWinPos,
  255.                      Default.sWinWidth, Default.sWinHeight, fsWinPosFlags);
  256.  
  257.    while (WinGetMsg (hab, &qmsg, NULL, 0, 0))
  258.       WinDispatchMsg (hab, &qmsg);
  259.  
  260.    if (File.hHandle)
  261.       DosClose (File.hHandle);
  262.    DosFreeSeg (usSelector);
  263.  
  264.    WinDestroyWindow (hwndFrame);
  265.  
  266.    WinDestroyMsgQueue (hmq);
  267.    WinTerminate (hab);
  268.    return 0;
  269. }
  270. //------------------------------------------------------------------
  271. // Open file.  Open the file, query file information, reset memory
  272. //     buffer structure.
  273. //------------------------------------------------------------------
  274. BOOL OpenFile (PCHAR szNewFileName) {
  275.  
  276.    SHORT       i;
  277.    HFILE       hNewHandle;
  278.    USHORT      usAction;
  279.    BOOL        fGoodRead = FALSE;
  280.  
  281.    if (DosOpen (
  282.         szNewFileName,                 // File name
  283.         &hNewHandle,                   // File handle
  284.         &usAction,                     // Action taken
  285.         0L,                            // File size
  286.         0,                             // File attribute
  287.         1,                             // Open type (Fail if no file.)
  288.         0x20,                          // Open mode (Read, deny write)
  289.         0L))                           // Reserved.
  290.       WinAlarm (HWND_DESKTOP, WA_NOTE);
  291.    else {
  292.       if (File.hHandle)
  293.          DosClose (File.hHandle);
  294.       strcpy (File.szName, szNewFileName);
  295.       File.hHandle = hNewHandle;
  296.       DosQFileInfo (File.hHandle, 1, (PBYTE) &FileInfo,
  297.                              sizeof FileInfo);
  298.       File.lSize = FileInfo.cbFile;
  299.       fGoodRead = TRUE;
  300.       //
  301.       // Reset the memory buffer to purge the old file data.
  302.       //
  303.       for (i = 0; i < 4; i++) {
  304.          Buff[i].lFilePtr = -1;
  305.          Buff[i].sUseCnt = 1;
  306.       }
  307.    }
  308.    return fGoodRead;
  309. }
  310. //------------------------------------------------------------------
  311. // GetFileDataPtr - Return a pointer to file data pointed to by
  312. //                  the file pointer.
  313. //------------------------------------------------------------------
  314. PCHAR GetFileDataPtr (LONG lFilePtr, BOOL fForward, USHORT *usLimit,
  315.                       BOOL *fEndOfFile) {
  316.    PCHAR    pcDataPtr;
  317.    ULONG    ulTemp;
  318.    SHORT    i, sLast = -1;
  319.    SHORT    sOldCnt, sNewCnt;
  320.    //
  321.    // Check limits of file.
  322.    //
  323.    *fEndOfFile = FALSE;
  324.    if (lFilePtr >= File.lSize) {
  325.       lFilePtr = File.lSize;
  326.       *fEndOfFile = fForward;
  327.    } else if (lFilePtr <= 0L) {
  328.       lFilePtr = 0L;
  329.       *fEndOfFile = !fForward;
  330.    }
  331.    //
  332.    // See if requested part of the file is in one of the buffers.
  333.    //
  334.    sOldCnt = sNewCnt = Buff[0].sUseCnt;
  335.    for (i = 0; i < 4; i++) {
  336.       sNewCnt = (sNewCnt < Buff[i].sUseCnt) ? Buff[i].sUseCnt : sNewCnt;
  337.       sOldCnt = (sOldCnt > Buff[i].sUseCnt) ? Buff[i].sUseCnt : sOldCnt;
  338.       if (Buff[i].lFilePtr != -1)
  339.          if (lFilePtr >= Buff[i].lFilePtr &&
  340.                     lFilePtr < Buff[i].lFilePtr + BUFFERSIZE)
  341.             sLast = i;
  342.    }
  343.    //
  344.    // If requested part not found, determine the oldest buffer to replace,
  345.    //     then read part of the file into that buffer.
  346.    //
  347.    if (sLast == -1) {
  348.       sOldCnt = Buff[0].sUseCnt;
  349.       for (i = 0; i < 4; i++)
  350.          if (sOldCnt >= Buff[i].sUseCnt) {
  351.             sOldCnt = Buff[i].sUseCnt;
  352.             sLast = i;
  353.          }
  354.       Buff[sLast].fValid = TRUE;
  355.       Buff[sLast].lFilePtr = (lFilePtr / BUFFERSIZE) * BUFFERSIZE;
  356.  
  357.       DosChgFilePtr (File.hHandle, Buff[sLast].lFilePtr, 0, &ulTemp);
  358.  
  359.       DosRead (File.hHandle, MAKEP (Buff[sLast].usBSel,
  360.                            Buff[sLast].usBOff), BUFFERSIZE,
  361.                            &Buff[sLast].usDSize);
  362.    }
  363.    //
  364.    // Reset LRU count to prevent overflow
  365.    //
  366.    if (sNewCnt > 0x7ff0) {
  367.       sNewCnt -= sOldCnt;
  368.       for (i = 0; i < 4; i++)
  369.          Buff[i].sUseCnt = Buff[i].sUseCnt - sOldCnt;
  370.    }
  371.    Buff[sLast].sUseCnt = ++sNewCnt;
  372.    //
  373.    // Create Pointer, set limits to buffer.
  374.    //
  375.    pcDataPtr = MAKEP (Buff[sLast].usBSel, Buff[sLast].usBOff
  376.                          + (USHORT) (lFilePtr - Buff[sLast].lFilePtr));
  377.    if (fForward)
  378.       *usLimit = Buff[sLast].usBOff + Buff[sLast].usDSize - 1;
  379.    else
  380.       *usLimit = Buff[sLast].usBOff;
  381.  
  382.    return pcDataPtr;
  383. }
  384. //------------------------------------------------------------------
  385. // MoveViewPtr - Update view pointer by scrolling the number of
  386. //     lines specified in ptrRow.  If limited by the top or bottom
  387. //     of the file, modify ptrRow to indicate the actual number of
  388. //      rows.
  389. //------------------------------------------------------------------
  390. LONG MoveViewPtr (LONG lFilePtr, LONG *ptrRow, BOOL fDispASCII) {
  391.    SHORT    j;
  392.    LONG     li;
  393.    LONG     lRow, lRowCount = 0L;
  394.    LONG     lOffset = 0L;
  395.    LONG     lOffsetLastCR = 0L;
  396.    USHORT   usLimit;
  397.    PCHAR    pcDataPtr;
  398.    BOOL     fEndOfFile;
  399.  
  400.    pcDataPtr = GetFileDataPtr (lFilePtr, *ptrRow > 0, &usLimit, &fEndOfFile);
  401.    lRow = *ptrRow;
  402.  
  403.    if (fDispASCII) {
  404.  
  405.       if (lRow > 0L) {
  406.          for (li=0; li < lRow && !fEndOfFile; li++, lOffset++){
  407.  
  408.             for (j=0; j < AVIOCOLS && *pcDataPtr != 0x0d
  409.                       && !fEndOfFile; j++, lOffset++)
  410.                if ((OFFSETOF(pcDataPtr) < usLimit))
  411.                   pcDataPtr++;
  412.                else {
  413.                   lFilePtr = ((lFilePtr + BUFFERSIZE)/ BUFFERSIZE) * BUFFERSIZE;
  414.                   pcDataPtr = GetFileDataPtr (lFilePtr, TRUE,
  415.                                               &usLimit, &fEndOfFile);
  416.                }
  417.             if ((OFFSETOF(pcDataPtr) < usLimit))
  418.                pcDataPtr++;
  419.             else {
  420.                lFilePtr = ((lFilePtr + BUFFERSIZE)/ BUFFERSIZE) * BUFFERSIZE;
  421.                pcDataPtr = GetFileDataPtr (lFilePtr, TRUE,
  422.                                            &usLimit, &fEndOfFile);
  423.             }
  424.             if (!fEndOfFile) {
  425.                lRowCount++;
  426.                lOffsetLastCR = lOffset + 1;
  427.             }
  428.          }
  429.          if (fEndOfFile) {
  430.             lOffset = lOffsetLastCR;
  431.          }
  432.          *ptrRow = lRowCount;
  433.       } else {
  434.          lRow = -lRow;
  435.          for (li=0; li < lRow && !fEndOfFile; li++){
  436.  
  437.             if ((OFFSETOF(pcDataPtr) > usLimit))
  438.                pcDataPtr--;
  439.             else {
  440.                lFilePtr = (lFilePtr / BUFFERSIZE) * BUFFERSIZE - 1;
  441.                pcDataPtr = GetFileDataPtr (lFilePtr, FALSE,
  442.                                            &usLimit, &fEndOfFile);
  443.             }
  444.             if (!fEndOfFile) {
  445.                lRowCount--;
  446.                lOffset--;
  447.             }
  448.             for (j=0; j < AVIOCOLS && !fEndOfFile; j++) {
  449.                if ((OFFSETOF(pcDataPtr) > usLimit)) {
  450.                   if (*(pcDataPtr-1) == 0x0d)
  451.                      break;
  452.                   pcDataPtr--;
  453.                } else {
  454.                   lFilePtr = (lFilePtr / BUFFERSIZE) * BUFFERSIZE - 1;
  455.                   pcDataPtr = GetFileDataPtr (lFilePtr, FALSE,
  456.                                               &usLimit, &fEndOfFile);
  457.                }
  458.                if (!fEndOfFile) {
  459.                   lOffset--;
  460.                }
  461.             }
  462.          }
  463.          *ptrRow = lRowCount;
  464.       }
  465.    }
  466.  
  467.    else {
  468.       //
  469.       // Align on paragraph
  470.       //
  471.       if (lFilePtr % 16 != 0)
  472.          lOffset -= (lFilePtr % 16);
  473.       lOffset += lRow * 16;
  474.       *ptrRow = lRow;
  475.       //
  476.       //Limit Checking
  477.       //
  478.       if ((lFilePtr == 0L && lRow < 0L)
  479.           ||(lFilePtr == File.lSize && lRow > 0L)){
  480.          lOffset = 0L;
  481.          *ptrRow = 0L;
  482.       } else if ((lFilePtr + lOffset) < 0) {
  483.         lOffset =  -lFilePtr;
  484.         *ptrRow = lOffset / 16L;
  485.       } else if ((lFilePtr + lOffset) >= File.lSize) {
  486.            if (lFilePtr % 16 == 0)
  487.              lOffset = (File.lSize - lFilePtr - 1L);
  488.            else
  489.              lOffset = (File.lSize - lFilePtr - 2L);
  490.         *ptrRow = lOffset / 16L;
  491.       }
  492.    }
  493.    return lOffset;
  494. }
  495. //------------------------------------------------------------------
  496. // ComputeLines - Compute number of lines between two points in
  497. //     the file.
  498. //------------------------------------------------------------------
  499. SHORT ComputeLines (LONG lOldPtr, LONG lNewPtr, BOOL fDispASCII) {
  500.    USHORT   usLimit;
  501.    SHORT    sCount = 0;
  502.    PCHAR    pcDataPtr;
  503.    BOOL     fEndOfFile = FALSE;
  504.  
  505.    pcDataPtr = GetFileDataPtr (lOldPtr, lOldPtr < lNewPtr, &usLimit,
  506.                                &fEndOfFile);
  507.    if (fDispASCII)
  508.       if (lOldPtr < lNewPtr) {
  509.          while (lOldPtr < lNewPtr && !fEndOfFile){
  510.             if (*pcDataPtr == 0x0d)
  511.                sCount++;
  512.             lOldPtr++;
  513.             if ((OFFSETOF(pcDataPtr) < usLimit))
  514.                pcDataPtr++;
  515.             else
  516.                pcDataPtr = GetFileDataPtr (lOldPtr, TRUE, &usLimit,
  517.                                            &fEndOfFile);
  518.          }
  519.       }
  520.       else {
  521.          while (lOldPtr > lNewPtr && !fEndOfFile) {
  522.             if (*pcDataPtr == 0x0d)
  523.                sCount--;
  524.             lOldPtr--;
  525.             if ((OFFSETOF(pcDataPtr) > usLimit))
  526.                pcDataPtr--;
  527.             else
  528.                pcDataPtr = GetFileDataPtr (lOldPtr, FALSE, &usLimit,
  529.                                            &fEndOfFile);
  530.          }
  531.       }
  532.    else
  533.       sCount = (SHORT) ((lNewPtr - lOldPtr) / 16);
  534.    return sCount;
  535. }
  536. //------------------------------------------------------------------
  537. // btoa Convert byte to ASCII
  538. //------------------------------------------------------------------
  539. VOID btoa (UCHAR cNum, UCHAR szOut[], BOOL fBlank) {
  540.    SHORT    i;
  541.  
  542.    for (i = 2; i > 0; i--)
  543.       if (fBlank)
  544.          szOut[i] = ' ';
  545.       else {
  546.          szOut[i] = (cNum % 16) + 0x30;
  547.          if (szOut[i] > 0x39) szOut[i] += (BYTE) 7;
  548.             cNum /= 16;
  549.       }
  550.    szOut[0] = ' ';
  551.    return;
  552. }
  553.  
  554. //------------------------------------------------------------------
  555. // Myltoa Convert a long to ASCII with leading zeros
  556. //------------------------------------------------------------------
  557. VOID Myltoa (ULONG lNum, UCHAR szOut[]) {
  558.    SHORT    i;
  559.  
  560.    for (i = 7; i >= 0; i--) {
  561.       szOut[i + (i+1)/5] = (BYTE) (lNum % 16) + 0x30;
  562.       if (szOut[i + (i+1)/5] > 0x39) szOut[i + (i+1)/5] += (BYTE) 7;
  563.       lNum /= 16;
  564.    }
  565.    szOut[4] = ' ';
  566.    return;
  567. }
  568.  
  569. //------------------------------------------------------------------
  570. // atob Convert ASCII Hex string to binary string
  571. //------------------------------------------------------------------
  572. SHORT atob (UCHAR szHStr[], UCHAR sStr[]) {
  573.    SHORT    inyble;
  574.    SHORT    ibyte;
  575.    SHORT    i;
  576.    SHORT    iDigit;
  577.  
  578.    ibyte = 0;
  579.  
  580.    if (strlen(szHStr) != 0) {
  581.      i = 0;
  582.      for (inyble = 0; inyble < strlen(szHStr); inyble++) {
  583.  
  584.        iDigit = (int) (toupper(szHStr[inyble]) - '0');
  585.        if (iDigit > 9)
  586.          iDigit = iDigit - 7;
  587.        if ((iDigit < 0) || (iDigit > 15)) {
  588.          if (i == 1) {
  589.            i = 0;
  590.            ibyte++;
  591.            }
  592.          continue;
  593.          }
  594.  
  595.        if (i == 0) {
  596.          sStr[ibyte] = (UCHAR) iDigit;
  597.          i = 1;
  598.          }
  599.        else {
  600.          sStr[ibyte] = (sStr[ibyte]*16) + iDigit;
  601.          i = 0;
  602.          ibyte++;
  603.          }
  604.        }
  605.      }
  606.    return ibyte;
  607. }
  608.  
  609. //------------------------------------------------------------------
  610. // Display Line
  611. //------------------------------------------------------------------
  612. SHORT DisplayLine (HVPS hvps, SHORT sRow, LONG lLinePtr, BOOL fDispASCII) {
  613.  
  614.    UCHAR    cHexChar, szTempBuff [256];
  615.    SHORT    i, sStart, sBytesPrinted = 0;
  616.    USHORT   usLimit;
  617.    BOOL     fEndOfFile;
  618.    PCHAR    pcDataPtr;
  619.  
  620.    if (fDispASCII) {
  621.       //
  622.       // Print as ASCII until CR or for 255 characters.
  623.       //
  624.       pcDataPtr = GetFileDataPtr (lLinePtr, TRUE, &usLimit, &fEndOfFile);
  625.  
  626.       for (i = 0; i <= AVIOCOLS && !fEndOfFile; i++){
  627.          if (*pcDataPtr == 0x0a) {
  628.             if ((OFFSETOF(pcDataPtr) < usLimit))
  629.                pcDataPtr++;
  630.             else {
  631.                lLinePtr = ((lLinePtr + BUFFERSIZE)/ BUFFERSIZE) * BUFFERSIZE;
  632.                pcDataPtr = GetFileDataPtr (lLinePtr, TRUE, &usLimit,
  633.                                            &fEndOfFile);
  634.             }
  635.             if (fEndOfFile)
  636.               szTempBuff[i] = ' ';
  637.             else
  638.               szTempBuff[i] = *pcDataPtr;
  639.             sBytesPrinted++;
  640.          } else
  641.             szTempBuff[i] = *pcDataPtr;
  642.  
  643.          if ((OFFSETOF(pcDataPtr) < usLimit))
  644.             pcDataPtr++;
  645.          else {
  646.             lLinePtr = ((lLinePtr + BUFFERSIZE)/ BUFFERSIZE) * BUFFERSIZE;
  647.             pcDataPtr = GetFileDataPtr (lLinePtr, TRUE, &usLimit,
  648.                                         &fEndOfFile);
  649.          }
  650.          sBytesPrinted++;
  651.          //
  652.          // Expand Tab Characters
  653.          //
  654.          if (szTempBuff[i] == 0x09) {
  655.             for (;(i+1) % Default.sTabStop != 0 && i <= AVIOCOLS; i++)
  656.                szTempBuff[i] = ' ';
  657.             szTempBuff[i] = ' ';
  658.          }
  659.          //
  660.          // If CR, end of line.
  661.          if (szTempBuff[i] == 0x0d) {
  662.             break;
  663.          }
  664.       }
  665.    } else {
  666.       //
  667.       // Convert from Hex and print.
  668.       //
  669.       pcDataPtr = GetFileDataPtr (lLinePtr, TRUE, &usLimit, &fEndOfFile);
  670.       sStart = (SHORT) (lLinePtr % 16L);
  671.       sBytesPrinted = 0;
  672.       for (i = 0; i < 10; i++)
  673.          szTempBuff[i] = ' ';
  674.  
  675.       if (!fEndOfFile)
  676.          Myltoa (lLinePtr, szTempBuff);
  677.  
  678.       for (i = 0; i < 16; i++){
  679.  
  680.          cHexChar = *pcDataPtr;
  681.  
  682.          btoa (cHexChar, szTempBuff + 10 + (i*3) + (i/8),
  683.                ((i < sStart) || fEndOfFile) );
  684.          if (Default.fDispEBCDIC)
  685.             szTempBuff[i+60+(i/8)] = ((i < sStart) || fEndOfFile) ?
  686.                                       (CHAR) 0x20 : caEBtoASCII[cHexChar];
  687.          else
  688.             szTempBuff[i+60+(i/8)] = ((i < sStart) || fEndOfFile) ? (CHAR) 0x20
  689.                                                                   : cHexChar;
  690.  
  691.  
  692.          if (i >= sStart){
  693.             if ((OFFSETOF(pcDataPtr) < usLimit))
  694.                pcDataPtr++;
  695.             else {
  696.                lLinePtr = ((lLinePtr + BUFFERSIZE)/ BUFFERSIZE) * BUFFERSIZE;
  697.                pcDataPtr = GetFileDataPtr (lLinePtr, TRUE, &usLimit,
  698.                                            &fEndOfFile);
  699.             }
  700.          }
  701.       }
  702.       szTempBuff[34] = ' ';
  703.       szTempBuff[59] = ' ';
  704.       szTempBuff[68] = ' ';
  705.       sBytesPrinted = i - sStart;
  706.       i += 59 + (i/8);
  707.    }
  708.    VioWrtCharStr (szTempBuff, i, sRow, 0, hvps);
  709.    return sBytesPrinted;
  710. }
  711. //------------------------------------------------------------------
  712. // SearchFile - Search the file for the value in szSearchStr or sSearchStr.
  713. //    If found, the file pointer is modified to the location in the
  714. //     file.
  715. //------------------------------------------------------------------
  716. BOOL SearchFile (LONG *lFilePtr) {
  717.    USHORT   usLimit;
  718.    PCHAR    pcDataPtr;
  719.    BOOL     fEndOfFile = FALSE, fFound = FALSE;
  720.    CHAR     szCmpBuffer[165];
  721.    SHORT    sBufferLength, sBufferCnt, sSearchLen, i;
  722.    LONG     lLocalPtr, lMarker;
  723.  
  724.  
  725.    if (fHexString)
  726.      sSearchLen = cbSearchStrLen;
  727.    else
  728.      sSearchLen = strlen (szSearchStr);
  729.  
  730.    lLocalPtr = (fTopSearch) ? 0L : *lFilePtr;
  731.  
  732.    pcDataPtr = GetFileDataPtr (lLocalPtr, TRUE, &usLimit, &fEndOfFile);
  733.  
  734.    while (!fEndOfFile && !fFound) {
  735.  
  736.       sBufferLength = (BUFFERSIZE - (SHORT)(lLocalPtr % BUFFERSIZE))
  737.                       - sSearchLen;
  738.       if (sBufferLength <= 0) {
  739.  
  740.          for (i = 0; i < BUFFERSIZE - (SHORT)(lLocalPtr % BUFFERSIZE); i++)
  741.             *(szCmpBuffer + i) = *(pcDataPtr + i);
  742.  
  743.          sBufferCnt = i;
  744.          lMarker = lLocalPtr;
  745.          lLocalPtr = ((lLocalPtr + BUFFERSIZE) / BUFFERSIZE) * BUFFERSIZE;
  746.  
  747.          pcDataPtr = GetFileDataPtr (lLocalPtr, TRUE, &usLimit,
  748.                                      &fEndOfFile);
  749.          if (fEndOfFile)
  750.             break;
  751.          for (i = 0; i < min (sSearchLen + 1,
  752.                               BUFFERSIZE - (usLimit % BUFFERSIZE)); i++)
  753.             *(szCmpBuffer + sBufferCnt + i) = *(pcDataPtr + i);
  754.  
  755.          for (i = 0; i < sBufferCnt; i++)
  756.             if (fHexString) {
  757.                if (memcmp (szCmpBuffer + i, sSearchStr, sSearchLen) == 0) {
  758.                   fFound = TRUE;
  759.                   break;
  760.                   }
  761.                }
  762.             else
  763.                if (fCheckCase) {
  764.                   if (strncmp (szCmpBuffer + i, szSearchStr, sSearchLen) == 0) {
  765.                      fFound = TRUE;
  766.                      break;
  767.                   }
  768.                } else {
  769.                   if (strnicmp (szCmpBuffer + i, szSearchStr, sSearchLen) == 0) {
  770.                      fFound = TRUE;
  771.                      break;
  772.                   }
  773.                }
  774.          sBufferLength = (BUFFERSIZE - (usLimit%BUFFERSIZE)) - sSearchLen;
  775.       }
  776.       if (fFound) {
  777.          lLocalPtr = lMarker + i;
  778.          break;
  779.       }
  780.       for (i = 0; i < sBufferLength; i++) {
  781.             if (fHexString) {
  782.                if (memcmp (pcDataPtr + i, sSearchStr, sSearchLen) == 0) {
  783.                   fFound = TRUE;
  784.                   break;
  785.                }
  786.             }
  787.          else
  788.             if (fCheckCase) {
  789.                if (strncmp (pcDataPtr + i, szSearchStr, sSearchLen) == 0) {
  790.                   fFound = TRUE;
  791.                   break;
  792.                }
  793.             } else {
  794.                if (strnicmp (pcDataPtr + i, szSearchStr, sSearchLen) == 0) {
  795.                   fFound = TRUE;
  796.                   break;
  797.                }
  798.             }
  799.       }
  800.       lLocalPtr += i;
  801.    }
  802.    if (fFound)
  803.       *lFilePtr = lLocalPtr;
  804.    return fFound;
  805. }
  806. //------------------------------------------------------------------
  807. // ScrollVis - Set Scroll Visibility
  808. //------------------------------------------------------------------
  809. VOID ScrollVis (HWND hwndFrame, HWND hwndHScroll, HWND hwndVScroll,
  810.                 HWND hwndMenu) {
  811.  
  812.    if (Default.fScrollBars) {
  813.  
  814.       WinSendMsg (hwndMenu, MM_SETITEMATTR,
  815.                   MPFROM2SHORT (IDM_DISPSCROLLBARS, TRUE),
  816.                   MPFROM2SHORT (MIA_CHECKED, MIA_CHECKED));
  817.  
  818.       WinSetParent (hwndVScroll, hwndFrame, FALSE );
  819.       WinSetParent (hwndHScroll, hwndFrame, FALSE );
  820.    } else {
  821.  
  822.       WinSendMsg (hwndMenu, MM_SETITEMATTR,
  823.                   MPFROM2SHORT (IDM_DISPSCROLLBARS, TRUE),
  824.                   MPFROM2SHORT (MIA_CHECKED, 0));
  825.  
  826.       WinSetParent (hwndVScroll, HWND_OBJECT, FALSE );
  827.       WinSetParent (hwndHScroll, HWND_OBJECT, FALSE );
  828.    }
  829.    WinSendMsg ( hwndFrame , WM_UPDATEFRAME ,
  830.    (MPARAM) (FCF_TITLEBAR | FCF_SYSMENU | FCF_MINMAX |
  831.    FCF_MENU), NULL);
  832.  
  833.    return;
  834. }
  835. //------------------------------------------------------------------
  836. // Set ASCII - Set ASCII Menu Check marks.
  837. //------------------------------------------------------------------
  838. VOID SetASCII (HWND hwndMenu, LONG *lViewPtr) {
  839.    LONG  lRow = -1;
  840.    if (Default.fDispASCII) {
  841.       if (!(MIA_CHECKED && WinSendMsg (hwndMenu, MM_QUERYITEMATTR,
  842.                                    MPFROM2SHORT (IDM_DISPLAYASCII, TRUE),
  843.                                    MPFROM2SHORT (MIA_CHECKED, 0)))) {
  844.          *lViewPtr += 2;
  845.          *lViewPtr += MoveViewPtr (*lViewPtr, &lRow, TRUE);
  846.       }
  847.       WinSendMsg (hwndMenu, MM_SETITEMATTR,
  848.                   MPFROM2SHORT (IDM_DISPLAYHEXASC, TRUE),
  849.                   MPFROM2SHORT (MIA_CHECKED, 0));
  850.  
  851.       WinSendMsg (hwndMenu, MM_SETITEMATTR,
  852.                   MPFROM2SHORT (IDM_DISPLAYHEXEBC, TRUE),
  853.                   MPFROM2SHORT (MIA_CHECKED, 0));
  854.  
  855.       WinSendMsg (hwndMenu, MM_SETITEMATTR,
  856.                   MPFROM2SHORT (IDM_DISPLAYASCII, TRUE),
  857.                   MPFROM2SHORT (MIA_CHECKED, MIA_CHECKED));
  858.    } else {
  859.       WinSendMsg (hwndMenu, MM_SETITEMATTR,
  860.                   MPFROM2SHORT (IDM_DISPLAYASCII, TRUE),
  861.                   MPFROM2SHORT (MIA_CHECKED, 0));
  862.  
  863.       if (Default.fDispEBCDIC) {
  864.          WinSendMsg (hwndMenu, MM_SETITEMATTR,
  865.                      MPFROM2SHORT (IDM_DISPLAYHEXASC, TRUE),
  866.                      MPFROM2SHORT (MIA_CHECKED, 0));
  867.  
  868.          WinSendMsg (hwndMenu, MM_SETITEMATTR,
  869.                      MPFROM2SHORT (IDM_DISPLAYHEXEBC, TRUE),
  870.                      MPFROM2SHORT (MIA_CHECKED, MIA_CHECKED));
  871.       } else {
  872.          WinSendMsg (hwndMenu, MM_SETITEMATTR,
  873.                      MPFROM2SHORT (IDM_DISPLAYHEXASC, TRUE),
  874.                      MPFROM2SHORT (MIA_CHECKED, MIA_CHECKED));
  875.  
  876.          WinSendMsg (hwndMenu, MM_SETITEMATTR,
  877.                      MPFROM2SHORT (IDM_DISPLAYHEXEBC, TRUE),
  878.                      MPFROM2SHORT (MIA_CHECKED, 0));
  879.       }
  880.    }
  881.    return;
  882. }
  883. //------------------------------------------------------------------
  884. // SetFontSize - Change font size and update menu if necessary.
  885. //------------------------------------------------------------------
  886. VOID SetFontSize (HWND hwndMenu, HVPS hvps, SHORT *psCharWidth,
  887.                   SHORT *psCharHeight) {
  888.    static   CHAR  szSmallPrompt[] = "~Small Font\tCtrl+S";
  889.    static   CHAR  szLargePrompt[] = "~Large Font\tCtrl+S";
  890.  
  891.    VioSetDeviceCellSize (Default.sCellHeight, Default.sCellWidth, hvps);
  892.    VioGetDeviceCellSize (psCharHeight, psCharWidth, hvps);
  893.  
  894.    switch (VideoData.usAdapterType) {
  895.       case 0:
  896.       case 1:                          //CGA, no other cell sizes.
  897.          WinSendMsg (hwndMenu, MM_SETITEMATTR,
  898.                      MPFROM2SHORT (IDM_FONTSIZE, 0),
  899.                      MPFROM2SHORT (MIA_DISABLED, MIA_CHECKED));
  900.          break;
  901.  
  902.       case 2:                          //EGA
  903.       case 3:                          //VGA
  904.       if (Default.sCellHeight == 8 && Default.sCellWidth == 8)
  905.          WinSendMsg (hwndMenu, MM_SETITEMTEXT,
  906.                      MPFROM2SHORT (IDM_FONTSIZE, 0),
  907.                      MPFROMP (szLargePrompt));
  908.       else
  909.          WinSendMsg (hwndMenu, MM_SETITEMTEXT,
  910.                      MPFROM2SHORT (IDM_FONTSIZE, 0),
  911.                      MPFROMP (szSmallPrompt));
  912.          break;
  913.  
  914.       case 7:                          //8514
  915.          break;
  916.       }
  917.    return;
  918. }
  919. //=======================================================================
  920. //
  921. // Client Window Procedure
  922. //
  923. //=======================================================================
  924. MRESULT EXPENTRY ClientWndProc (HWND hwnd, USHORT msg, MPARAM mp1, MPARAM mp2)
  925.    {
  926.    static   HWND  hwndFrame, hwndMenu, hwndVScroll, hwndHScroll;
  927.  
  928.    static   HVPS  hvps;
  929.    static   HPS   hps;
  930.  
  931.    static   LONG  lViewPtr;
  932.    static   BOOL  fGoMinimize;
  933.  
  934.    static   SHORT sHScroll, sVScrScale, sHPage = 20, sVPage = 20;
  935.    static   SHORT sCharHeight, sCharWidth, sxWinSize, syWinSize;
  936.    static   SHORT sRowsVisible = AVIOROWS;
  937.  
  938.    HDC      hdc;
  939.    SIZEL    sizl;
  940.    SHORT    sRow;
  941.    SHORT    sTempRow;
  942.    LONG     lRow;
  943.    SHORT    sTemp;
  944.    LONG     lDeltaRows;
  945.    LONG     lTemp;
  946.    SWP      swpWinPos;
  947.    PSWP     pswpWinPos;
  948.    CHAR     szTempBuffer[PATHLENGTH];
  949.  
  950.    switch (msg) {
  951.  
  952.       //--------------------------------------------------------------
  953.       // When the window is created, get and store the handles to
  954.       //   the scroll bars and menu, read the default parameters if
  955.       //   saved before, set the proper attributes for the menu
  956.       //   selections, and create a AVIO presentation space.
  957.       //--------------------------------------------------------------
  958.       case WM_CREATE:
  959.  
  960.          WinQueryWindowText (hwndFrame,
  961.                              sizeof szStartTitleText,
  962.                              szStartTitleText);
  963.          strcpy (szStartTitleText, "PM FIle View");
  964.  
  965.          //
  966.          // If no file specified and not starting as an icon, Query
  967.          // user for a file name.
  968.          //
  969.          if (!File.fValid) {
  970.             if (strlen (szNewFile) == 0) {
  971.                if (!fMinimized)
  972.                   if (WinDlgBox(HWND_DESKTOP, hwnd, FileDlgProc,
  973.                          NULL, IDD_OPEN, NULL))
  974.                      if (!(File.fValid = OpenFile (szNewFile)))
  975.                         WinMessageBox (HWND_DESKTOP, hwnd,
  976.                                        "Unable to open the file",
  977.                                        szNewFile, NULL, MB_OK | MB_ERROR);
  978.             } else
  979.                if (!(File.fValid = OpenFile (szNewFile)))
  980.                   WinMessageBox (HWND_DESKTOP, hwnd,
  981.                                  "Unable to open the file", szNewFile,
  982.                                  NULL, MB_OK | MB_ERROR);
  983.             if (File.fValid) {
  984.                if (sHScroll) {
  985.                   sHScroll = 0;
  986.                   VioSetOrg (0, sHScroll, hvps);
  987.                }
  988.                lViewPtr = 0;
  989.                sVScrScale  = (SHORT) ((File.lSize / 32768) + 1);
  990.             }
  991.          }
  992.          fMinimized = FALSE;
  993.          //
  994.          // Query the Frame for the necessary window handles.
  995.          //
  996.          hwndFrame = WinQueryWindow (hwnd, QW_PARENT,FALSE);
  997.          hwndMenu = WinWindowFromID (hwndFrame, FID_MENU);
  998.          hwndVScroll = WinWindowFromID (hwndFrame, FID_VERTSCROLL);
  999.          hwndHScroll = WinWindowFromID ( hwndFrame, FID_HORZSCROLL);
  1000.          //
  1001.          // Set menu attributes.
  1002.          //
  1003.          sVScrScale  = (SHORT) ((File.lSize / 32768) + 1);
  1004.          ScrollVis (hwndFrame, hwndHScroll, hwndVScroll, hwndMenu);
  1005.          SetASCII(hwndMenu, &lViewPtr);
  1006.          //
  1007.          // Establish AVIO presentation space.
  1008.          //
  1009.          hdc = WinOpenWindowDC (hwnd);
  1010.          sizl.cx = sizl.cy = 0;
  1011.          hps = GpiCreatePS (hab, hdc, &sizl, PU_PELS | GPIF_DEFAULT |
  1012.                             GPIT_MICRO | GPIA_ASSOC);
  1013.          VioCreatePS (&hvps, AVIOROWS, AVIOCOLS, 0, 1, NULL);
  1014.          VioAssociate (hdc, hvps);
  1015.          VioGetConfig (0, (PVOID) &VideoData, hvps);
  1016.  
  1017.          SetFontSize (hwndMenu, hvps, &sCharWidth, &sCharHeight);
  1018.          VioScrollUp (0, 0, -1, -1, -1, Default.szAttribute, hvps);
  1019.  
  1020.          if (strlen (File.szName) != 0)
  1021.             WinSetWindowText (hwndFrame, File.szName);
  1022.          return 0;
  1023.  
  1024.       //--------------------------------------------------------------
  1025.       // Intercept the close message to abort a file open dialog box
  1026.       //   when the program is closed from an icon.
  1027.       //--------------------------------------------------------------
  1028.       case WM_CLOSE:
  1029.  
  1030.             fMinimized = FALSE;
  1031.          break;
  1032.  
  1033.       //--------------------------------------------------------------
  1034.       // If the Window is being restored from an icon without a vaild
  1035.       //   file, prompt the user for a file using the file open dialog
  1036.       //   box.
  1037.       //--------------------------------------------------------------
  1038.       case WM_MINMAXFRAME:
  1039.  
  1040.          if (fMinimized)
  1041.             if (!File.fValid) {
  1042.                if (WinDlgBox(HWND_DESKTOP, hwnd, FileDlgProc, NULL,
  1043.                              IDD_OPEN, NULL)) {
  1044.                   if (!(File.fValid = OpenFile (szNewFile)))
  1045.                      WinMessageBox (HWND_DESKTOP, hwnd,
  1046.                                     "Unable to open the file",
  1047.                                     szNewFile, NULL, MB_OK | MB_ERROR);
  1048.                   else {
  1049.                      if (sHScroll) {
  1050.                         sHScroll = 0;
  1051.                         VioSetOrg (0, sHScroll, hvps);
  1052.                      }
  1053.                      lViewPtr = 0;
  1054.                      sVScrScale  = (SHORT) ((File.lSize / 32768) + 1);
  1055.                      WinSetWindowText (hwndFrame, File.szName);
  1056.                   }
  1057.                } else
  1058.                   fGoMinimize = TRUE;
  1059.             }
  1060.          //
  1061.          // Record the current state of the program.
  1062.          //
  1063.          pswpWinPos = PVOIDFROMMP (mp1);
  1064.          if (pswpWinPos->fs & SWP_MINIMIZE)
  1065.             fMinimized = TRUE;
  1066.          else
  1067.             fMinimized = FALSE;
  1068.          break;
  1069.  
  1070.       //--------------------------------------------------------------
  1071.       // When the GoMimize flag is set send the frame a minimize
  1072.       //   message.
  1073.       //--------------------------------------------------------------
  1074.       case WM_WINDOWPOSCHANGED:
  1075.  
  1076.             if (fGoMinimize) {
  1077.                fGoMinimize = FALSE;
  1078.                WinSetWindowPos (hwndFrame, HWND_BOTTOM, 0, 0, 0, 0,
  1079.                                  SWP_MINIMIZE);
  1080.             }
  1081.          break;
  1082.  
  1083.       //--------------------------------------------------------------
  1084.       // When the window is resized, record the new window size,
  1085.       //   update the horizontal position of the AVIO space and
  1086.       //   scroll bar, and notify the frame to modify its windows.
  1087.       //--------------------------------------------------------------
  1088.       case WM_SIZE:
  1089.  
  1090.          sxWinSize = SHORT1FROMMP(mp2);
  1091.          syWinSize = SHORT2FROMMP(mp2);
  1092.  
  1093.          if (sHScroll > AVIOCOLS - sxWinSize / sCharWidth) {
  1094.             sHScroll = min (max (0, sHScroll),
  1095.                              AVIOCOLS - sxWinSize / sCharWidth);
  1096.             VioSetOrg (0, sHScroll, hvps);
  1097.             WinInvalidateRect (hwnd, NULL, FALSE);
  1098.          }
  1099.          sHPage = max (sxWinSize / sCharWidth - 1, 0);
  1100.          sVPage = max (syWinSize / sCharHeight - 1, 0);
  1101.          sRowsVisible = min (syWinSize / sCharHeight + 1, AVIOROWS);
  1102.  
  1103.          WinSendMsg ( hwndFrame, WM_UPDATEFRAME, (MPARAM) (FCF_TITLEBAR
  1104.                       | FCF_SYSMENU | FCF_MINMAX | FCF_MENU), NULL);
  1105.  
  1106.          WinSendMsg (hwndHScroll, SBM_SETSCROLLBAR,
  1107.                      MPFROM2SHORT (sHScroll, 0),
  1108.                      MPFROM2SHORT (0, AVIOCOLS - sxWinSize / sCharWidth));
  1109.  
  1110.          WinSendMsg (hwndHScroll, SBM_SETTHUMBSIZE,
  1111.                      MPFROM2SHORT (sxWinSize / sCharWidth,
  1112.                      AVIOCOLS - sxWinSize / sCharWidth), NULL);
  1113.  
  1114.          WinSendMsg (hwndVScroll, SBM_SETSCROLLBAR,
  1115.                      MPFROM2SHORT ((SHORT)(lViewPtr/sVScrScale), 0),
  1116.                      MPFROM2SHORT (0, (SHORT)(File.lSize/sVScrScale)));
  1117.  
  1118.  
  1119.          if ( (SHORT)((syWinSize/sCharHeight) * 30) <
  1120.               (SHORT)(File.lSize/sVScrScale) )
  1121.             WinSendMsg (hwndVScroll, SBM_SETTHUMBSIZE,
  1122.                         MPFROM2SHORT( (syWinSize/sCharHeight) * 30,
  1123.                         (SHORT)(File.lSize/sVScrScale)),NULL);
  1124.          else
  1125.             WinSendMsg (hwndVScroll, SBM_SETTHUMBSIZE,
  1126.                         MPFROM2SHORT( (syWinSize/sCharHeight) * 16,
  1127.                         (SHORT)(File.lSize/sVScrScale)),NULL);
  1128.  
  1129.          return WinDefAVioWindowProc (hwnd, msg, mp1, mp2);
  1130.  
  1131.       //--------------------------------------------------------------
  1132.       // Repaint the complete AVIO space by first clearing the window
  1133.       //   then writing to the AVIO space.
  1134.       //--------------------------------------------------------------
  1135.       case WM_PAINT:
  1136.  
  1137.          WinBeginPaint (hwnd, hps, NULL);
  1138.          VioScrollUp (0, 0, -1, -1, -1, Default.szAttribute, hvps);
  1139.  
  1140.          lTemp = lViewPtr;
  1141.          for (sRow = 0; sRow < sRowsVisible; sRow++)
  1142.             lTemp += (LONG) DisplayLine (hvps, sRow, lTemp,
  1143.                                           Default.fDispASCII);
  1144.          WinEndPaint (hps);
  1145.  
  1146.          WinSendMsg (hwndVScroll, SBM_SETPOS,
  1147.                      MPFROM2SHORT ((SHORT)(lViewPtr/sVScrScale), 0),
  1148.                      NULL);
  1149.          return 0;
  1150.  
  1151.       //--------------------------------------------------------------
  1152.       // Process each menu selection according to function.
  1153.       //--------------------------------------------------------------
  1154.       case WM_COMMAND:
  1155.  
  1156.          switch (COMMANDMSG(&msg)->cmd) {
  1157.  
  1158.          case IDM_NEW:
  1159.  
  1160.             if (File.hHandle)
  1161.                DosClose (File.hHandle);
  1162.             VioScrollUp (0, 0, -1, -1, -1, Default.szAttribute, hvps);
  1163.  
  1164.             *File.szName = '\0';
  1165.             File.hHandle = NULL;
  1166.             File.lSize = 0L;
  1167.             File.fValid = FALSE;
  1168.             WinSetWindowText (hwndFrame, szStartTitleText);
  1169.  
  1170.             WinPostMsg (hwnd, WM_COMMAND,
  1171.                         MPFROM2SHORT (IDM_OPEN,0), 0L);
  1172.  
  1173.             return 0;
  1174.  
  1175.          case IDM_OPEN:
  1176.             if (WinDlgBox(HWND_DESKTOP, hwnd, FileDlgProc,
  1177.                       NULL, IDD_OPEN, NULL)) {
  1178.                if (File.fValid = OpenFile (szNewFile)) {
  1179.                   if (sHScroll) {
  1180.                      sHScroll = 0;
  1181.                      VioSetOrg (0, sHScroll, hvps);
  1182.                   }
  1183.                   lViewPtr = 0;
  1184.                   sVScrScale  = (SHORT) ((File.lSize / 32768) + 1);
  1185.  
  1186.                   WinSendMsg (hwndVScroll, SBM_SETSCROLLBAR,
  1187.                               MPFROM2SHORT (0, 0),
  1188.                               MPFROM2SHORT (0,
  1189.                                             (SHORT)(File.lSize/sVScrScale)));
  1190.                   if ( (SHORT)((syWinSize/sCharHeight) * 30) <
  1191.                        (SHORT)(File.lSize/sVScrScale) )
  1192.                      WinSendMsg (hwndVScroll, SBM_SETTHUMBSIZE,
  1193.                                  MPFROM2SHORT( (syWinSize/sCharHeight) * 30,
  1194.                                  (SHORT)(File.lSize/sVScrScale)),NULL);
  1195.                   else
  1196.                      WinSendMsg (hwndVScroll, SBM_SETTHUMBSIZE,
  1197.                                  MPFROM2SHORT( (syWinSize/sCharHeight) * 16,
  1198.                                  (SHORT)(File.lSize/sVScrScale)),NULL);
  1199.                   WinSetWindowText (hwndFrame, File.szName);
  1200.                   WinInvalidateRect (hwnd, NULL, FALSE);
  1201.                } else
  1202.                   WinMessageBox (HWND_DESKTOP, hwnd, "Unable to open the file",
  1203.                                  szNewFile, NULL, MB_OK | MB_ERROR);
  1204.             }
  1205.             return 0;
  1206.  
  1207.          case IDM_FIND:
  1208.             if (WinDlgBox(HWND_DESKTOP, hwnd, SearchDlgProc,
  1209.                       NULL, IDD_SEARCH, NULL)) {
  1210.                if (fHexString) {
  1211.                  if (strlen (szSearchHStr) != 0)
  1212.                     WinPostMsg (hwnd, WM_COMMAND,
  1213.                                 MPFROM2SHORT (IDM_REPFIND,0), mp2);
  1214.                  }
  1215.                else
  1216.                  if (strlen (szSearchStr) != 0)
  1217.                     WinPostMsg (hwnd, WM_COMMAND,
  1218.                                 MPFROM2SHORT (IDM_REPFIND,0), mp2);
  1219.                }
  1220.             return 0;
  1221.  
  1222.          case IDM_REPFIND:
  1223.             if ( ((fHexString) && (strlen (szSearchHStr) == 0)) ||
  1224.                  ((!fHexString) && (strlen (szSearchStr) == 0)) ) {
  1225.                WinPostMsg (hwnd, WM_COMMAND, MPFROM2SHORT (IDM_FIND,0),
  1226.                            mp2);
  1227.                return 0;
  1228.             } else {
  1229.                //
  1230.                //   Check to see if we are on the same line as the last
  1231.                // found string.  If so, start search at 1 byte past
  1232.                // last found string.
  1233.                //
  1234.                lDeltaRows = 1L;
  1235.                lTemp = MoveViewPtr (lViewPtr, &lDeltaRows,
  1236.                                            Default.fDispASCII);
  1237.                lTemp += lViewPtr;
  1238.  
  1239.                if (lTemp > lLastFound && lLastFound >= lViewPtr)
  1240.                   lLastFound++;
  1241.                else
  1242.                   lLastFound = lViewPtr;
  1243.                //
  1244.                //   If string found, back up to the start of the
  1245.                // current line.
  1246.                //
  1247.                WinQueryWindowText (hwndFrame, PATHLENGTH, szTempBuffer);
  1248.                WinSetWindowText (hwndFrame, "Searching");
  1249.                if (SearchFile (&lLastFound)) {
  1250.                   lViewPtr = lLastFound;
  1251.                   if (!Default.fDispASCII)
  1252.                      lDeltaRows = 0L;
  1253.                   else
  1254.                      lDeltaRows = -1L;
  1255.                   lViewPtr += MoveViewPtr (lViewPtr, &lDeltaRows,
  1256.                                            Default.fDispASCII);
  1257.                   WinInvalidateRect (hwnd, NULL, FALSE);
  1258.                   WinSetWindowText (hwndFrame, szTempBuffer);
  1259.                } else {
  1260.                   WinSetWindowText (hwndFrame, szTempBuffer);
  1261.                   if (fHexString)
  1262.                     WinMessageBox (HWND_DESKTOP, hwnd, szSearchHStr,
  1263.                                    "Unable to find the hex string",
  1264.                                    NULL, MB_OK | MB_ICONHAND);
  1265.                   else
  1266.                     WinMessageBox (HWND_DESKTOP, hwnd, szSearchStr,
  1267.                                    "Unable to find the string",
  1268.                                    NULL, MB_OK | MB_ICONHAND);
  1269.                }
  1270.             }
  1271.             return 0;
  1272.  
  1273.          case IDM_GOTO:
  1274.             if (WinDlgBox(HWND_DESKTOP, hwnd, GotoDlgProc,
  1275.                       NULL, IDD_GOTO, NULL)) {
  1276.                lViewPtr = min (max (lNewViewPtr, 0L), File.lSize);
  1277.                WinInvalidateRect (hwnd, NULL, FALSE);
  1278.             }
  1279.             return 0;
  1280.  
  1281.          case IDM_CONFIGURE:
  1282.             if (WinDlgBox(HWND_DESKTOP, hwnd, ConfigDlgProc,
  1283.                       NULL, IDD_CONFIGURE, NULL)) {
  1284.                if (fSaveToDisk) {
  1285.                   if (fSaveWinPos) {
  1286.                      WinQueryWindowPos (hwndFrame, &swpWinPos);
  1287.                      Default.sxWinPos = swpWinPos.x;
  1288.                      Default.syWinPos = swpWinPos.y;
  1289.                      Default.sWinWidth = swpWinPos.cx;
  1290.                      Default.sWinHeight = swpWinPos.cy;
  1291.                   }
  1292.                   WinWriteProfileData (hab, szAppName, szKeyName,
  1293.                                        &Default, sizeof Default);
  1294.                }
  1295.                SetASCII(hwndMenu, &lViewPtr);
  1296.                ScrollVis (hwndFrame, hwndHScroll, hwndVScroll, hwndMenu);
  1297.                SetFontSize (hwndMenu, hvps, &sCharWidth, &sCharHeight);
  1298.                sHPage = max (sxWinSize / sCharWidth - 1, 0);
  1299.                sVPage = max (syWinSize / sCharHeight - 1, 0);
  1300.                sRowsVisible = min (syWinSize / sCharHeight + 1, AVIOROWS);
  1301.                WinInvalidateRect (hwnd, NULL, FALSE);
  1302.             }
  1303.             return 0;
  1304.  
  1305.          case IDM_DISPLAYASCII:
  1306.             if (!Default.fDispASCII) {
  1307.                Default.fDispASCII = TRUE;
  1308.                SetASCII (hwndMenu, &lViewPtr);
  1309.                WinInvalidateRect (hwnd, NULL, FALSE);
  1310.             }
  1311.             return 0;
  1312.  
  1313.          case IDM_DISPLAYHEXASC:
  1314.             if ((Default.fDispASCII) || (Default.fDispEBCDIC)) {
  1315.                Default.fDispASCII = FALSE;
  1316.                Default.fDispEBCDIC = FALSE;
  1317.                SetASCII (hwndMenu, &lViewPtr);
  1318.                WinInvalidateRect (hwnd, NULL, FALSE);
  1319.             }
  1320.             return 0;
  1321.  
  1322.          case IDM_DISPLAYHEXEBC:
  1323.             if ((Default.fDispASCII) || (!Default.fDispEBCDIC)) {
  1324.                Default.fDispASCII = FALSE;
  1325.                Default.fDispEBCDIC = TRUE;
  1326.                SetASCII (hwndMenu, &lViewPtr);
  1327.                WinInvalidateRect (hwnd, NULL, FALSE);
  1328.             }
  1329.             return 0;
  1330.  
  1331.          case IDM_DISPSCROLLBARS:
  1332.             if (Default.fScrollBars)
  1333.                Default.fScrollBars = FALSE;
  1334.             else
  1335.                Default.fScrollBars = TRUE;
  1336.  
  1337.             ScrollVis (hwndFrame, hwndHScroll, hwndVScroll, hwndMenu);
  1338.             return 0;
  1339.  
  1340.          case IDM_FONTSIZE:
  1341.             switch (VideoData.usAdapterType) {
  1342.                case 2:                          //EGA
  1343.                   if (Default.sCellHeight == 8 && Default.sCellWidth == 8){
  1344.                      Default.sCellHeight = sCellSize[1][1];
  1345.                      Default.sCellWidth = sCellSize[1][0];
  1346.                   } else {
  1347.                      Default.sCellHeight = sCellSize[0][1];
  1348.                      Default.sCellWidth = sCellSize[0][0];
  1349.                   }
  1350.                   break;
  1351.  
  1352.                case 3:                          //VGA
  1353.                   if (Default.sCellHeight == 8 && Default.sCellWidth == 8){
  1354.                      Default.sCellHeight = sCellSize[2][1];
  1355.                      Default.sCellWidth = sCellSize[2][0];
  1356.                   } else {
  1357.                      Default.sCellHeight = sCellSize[0][1];
  1358.                      Default.sCellWidth = sCellSize[0][0];
  1359.                   }
  1360.                   break;
  1361.  
  1362.                case 7:                          //8514
  1363.                   if (!WinDlgBox(HWND_DESKTOP, hwnd, FontDlgProc,
  1364.                          NULL, IDD_PICKFONT, NULL))
  1365.                      return 0;
  1366.                   break;
  1367.             }
  1368.             SetFontSize (hwndMenu, hvps, &sCharWidth, &sCharHeight);
  1369.             sHPage = max (sxWinSize / sCharWidth - 1, 0);
  1370.             sVPage = max (syWinSize / sCharHeight - 1, 0);
  1371.             sRowsVisible = min (syWinSize / sCharHeight + 1, AVIOROWS);
  1372.             WinInvalidateRect (hwnd, NULL, FALSE);
  1373.             return 0;
  1374.  
  1375.          case IDM_ABOUT:
  1376.             WinDlgBox(HWND_DESKTOP, hwnd, AboutDlgProc,
  1377.                       NULL, IDD_ABOUT, NULL);
  1378.             return 0;
  1379.  
  1380.          case IDM_EXIT:
  1381.             WinSendMsg(hwnd, WM_CLOSE, 0L, 0L);
  1382.             return 0;
  1383.       }
  1384.       //--------------------------------------------------------------
  1385.       // Convert cursor keys to scroll bar messages.
  1386.       //--------------------------------------------------------------
  1387.       case WM_CHAR:
  1388.  
  1389.          switch (CHARMSG (&msg) -> vkey) {
  1390.  
  1391.             case VK_UP:
  1392.             case VK_DOWN:
  1393.             case VK_PAGEUP:
  1394.             case VK_PAGEDOWN:
  1395.                return WinSendMsg (hwndVScroll, msg, mp1, mp2);
  1396.  
  1397.             case VK_LEFT:
  1398.             case VK_RIGHT:
  1399.                return WinSendMsg (hwndHScroll, msg, mp1, mp2);
  1400.  
  1401.             case VK_HOME:
  1402.                if (lViewPtr != 0) {
  1403.                   lViewPtr = 0;
  1404.                   WinInvalidateRect (hwnd, NULL, FALSE);
  1405.                }
  1406.                break;
  1407.  
  1408.             case VK_END:
  1409.                if (lViewPtr != File.lSize - 1) {
  1410.                   lViewPtr = File.lSize - 1;
  1411.  
  1412.                   if (Default.fDispASCII)
  1413.                     lDeltaRows = -1L;
  1414.                   else
  1415.                     lDeltaRows = 0L;
  1416.                   lViewPtr += MoveViewPtr (lViewPtr, &lDeltaRows,
  1417.                                                      Default.fDispASCII);
  1418.  
  1419.                   WinInvalidateRect (hwnd, NULL, FALSE);
  1420.                }
  1421.                break;
  1422.          }
  1423.          return WinDefWindowProc (hwnd, msg, mp1, mp2);
  1424.  
  1425.       //-----------------------------------------------------------
  1426.       // Process Horizonal Scroll Bar Messages by scrolling across
  1427.       //    the AVIO space.
  1428.       //-----------------------------------------------------------
  1429.       case WM_HSCROLL:
  1430.  
  1431.          switch (SHORT2FROMMP (mp2)) {
  1432.  
  1433.             case SB_LINELEFT:
  1434.  
  1435.                sHScroll -= 1;
  1436.                break;
  1437.  
  1438.             case SB_PAGELEFT:
  1439.  
  1440.                sHScroll -= sHPage;
  1441.                break;
  1442.  
  1443.             case SB_LINERIGHT:
  1444.  
  1445.                sHScroll += 1;
  1446.                break;
  1447.  
  1448.             case SB_PAGERIGHT:
  1449.  
  1450.                sHScroll += sHPage;
  1451.                break;
  1452.  
  1453.             case SB_SLIDERTRACK:
  1454.  
  1455.                sHScroll = SHORT1FROMMP (mp2);
  1456.                break;
  1457.          }
  1458.          sHScroll = min (max (0, sHScroll),
  1459.                           AVIOCOLS - sxWinSize / sCharWidth);
  1460.  
  1461.          if (sHScroll != SHORT1FROMMR (WinSendMsg (hwndHScroll,
  1462.                                         SBM_QUERYPOS, NULL, NULL))) {
  1463.             VioSetOrg (0, sHScroll, hvps);
  1464.             WinSendMsg (hwndHScroll, SBM_SETPOS,
  1465.                         MPFROM2SHORT (sHScroll, 0), NULL);
  1466.          }
  1467.          return 0;
  1468.  
  1469.       //-----------------------------------------------------------
  1470.       // Process Vertical Scroll Bar Messages by scrolling the AVIO
  1471.       //    space and writing the new lines.
  1472.       //-----------------------------------------------------------
  1473.       case WM_VSCROLL:
  1474.  
  1475.          switch (SHORT2FROMMP (mp2)) {
  1476.  
  1477.             case SB_LINEUP:
  1478.  
  1479.                lDeltaRows = -1L;
  1480.                break;
  1481.  
  1482.             case SB_PAGEUP:
  1483.  
  1484.                lDeltaRows = (LONG) -sVPage;
  1485.                break;
  1486.  
  1487.             case SB_LINEDOWN:
  1488.  
  1489.                lDeltaRows = 1L;
  1490.                break;
  1491.  
  1492.             case SB_PAGEDOWN:
  1493.  
  1494.                lDeltaRows = (LONG) sVPage;
  1495.                break;
  1496.  
  1497.             case SB_SLIDERTRACK:
  1498.  
  1499.                lTemp = lViewPtr;
  1500.  
  1501.                lViewPtr = (LONG) ((LONG)SHORT1FROMMP(mp2) * (LONG)sVScrScale);
  1502.                if (Default.fDispASCII) {
  1503.                  lDeltaRows = -1L;
  1504.                  lViewPtr += MoveViewPtr (lViewPtr, &lDeltaRows, Default.fDispASCII);
  1505.                  if (lDeltaRows != 0) {
  1506.                     lDeltaRows = 1L;
  1507.                     lViewPtr += MoveViewPtr (lViewPtr, &lDeltaRows, Default.fDispASCII);
  1508.                  }
  1509.                }
  1510.                else {
  1511.                  lDeltaRows = 0L;
  1512.                  lViewPtr += MoveViewPtr (lViewPtr, &lDeltaRows, Default.fDispASCII);
  1513.                }
  1514.  
  1515.                sTemp = ComputeLines (lTemp, lViewPtr,
  1516.                                      Default.fDispASCII);
  1517.                sTemp = (sTemp > sRowsVisible) ? sRowsVisible : sTemp;
  1518.                sTemp = (sTemp < -sRowsVisible) ? -sRowsVisible : sTemp;
  1519.                lDeltaRows = (LONG) sTemp;
  1520.  
  1521.                break;
  1522.  
  1523.             default:
  1524.                return 0;
  1525.          }
  1526.          if (SHORT2FROMMP (mp2) != SB_SLIDERTRACK)
  1527.             lViewPtr += MoveViewPtr (lViewPtr, &lDeltaRows, Default.fDispASCII);
  1528.  
  1529.          WinSendMsg (hwndVScroll, SBM_SETPOS,
  1530.                      MPFROM2SHORT ((SHORT)(lViewPtr/sVScrScale), 0), NULL);
  1531.  
  1532.          if (lDeltaRows > 0L) {
  1533.             VioScrollUp (0, 0, sRowsVisible, AVIOCOLS, (SHORT) lDeltaRows,
  1534.                          Default.szAttribute, hvps);
  1535.  
  1536.             sRow = sRowsVisible-(SHORT)lDeltaRows;
  1537.             sTempRow = sRow;
  1538.  
  1539.             lTemp = lViewPtr;
  1540.             lRow = (LONG) sRow;
  1541.             lTemp += MoveViewPtr (lTemp, &lRow, Default.fDispASCII);
  1542.             sRow = (SHORT) lRow;
  1543.  
  1544.             if (sRow == sTempRow) {
  1545.                if (!Default.fDispASCII)
  1546.                   for (sRow = 0; sRow <= (SHORT)lDeltaRows; sRow++)
  1547.                      lTemp += DisplayLine (hvps,
  1548.                                            (sRowsVisible-(SHORT)lDeltaRows) + sRow,
  1549.                                            lTemp, Default.fDispASCII);
  1550.                else
  1551.                   for (sRow = 0; sRow < (SHORT)lDeltaRows; sRow++)
  1552.                      lTemp += DisplayLine (hvps,
  1553.                                            (sRowsVisible-(SHORT)lDeltaRows) + sRow,
  1554.                                            lTemp, Default.fDispASCII);
  1555.             }
  1556.          }
  1557.          if (lDeltaRows < 0L) {
  1558.             lDeltaRows = -lDeltaRows;
  1559.             VioScrollDn (0, 0, sRowsVisible, AVIOCOLS, (SHORT) lDeltaRows,
  1560.                          Default.szAttribute, hvps);
  1561.  
  1562.             lTemp = lViewPtr;
  1563.             for (sRow = 0; sRow <= (SHORT) lDeltaRows; sRow++)
  1564.                lTemp += DisplayLine (hvps, sRow, lTemp, Default.fDispASCII);
  1565.          }
  1566.          return 0;
  1567.  
  1568.       //-----------------------------------------------------------
  1569.       // Destroy the AVIO space nad the presentation space.
  1570.       //-----------------------------------------------------------
  1571.       case WM_DESTROY:
  1572.  
  1573.          VioAssociate (NULL, hvps);
  1574.          VioDestroyPS (hvps);
  1575.          GpiDestroyPS (hps);
  1576.          return 0;
  1577.    }
  1578.    return WinDefWindowProc (hwnd, msg, mp1, mp2);
  1579. }
  1580. //=====================================================================
  1581. // Dialog Procedures
  1582. //=====================================================================
  1583. //------------------------------------------------------------------
  1584. //  About Dialog Box
  1585. //------------------------------------------------------------------
  1586. MRESULT EXPENTRY AboutDlgProc (HWND hwnd, USHORT msg, MPARAM mp1, MPARAM mp2)
  1587.    {
  1588.    switch (msg) {
  1589.  
  1590.       case WM_COMMAND:
  1591.  
  1592.          switch (COMMANDMSG(&msg)->cmd) {
  1593.  
  1594.             case DID_OK:
  1595.             case DID_CANCEL:
  1596.                     WinDismissDlg (hwnd, TRUE);
  1597.                     return 0;
  1598.          }
  1599.    }
  1600.    return WinDefDlgProc (hwnd, msg, mp1, mp2);
  1601. }
  1602. //------------------------------------------------------------------
  1603. //  Goto Dialog Box
  1604. //------------------------------------------------------------------
  1605. MRESULT EXPENTRY GotoDlgProc (HWND hwnd, USHORT msg, MPARAM mp1, MPARAM mp2)
  1606.    {
  1607.    CHAR  szBuffer[12];
  1608.    LONG  lDeltaRows;
  1609.  
  1610.    switch (msg) {
  1611.  
  1612.       case WM_INITDLG:
  1613.  
  1614.          WinSendDlgItemMsg (hwnd, IDD_NEWOFFSET, EM_CLEAR, NULL, NULL);
  1615.  
  1616.          WinSendDlgItemMsg ( hwnd, IDD_NEWOFFSET, EM_SETTEXTLIMIT,
  1617.                              MPFROM2SHORT (11, 0), NULL);
  1618.  
  1619.          WinSendDlgItemMsg (hwnd, IDD_HEXGOTO, BM_SETCHECK,
  1620.                             MPFROM2SHORT (fHexGoto, 0), NULL);
  1621.          WinSendDlgItemMsg (hwnd, IDD_LINEGOTO, BM_SETCHECK,
  1622.                             MPFROM2SHORT (fLineGoto, 0), NULL);
  1623.          WinSendDlgItemMsg (hwnd, IDD_DECGOTO, BM_SETCHECK,
  1624.                             MPFROM2SHORT (fDecGoto, 0), NULL);
  1625.          return 0;
  1626.  
  1627.  
  1628.       case WM_CONTROL:
  1629.  
  1630.          switch (SHORT1FROMMP (mp1)) {
  1631.  
  1632.             case IDD_HEXGOTO:
  1633.                switch (SHORT2FROMMP (mp1)) {
  1634.  
  1635.                   case BN_CLICKED:
  1636.                      fDecGoto = FALSE;
  1637.                      fLineGoto = FALSE;
  1638.                      fHexGoto = TRUE;
  1639.                      return 0;
  1640.                }
  1641.                break;
  1642.  
  1643.             case IDD_DECGOTO:
  1644.                switch (SHORT2FROMMP (mp1)) {
  1645.  
  1646.                   case BN_CLICKED:
  1647.                      fDecGoto = TRUE;
  1648.                      fLineGoto = FALSE;
  1649.                      fHexGoto = FALSE;
  1650.                      return 0;
  1651.                }
  1652.                break;
  1653.  
  1654.             case IDD_LINEGOTO:
  1655.                switch (SHORT2FROMMP (mp1)) {
  1656.  
  1657.                   case BN_CLICKED:
  1658.                      fDecGoto = FALSE;
  1659.                      fLineGoto = TRUE;
  1660.                      fHexGoto = FALSE;
  1661.                      return 0;
  1662.                }
  1663.                break;
  1664.          }
  1665.          break;
  1666.  
  1667.  
  1668.       case WM_COMMAND:
  1669.  
  1670.          switch (COMMANDMSG(&msg)->cmd) {
  1671.  
  1672.             case DID_OK:
  1673.                if (WinQueryDlgItemText (hwnd, IDD_NEWOFFSET, sizeof szBuffer,
  1674.                     szBuffer)) {
  1675.                   if (fHexGoto)
  1676.                     lNewViewPtr = strtol(szBuffer, NULL, 16);
  1677.                   else {
  1678.                     if (fLineGoto) {
  1679.                       lDeltaRows = atol(szBuffer) - 1L;
  1680.                       lNewViewPtr = MoveViewPtr (0L, &lDeltaRows, TRUE);
  1681.                       }
  1682.                     else
  1683.                       lNewViewPtr = atol (szBuffer);
  1684.                     }
  1685.                   WinDismissDlg (hwnd, TRUE);
  1686.                   return 0;
  1687.                }
  1688.             case DID_CANCEL:
  1689.                WinDismissDlg (hwnd, FALSE);
  1690.                return 0;
  1691.          }
  1692.    }
  1693.    return WinDefDlgProc (hwnd, msg, mp1, mp2);
  1694. }
  1695. //=====================================================================
  1696. // Search Dialog Procedures
  1697. //=====================================================================
  1698. //------------------------------------------------------------------
  1699. //  Search Dialog Box
  1700. //------------------------------------------------------------------
  1701. MRESULT EXPENTRY SearchDlgProc (HWND hwnd, USHORT msg, MPARAM mp1, MPARAM mp2)
  1702.    {
  1703.    switch (msg) {
  1704.  
  1705.       case WM_INITDLG:
  1706.  
  1707.          if (fHexString)
  1708.            WinSetDlgItemText ( hwnd, IDD_SRCHSTR, szSearchHStr);
  1709.          else
  1710.            WinSetDlgItemText ( hwnd, IDD_SRCHSTR, szSearchStr);
  1711.  
  1712.          WinSendDlgItemMsg (hwnd, IDD_CHKCASE, BM_SETCHECK,
  1713.                             MPFROM2SHORT (fCheckCase, 0), NULL);
  1714.  
  1715.          WinSendDlgItemMsg (hwnd, IDD_TOPSEARCH, BM_SETCHECK,
  1716.                             MPFROM2SHORT (fTopSearch, 0), NULL);
  1717.  
  1718.          WinSendDlgItemMsg (hwnd, IDD_HEXSTRING, BM_SETCHECK,
  1719.                             MPFROM2SHORT (fHexString, 0), NULL);
  1720.          return 0;
  1721.  
  1722.       case WM_CONTROL:
  1723.  
  1724.          switch (SHORT1FROMMP (mp1)) {
  1725.  
  1726.             case IDD_CHKCASE:
  1727.                switch (SHORT2FROMMP (mp1)) {
  1728.  
  1729.                   case BN_CLICKED:
  1730.                      if (fCheckCase)
  1731.                         fCheckCase = FALSE;
  1732.                      else
  1733.                         fCheckCase = TRUE;
  1734.                      return 0;
  1735.                }
  1736.                break;
  1737.  
  1738.             case IDD_TOPSEARCH:
  1739.                switch (SHORT2FROMMP (mp1)) {
  1740.  
  1741.                   case BN_CLICKED:
  1742.                      if (fTopSearch)
  1743.                         fTopSearch = FALSE;
  1744.                      else
  1745.                         fTopSearch = TRUE;
  1746.                      return 0;
  1747.                }
  1748.                break;
  1749.  
  1750.             case IDD_HEXSTRING:
  1751.                switch (SHORT2FROMMP (mp1)) {
  1752.  
  1753.                   case BN_CLICKED:
  1754.                      if (fHexString)
  1755.                         fHexString = FALSE;
  1756.                      else
  1757.                         fHexString = TRUE;
  1758.                      return 0;
  1759.                }
  1760.                break;
  1761.          }
  1762.          break;
  1763.  
  1764.       case WM_COMMAND:
  1765.  
  1766.          switch (COMMANDMSG(&msg)->cmd) {
  1767.  
  1768.             case DID_OK:
  1769.                if (fHexString) {
  1770.                  WinQueryDlgItemText (hwnd, IDD_SRCHSTR, sizeof szSearchHStr,
  1771.                       szSearchHStr);
  1772.                  cbSearchStrLen = atob(szSearchHStr, sSearchStr);
  1773.                  if (cbSearchStrLen) {
  1774.                     WinDismissDlg (hwnd, TRUE);
  1775.                     return 0;
  1776.                     }
  1777.                  }
  1778.                else {
  1779.                  WinQueryDlgItemText (hwnd, IDD_SRCHSTR, sizeof szSearchStr,
  1780.                       szSearchStr);
  1781.                  if (strlen (szSearchStr)) {
  1782.                     WinDismissDlg (hwnd, TRUE);
  1783.                     return 0;
  1784.                     }
  1785.                  }
  1786.  
  1787.             case DID_CANCEL:
  1788.                WinDismissDlg (hwnd, FALSE);
  1789.                return 0;
  1790.          }
  1791.    }
  1792.    return WinDefDlgProc (hwnd, msg, mp1, mp2);
  1793. }
  1794. //===================================================================
  1795. // Procedures for File open dialog box
  1796. //===================================================================
  1797. VOID FillDriveListBox (HWND hwnd, CHAR *pcCurrentPath) {
  1798.    static CHAR szDrive [] = "  :";
  1799.    SHORT  sDrive;
  1800.    ULONG  ulDriveMap;
  1801.    USHORT usDriveNum;
  1802.  
  1803.    DosQCurDisk (&usDriveNum, &ulDriveMap);
  1804.  
  1805.    pcCurrentPath[0] = (CHAR) usDriveNum + '@';
  1806.    pcCurrentPath[1] = ':';
  1807.    pcCurrentPath[2] = '\\';
  1808.  
  1809.    WinSendDlgItemMsg (hwnd, IDD_DRIVELIST, LM_DELETEALL, NULL, NULL);
  1810.  
  1811.    for (sDrive = 0; sDrive < 26 ; sDrive++ )
  1812.       if (ulDriveMap & 1L << sDrive) {
  1813.          szDrive [1] = (CHAR) sDrive + 'A';
  1814.  
  1815.          WinSendDlgItemMsg (hwnd, IDD_DRIVELIST, LM_INSERTITEM,
  1816.                               MPFROM2SHORT (LIT_END, 0),
  1817.                               MPFROMP (szDrive));
  1818.       }
  1819.       WinSendDlgItemMsg (hwnd, IDD_DRIVELIST, LM_SELECTITEM,
  1820.                            MPFROM2SHORT (usDriveNum - 1, 0),
  1821.                            MPFROM2SHORT (TRUE, 0));
  1822. }
  1823. //------------------------------------------------------------------
  1824. //  Fill Directory List Box Procedure
  1825. //------------------------------------------------------------------
  1826. VOID FillDirListBox (HWND hwnd, CHAR *pcCurPath, BOOL fIncHidden) {
  1827.    static      CHAR  szRootStr[] = "\\";
  1828.    FILEFINDBUF findbuf;
  1829.    HDIR        hDir = 1;
  1830.    USHORT      usCurPathLen = PATHLENGTH, usSearchCount = 1;
  1831.    USHORT      usAttr;
  1832.  
  1833.    if (fIncHidden)
  1834.       usAttr = 0x0017;
  1835.    else
  1836.       usAttr = 0x0015;
  1837.  
  1838.    WinSendDlgItemMsg (hwnd, IDD_DIRLIST, LM_DELETEALL, NULL, NULL);
  1839.  
  1840.    DosQCurDir (0, pcCurPath + 3 , &usCurPathLen);
  1841.  
  1842.    DosFindFirst ("*.*", &hDir, usAttr, &findbuf, sizeof findbuf,
  1843.                  &usSearchCount, 0L);
  1844.  
  1845.    while (usSearchCount) {
  1846.       if (findbuf.attrFile & 0x0010
  1847.           && (findbuf.achName [0] != '.' || findbuf.achName [1] ))
  1848.  
  1849.          if (pcCurPath [strlen(pcCurPath)-1] != '\\'
  1850.              || findbuf.achName[1] != '.' || findbuf.achName [2])
  1851.  
  1852.             WinSendDlgItemMsg (hwnd, IDD_DIRLIST, LM_INSERTITEM,
  1853.                                  MPFROM2SHORT (LIT_SORTASCENDING, 0),
  1854.                                  MPFROMP (findbuf.achName));
  1855.  
  1856.       DosFindNext (hDir, &findbuf, sizeof findbuf, &usSearchCount);
  1857.    }
  1858.    if (pcCurPath [strlen(pcCurPath)-1] != '\\')
  1859.       WinSendDlgItemMsg (hwnd, IDD_DIRLIST, LM_INSERTITEM,
  1860.                           MPFROM2SHORT (0, 0), MPFROMP (szRootStr));
  1861. }
  1862. //------------------------------------------------------------------
  1863. //  Fill File List Box Procedure
  1864. //------------------------------------------------------------------
  1865. VOID FillFileListBox (HWND hwnd, CHAR *pcSearchParam, BOOL fIncHidden) {
  1866.    FILEFINDBUF findbuf;
  1867.    HDIR        hDir = 1;
  1868.    USHORT      usSearchCount = 1;
  1869.    USHORT      usAttr;
  1870.  
  1871.    if (fIncHidden)
  1872.       usAttr = 0x0007;
  1873.    else
  1874.       usAttr = 0x0005;
  1875.  
  1876.    WinSendDlgItemMsg (hwnd, IDD_FILELIST, LM_DELETEALL, NULL, NULL);
  1877.  
  1878.    DosFindFirst (pcSearchParam, &hDir, usAttr, &findbuf, sizeof findbuf,
  1879.                  &usSearchCount, 0L);
  1880.  
  1881.    while (usSearchCount) {
  1882.       WinSendDlgItemMsg (hwnd, IDD_FILELIST, LM_INSERTITEM,
  1883.                            MPFROM2SHORT (LIT_SORTASCENDING, 0),
  1884.                            MPFROMP (findbuf.achName));
  1885.       DosFindNext (hDir, &findbuf, sizeof findbuf, &usSearchCount);
  1886.    }
  1887. }
  1888. //------------------------------------------------------------------
  1889. //  File Open Dialog Box Procedure
  1890. //------------------------------------------------------------------
  1891. MRESULT EXPENTRY FileDlgProc (HWND hwnd, USHORT msg, MPARAM mp1, MPARAM mp2)
  1892.    {
  1893.    static      CHAR  szCurrentPath [PATHLENGTH], szFileName[PATHLENGTH] = "*.*";
  1894.    static      CHAR  szFileNameFilter[PATHLENGTH] = "*.*";
  1895.    static      BOOL  fIncHidden;
  1896.    CHAR        *pFileName;
  1897.    CHAR        szBuffer [PATHLENGTH];
  1898.    CHAR        szFilterText [PATHLENGTH+12];
  1899.    CHAR        szLastFileName [PATHLENGTH];
  1900.    USHORT      sLastFileIndex;
  1901.    USHORT      usCurPathLen = PATHLENGTH - 3;
  1902.    SHORT       sSelect;
  1903.    FILEFINDBUF findbuf;
  1904.    HDIR        hDir = 1;
  1905.    USHORT      usSearchCount = 1, usAttr, i;
  1906.  
  1907.    switch (msg) {
  1908.  
  1909.       case WM_INITDLG:
  1910.          fIncHidden = Default.fIncHiddenFiles;
  1911.  
  1912.          strcpy (szFileName, "*.*");
  1913.          strcpy (szFilterText, "File Filter: ");
  1914.          strcat (szFilterText, szFileNameFilter);
  1915.          WinSetDlgItemText (hwnd, IDD_FILEFILTER, szFilterText);
  1916.  
  1917.          FillDriveListBox (hwnd, szCurrentPath);
  1918.          FillDirListBox (hwnd, szCurrentPath, fIncHidden);
  1919.          FillFileListBox (hwnd, szFileNameFilter, fIncHidden);
  1920.  
  1921.          WinSendDlgItemMsg (hwnd, IDD_INCHIDDEN, BM_SETCHECK,
  1922.                             MPFROM2SHORT (fIncHidden, 0), NULL);
  1923.  
  1924.          DosQCurDir (0, szCurrentPath + 3, &usCurPathLen);
  1925.  
  1926.          WinSendDlgItemMsg ( hwnd, IDD_FILEEDIT, EM_SETTEXTLIMIT,
  1927.                              MPFROM2SHORT (PATHLENGTH, 0), NULL);
  1928.  
  1929.          WinSetDlgItemText ( hwnd, IDD_FILEEDIT, szCurrentPath);
  1930.  
  1931.  
  1932.          pFileName = strrchr(File.szName, '\\');
  1933.          if (pFileName != NULL) {
  1934.             strcpy (szLastFileName, (pFileName + 1));
  1935.             for (i = 0; i < strlen(szLastFileName); i++)
  1936.                szLastFileName[i] = (CHAR) toupper(szLastFileName[i]);
  1937.             sLastFileIndex = SHORT1FROMMR (
  1938.                    WinSendDlgItemMsg ( hwnd, IDD_FILELIST, LM_SEARCHSTRING,
  1939.                                     MPFROM2SHORT (LSS_CASESENSITIVE, LIT_FIRST),
  1940.                                     MPFROMP (szLastFileName) )
  1941.                                     );
  1942.             if ( (sLastFileIndex != LIT_ERROR) && (sLastFileIndex != LIT_NONE) )
  1943.                WinSendDlgItemMsg ( hwnd, IDD_FILELIST, LM_SETTOPINDEX,
  1944.                                    MPFROMSHORT (sLastFileIndex),
  1945.                                    NULL);
  1946.          }
  1947.  
  1948.  
  1949.          return 0;
  1950.  
  1951.       case WM_CONTROL:
  1952.  
  1953.          if (SHORT1FROMMP (mp1) == IDD_DRIVELIST ||
  1954.              SHORT1FROMMP (mp1) == IDD_DIRLIST   ||
  1955.              SHORT1FROMMP (mp1) == IDD_FILELIST) {
  1956.  
  1957.             sSelect = (USHORT) WinSendDlgItemMsg (hwnd, SHORT1FROMMP (mp1),
  1958.                                     LM_QUERYSELECTION, 0L, 0L);
  1959.  
  1960.             WinSendDlgItemMsg (hwnd, SHORT1FROMMP (mp1),
  1961.                               LM_QUERYITEMTEXT,
  1962.                               MPFROM2SHORT (sSelect, sizeof szBuffer),
  1963.                               MPFROMP (szBuffer));
  1964.          }
  1965.  
  1966.          switch (SHORT1FROMMP (mp1)) {
  1967.  
  1968.             case IDD_DRIVELIST:
  1969.                switch (SHORT2FROMMP (mp1)) {
  1970.  
  1971.                   case LN_ENTER:
  1972.                      szCurrentPath[0] = szBuffer[1];
  1973.                      DosSelectDisk (szBuffer [1] - '@');
  1974.  
  1975.                      FillDirListBox (hwnd, szCurrentPath, fIncHidden);
  1976.                      if (strcmp(szFileName, "*.*") != 0) {
  1977.                         if (szCurrentPath [strlen (szCurrentPath)-1]
  1978.                                                                 != '\\')
  1979.                            strcat (szCurrentPath, "\\");
  1980.                         strcat (szCurrentPath, szFileName);
  1981.                      }
  1982.                      WinSetDlgItemText ( hwnd, IDD_FILEEDIT, szCurrentPath);
  1983.                      FillFileListBox (hwnd, szFileNameFilter, fIncHidden);
  1984.  
  1985.                      return 0;
  1986.                }
  1987.                break;
  1988.  
  1989.             case IDD_DIRLIST:
  1990.                switch (SHORT2FROMMP (mp1)) {
  1991.  
  1992.                   case LN_ENTER:
  1993.  
  1994.                      DosChDir (szBuffer, 0L);
  1995.  
  1996.                      FillDirListBox (hwnd, szCurrentPath, fIncHidden);
  1997.                      if (strcmp(szFileName, "*.*") != 0) {
  1998.                         if (szCurrentPath [strlen (szCurrentPath)-1]
  1999.                                                                 != '\\')
  2000.                            strcat (szCurrentPath, "\\");
  2001.                         strcat (szCurrentPath, szFileName);
  2002.                      }
  2003.                      WinSetDlgItemText ( hwnd, IDD_FILEEDIT, szCurrentPath);
  2004.                      FillFileListBox (hwnd, szFileNameFilter, fIncHidden);
  2005.                      return 0;
  2006.                }
  2007.                break;
  2008.  
  2009.             case IDD_FILELIST:
  2010.                switch (SHORT2FROMMP (mp1)) {
  2011.  
  2012.                   case LN_SELECT:
  2013.  
  2014.                      DosQCurDir (0, szCurrentPath + 3, &usCurPathLen);
  2015.                      if (szCurrentPath [strlen(szCurrentPath)-1] != '\\')
  2016.                         strcat (szCurrentPath, "\\");
  2017.                      strcat (szCurrentPath, szBuffer);
  2018.  
  2019.                      WinSetDlgItemText ( hwnd, IDD_FILEEDIT, szCurrentPath);
  2020.                      return 0;
  2021.  
  2022.                   case LN_ENTER:
  2023.  
  2024.                      WinQueryDlgItemText (hwnd, IDD_FILEEDIT,
  2025.                                           sizeof szCurrentPath,
  2026.                                           szCurrentPath);
  2027.                      if (DosQPathInfo (szCurrentPath, 5, szBuffer,
  2028.                                    sizeof szBuffer, 0L)) {
  2029.                         WinMessageBox ( HWND_DESKTOP, hwnd, szBuffer,
  2030.                                              "Unrecognised path", 1,
  2031.                                              MB_OK | MB_ERROR);
  2032.                         return 0;
  2033.                      } else {
  2034.                         strcpy (szNewFile, szBuffer);
  2035.                         Default.fIncHiddenFiles = fIncHidden;
  2036.                         WinDismissDlg (hwnd, TRUE);
  2037.                         return 0;
  2038.                      }
  2039.                }
  2040.                break;
  2041.  
  2042.             case IDD_INCHIDDEN:
  2043.                switch (SHORT2FROMMP (mp1)) {
  2044.  
  2045.                   case BN_CLICKED:
  2046.                      if (fIncHidden)
  2047.                         fIncHidden = FALSE;
  2048.                      else
  2049.                         fIncHidden = TRUE;
  2050.                      FillFileListBox (hwnd, szFileName, fIncHidden);
  2051.                      FillDirListBox (hwnd, szCurrentPath, fIncHidden);
  2052.                      return 0;
  2053.                }
  2054.                break;
  2055.          }
  2056.          break;
  2057.  
  2058.       case WM_COMMAND:
  2059.  
  2060.          switch (COMMANDMSG(&msg)->cmd) {
  2061.  
  2062.             case DID_OK:
  2063.                WinQueryDlgItemText (hwnd, IDD_FILEEDIT,
  2064.                                     sizeof szCurrentPath,
  2065.                                     szCurrentPath);
  2066.                if (DosQPathInfo (szCurrentPath, 5, szBuffer,
  2067.                              sizeof szBuffer, 0L)) {
  2068.                   WinMessageBox ( HWND_DESKTOP, hwnd, szBuffer,
  2069.                                        "Unrecognised path", 1,
  2070.                                        MB_OK | MB_ERROR);
  2071.                   return 0;
  2072.                } else
  2073.                   if (strchr (szBuffer, '*') == 0
  2074.                       && strchr (szBuffer, '?') == 0) {
  2075.                      if (fIncHidden)
  2076.                         usAttr = 0x0007;
  2077.                      else
  2078.                         usAttr = 0x0005;
  2079.                      usSearchCount = 1;
  2080.  
  2081.                      DosFindFirst (szBuffer, &hDir, usAttr, &findbuf,
  2082.                                    sizeof findbuf, &usSearchCount, 0L);
  2083.                      if (usSearchCount  == 0) {
  2084.                         WinMessageBox (HWND_DESKTOP, hwnd, szBuffer,
  2085.                                        "File not Found", 1, MB_OK | MB_ERROR);
  2086.                         return 0;
  2087.                      } else {
  2088.                         strcpy (szNewFile, szBuffer);
  2089.                         Default.fIncHiddenFiles = fIncHidden;
  2090.                         WinDismissDlg (hwnd, TRUE);
  2091.                         return 0;
  2092.                      }
  2093.                   } else {
  2094.                      for (i = strlen(szBuffer); i >= 0; i--)
  2095.                         if (szBuffer[i] == '\\')
  2096.                            break;
  2097.                      strcpy (szFileNameFilter, szBuffer + i + 1);
  2098.                      strcpy (szFilterText, "File Filter: ");
  2099.                      strcat (szFilterText, szFileNameFilter);
  2100.                      WinSetDlgItemText (hwnd, IDD_FILEFILTER, szFilterText);
  2101.                      FillFileListBox (hwnd, szFileNameFilter, fIncHidden);
  2102.                      return 0;
  2103.                   }
  2104.                break;
  2105.             case DID_CANCEL:
  2106.                WinDismissDlg (hwnd, FALSE);
  2107.                return 0;
  2108.          }
  2109.          break;
  2110.    }
  2111.    return WinDefDlgProc (hwnd, msg, mp1, mp2);
  2112. }
  2113. //===================================================================
  2114. // Procedures for Configure dialog box
  2115. //===================================================================
  2116. VOID FillColorBox (HWND hwnd, SHORT iListID) {
  2117.  
  2118.    static CHAR szColors [16][12] = { "Black", "Dk. Blue", "Dk. Green",
  2119.       "Dk. Cyan", "Dk. Red", "Dk. Magenta", "Brown", "Gray", "Dk. Gray",
  2120.       "Blue", "Green", "Cyan", "Red", "Magenta", "Yellow", "White"};
  2121.  
  2122.    SHORT  i;
  2123.  
  2124.    WinSendDlgItemMsg (hwnd, iListID, LM_DELETEALL, NULL, NULL);
  2125.  
  2126.    for (i = 0; i < 16 ; i++ )
  2127.          WinSendDlgItemMsg (hwnd, iListID, LM_INSERTITEM,
  2128.                               MPFROM2SHORT (LIT_END, 0),
  2129.                               MPFROMP (szColors[i]));
  2130.    return;
  2131. }
  2132. //------------------------------------------------------------------
  2133. //  Fill Character cell size box
  2134. //------------------------------------------------------------------
  2135. VOID FillCellSizeBox (HWND hwnd, SHORT iListID) {
  2136.  
  2137.    static CHAR szCellSizes [10][8] = {"8 x 8", "8 x 12", "8 x 14", "7 x 15",
  2138.       "7 x 25", "8 x 17", "12 x 16", "12 x 20", "12 x 22", "12 x 30"};
  2139.  
  2140.    SHORT  i, sStart, sEnd;
  2141.  
  2142.    WinSendDlgItemMsg (hwnd, iListID, LM_DELETEALL, NULL, NULL);
  2143.  
  2144.    WinSendDlgItemMsg (hwnd, iListID, LM_INSERTITEM,
  2145.                     MPFROM2SHORT (LIT_END, 0), MPFROMP (szCellSizes[0]));
  2146.  
  2147.    switch (VideoData.usAdapterType) {
  2148.       case 0:
  2149.       case 1:                          //CGA, no other cell sizes.
  2150.          sStart = 2;
  2151.          sEnd = 1;
  2152.          break;
  2153.  
  2154.       case 2:                          //EGA
  2155.          sStart = 1;
  2156.          sEnd = 1;
  2157.          break;
  2158.  
  2159.       case 3:                          //VGA
  2160.          sStart = 2;
  2161.          sEnd = 2;
  2162.          break;
  2163.  
  2164.       case 7:                          //8514
  2165.          sStart = 3;
  2166.          sEnd = 9;
  2167.          break;
  2168.       }
  2169.    for (i = sStart; i <= sEnd; i++ )
  2170.       WinSendDlgItemMsg (hwnd, iListID, LM_INSERTITEM,
  2171.                       MPFROM2SHORT (LIT_END, 0), MPFROMP (szCellSizes[i]));
  2172.    return;
  2173. }
  2174. //------------------------------------------------------------------
  2175. // GetFontSize - Determine font size.
  2176. //------------------------------------------------------------------
  2177. SHORT GetCellSize (SHORT sHeight, SHORT sWidth) {
  2178.  
  2179.    SHORT  i, sIndex = 1, sStart = 1;
  2180.  
  2181.    if (sHeight == sCellSize[0][1] && sWidth == sCellSize[0][0])
  2182.       return 0;
  2183.  
  2184.    if (VideoData.usAdapterType == 3)
  2185.       sStart = 2;
  2186.    else if (VideoData.usAdapterType == 7)
  2187.       sStart = 3;
  2188.    for (i = sStart; i < 10; i++, sIndex++ )
  2189.       if (sHeight == sCellSize[i][1] && sWidth == sCellSize[i][0])
  2190.          break;
  2191.    return sIndex;
  2192. }
  2193. //------------------------------------------------------------------
  2194. //  Configure Dialog Box
  2195. //------------------------------------------------------------------
  2196. MRESULT EXPENTRY ConfigDlgProc (HWND hwnd, USHORT msg, MPARAM mp1, MPARAM mp2)
  2197.    {
  2198.    static   SHORT    sSelect;
  2199.    static   CHAR     szAttribute[2];
  2200.    static   SHORT    sCHeight;
  2201.    static   SHORT    sCWidth;
  2202.    static   SHORT    sTabStop;
  2203.    static   BOOL     fDispASCII;
  2204.    static   BOOL     fScrollBars;
  2205.    static   BOOL     fDispEBCDIC;
  2206.    static   BOOL     fLocalSaveWinPos;
  2207.  
  2208.    switch (msg) {
  2209.  
  2210.       case WM_INITDLG:
  2211.  
  2212.          szAttribute[1] = Default.szAttribute[1];
  2213.          sCHeight = Default.sCellHeight;
  2214.          sCWidth = Default.sCellWidth;
  2215.          sTabStop = Default.sTabStop;
  2216.          fDispASCII = Default.fDispASCII;
  2217.          fScrollBars = Default.fScrollBars;
  2218.          fDispEBCDIC = Default.fDispEBCDIC;
  2219.          fLocalSaveWinPos = FALSE;
  2220.  
  2221.          FillColorBox (hwnd, IDD_FCOLOR);
  2222.          FillColorBox (hwnd, IDD_BCOLOR);
  2223.          FillCellSizeBox (hwnd, IDD_CELLSIZE);
  2224.  
  2225.          WinSendDlgItemMsg (hwnd, IDD_BCOLOR, LM_SELECTITEM,
  2226.                    MPFROM2SHORT (((szAttribute[1]>>4) & 0x0f), 0),
  2227.                    MPFROM2SHORT (TRUE,0));
  2228.  
  2229.          WinSendDlgItemMsg (hwnd, IDD_FCOLOR, LM_SELECTITEM,
  2230.                    MPFROM2SHORT ((szAttribute[1] & 0x0f), 0),
  2231.                    MPFROM2SHORT (TRUE,0));
  2232.  
  2233.          WinSendDlgItemMsg (hwnd, IDD_CELLSIZE, LM_SELECTITEM,
  2234.                    MPFROM2SHORT (GetCellSize (sCHeight,sCWidth), 0),
  2235.                    MPFROM2SHORT (TRUE,0));
  2236.  
  2237.          WinSendDlgItemMsg (hwnd, IDD_DEFASCII, BM_SETCHECK,
  2238.                             MPFROM2SHORT (fDispASCII, 0), NULL);
  2239.  
  2240.          WinSendDlgItemMsg (hwnd, IDD_DEFHEXASC, BM_SETCHECK,
  2241.                             MPFROM2SHORT (!fDispASCII, 0), NULL);
  2242.  
  2243.          WinSendDlgItemMsg (hwnd, IDD_DEFHEXEBC, BM_SETCHECK,
  2244.                             MPFROM2SHORT (fDispEBCDIC, 0), NULL);
  2245.  
  2246.          WinSendDlgItemMsg (hwnd, IDD_DEFSCROLL, BM_SETCHECK,
  2247.                             MPFROM2SHORT (fScrollBars, 0), NULL);
  2248.  
  2249.          WinSendDlgItemMsg (hwnd, IDD_SAVEWINPOS, BM_SETCHECK,
  2250.                             MPFROM2SHORT (fLocalSaveWinPos, 0), NULL);
  2251.  
  2252.          WinSendDlgItemMsg (hwnd, IDD_SAVE, BM_SETCHECK,
  2253.                             MPFROM2SHORT (fSaveToDisk, 0), NULL);
  2254.  
  2255.          WinSetDlgItemShort ( hwnd, IDD_DEFTABS, sTabStop, FALSE);
  2256.          return 0;
  2257.  
  2258.       case WM_CONTROL:
  2259.  
  2260.          if (SHORT1FROMMP (mp1) == IDD_BCOLOR    ||
  2261.              SHORT1FROMMP (mp1) == IDD_FCOLOR    ||
  2262.              SHORT1FROMMP (mp1) == IDD_CELLSIZE) {
  2263.             sSelect = (USHORT) WinSendDlgItemMsg (hwnd,
  2264.                       SHORT1FROMMP (mp1), LM_QUERYSELECTION, 0L, 0L);
  2265.          }
  2266.          switch (SHORT1FROMMP (mp1)) {
  2267.  
  2268.             case IDD_BCOLOR:
  2269.                switch (SHORT2FROMMP (mp1)) {
  2270.  
  2271.                   case LN_SELECT:
  2272.  
  2273.                      szAttribute[1] = (szAttribute[1] & 0x0f)
  2274.                                       | ((sSelect << 4) & 0xf0);
  2275.                      return 0;
  2276.                }
  2277.                break;
  2278.  
  2279.             case IDD_FCOLOR:
  2280.                switch (SHORT2FROMMP (mp1)) {
  2281.  
  2282.                   case LN_SELECT:
  2283.  
  2284.                      szAttribute[1] = (szAttribute[1] & 0xf0)
  2285.                                       | (sSelect & 0x0f);
  2286.                      return 0;
  2287.                }
  2288.                break;
  2289.  
  2290.             case IDD_CELLSIZE:
  2291.                switch (SHORT2FROMMP (mp1)) {
  2292.  
  2293.                   case LN_SELECT:
  2294.  
  2295.                      if (sSelect != 0)
  2296.                         switch (VideoData.usAdapterType) {
  2297.                            case 3:                         //VGA
  2298.                               sSelect++;
  2299.                               break;
  2300.  
  2301.                            case 7:                         //8514
  2302.                               sSelect += 2;
  2303.                               break;
  2304.                         }
  2305.                      sCHeight = sCellSize [sSelect][1];
  2306.                      sCWidth = sCellSize [sSelect][0];
  2307.                      return 0;
  2308.                }
  2309.                break;
  2310.  
  2311.             case IDD_DEFASCII:
  2312.                switch (SHORT2FROMMP (mp1)) {
  2313.  
  2314.                   case BN_CLICKED:
  2315.                      fDispASCII = TRUE;
  2316.                      fDispEBCDIC = FALSE;
  2317.                      return 0;
  2318.                }
  2319.                break;
  2320.  
  2321.             case IDD_DEFHEXASC:
  2322.                switch (SHORT2FROMMP (mp1)) {
  2323.  
  2324.                   case BN_CLICKED:
  2325.                      fDispASCII = FALSE;
  2326.                      fDispEBCDIC = FALSE;
  2327.                      return 0;
  2328.                }
  2329.                break;
  2330.  
  2331.             case IDD_DEFHEXEBC:
  2332.                switch (SHORT2FROMMP (mp1)) {
  2333.  
  2334.                   case BN_CLICKED:
  2335.                      fDispASCII = FALSE;
  2336.                      fDispEBCDIC = TRUE;
  2337.                      return 0;
  2338.                }
  2339.                break;
  2340.  
  2341.             case IDD_DEFSCROLL:
  2342.                switch (SHORT2FROMMP (mp1)) {
  2343.  
  2344.                   case BN_CLICKED:
  2345.                      if (fScrollBars)
  2346.                         fScrollBars = FALSE;
  2347.                      else
  2348.                         fScrollBars = TRUE;
  2349.                      return 0;
  2350.                }
  2351.                break;
  2352.  
  2353.             case IDD_SAVEWINPOS:
  2354.                switch (SHORT2FROMMP (mp1)) {
  2355.  
  2356.                   case BN_CLICKED:
  2357.                      if (fLocalSaveWinPos)
  2358.                         fLocalSaveWinPos = FALSE;
  2359.                      else
  2360.                         fLocalSaveWinPos = TRUE;
  2361.                      return 0;
  2362.                }
  2363.                break;
  2364.  
  2365.             case IDD_SAVE:
  2366.                switch (SHORT2FROMMP (mp1)) {
  2367.  
  2368.                   case BN_CLICKED:
  2369.                      if (fSaveToDisk)
  2370.                         fSaveToDisk = FALSE;
  2371.                      else
  2372.                         fSaveToDisk = TRUE;
  2373.                      return 0;
  2374.                }
  2375.                break;
  2376.          }
  2377.          break;
  2378.  
  2379.       case WM_COMMAND:
  2380.  
  2381.          switch (COMMANDMSG(&msg)->cmd) {
  2382.  
  2383.                   case DID_OK:
  2384.                      Default.szAttribute[1] = szAttribute[1];
  2385.                      Default.sCellHeight = sCHeight;
  2386.                      Default.sCellWidth = sCWidth;
  2387.                      Default.fDispASCII = fDispASCII;
  2388.                      Default.fScrollBars = fScrollBars;
  2389.                      Default.fDispEBCDIC = fDispEBCDIC;
  2390.                      WinQueryDlgItemShort (hwnd, IDD_DEFTABS, &sSelect,
  2391.                                            FALSE);
  2392.                      sSelect = min (max (1, sSelect), AVIOCOLS - 1);
  2393.                      Default.sTabStop = sSelect;
  2394.                      fSaveWinPos = fLocalSaveWinPos;
  2395.                      WinDismissDlg (hwnd, TRUE);
  2396.                      return 1;
  2397.  
  2398.                   case DID_CANCEL:
  2399.                           WinDismissDlg (hwnd, FALSE);
  2400.                           return 0;
  2401.          }
  2402.    }
  2403.    return WinDefDlgProc (hwnd, msg, mp1, mp2);
  2404. }
  2405. //------------------------------------------------------------------
  2406. //  Font Size Dialog Box
  2407. //------------------------------------------------------------------
  2408. MRESULT EXPENTRY FontDlgProc (HWND hwnd, USHORT msg, MPARAM mp1, MPARAM mp2)
  2409.    {
  2410.    static   SHORT    sSelect;
  2411.    static   SHORT    sCHeight;
  2412.    static   SHORT    sCWidth;
  2413.  
  2414.    switch (msg) {
  2415.  
  2416.       case WM_INITDLG:
  2417.  
  2418.          sCHeight = Default.sCellHeight;
  2419.          sCWidth = Default.sCellWidth;
  2420.  
  2421.          FillCellSizeBox (hwnd, IDD_FONTS);
  2422.  
  2423.          WinSendDlgItemMsg (hwnd, IDD_FONTS, LM_SELECTITEM,
  2424.                    MPFROM2SHORT (GetCellSize (sCHeight,sCWidth), 0),
  2425.                    MPFROM2SHORT (TRUE,0));
  2426.          return 0;
  2427.  
  2428.       case WM_CONTROL:
  2429.  
  2430.          switch (SHORT1FROMMP (mp1)) {
  2431.  
  2432.             case IDD_FONTS:
  2433.                switch (SHORT2FROMMP (mp1)) {
  2434.  
  2435.                   case LN_SELECT:
  2436.                      sSelect = (USHORT) WinSendDlgItemMsg (hwnd,
  2437.                          IDD_FONTS, LM_QUERYSELECTION, 0L, 0L);
  2438.  
  2439.                      if (sSelect != 0)
  2440.                         switch (VideoData.usAdapterType) {
  2441.                            case 3:                         //VGA
  2442.                               sSelect++;
  2443.                               break;
  2444.  
  2445.                            case 7:                         //8514
  2446.                               sSelect += 2;
  2447.                               break;
  2448.                         }
  2449.                      sCHeight = sCellSize [sSelect][1];
  2450.                      sCWidth = sCellSize [sSelect][0];
  2451.                      return 0;
  2452.  
  2453.                   case LN_ENTER:
  2454.                      Default.sCellHeight = sCHeight;
  2455.                      Default.sCellWidth = sCWidth;
  2456.                      WinDismissDlg (hwnd, TRUE);
  2457.                      return 0;
  2458.  
  2459.                }
  2460.                break;
  2461.          }
  2462.          break;
  2463.  
  2464.       case WM_COMMAND:
  2465.  
  2466.          switch (COMMANDMSG(&msg)->cmd) {
  2467.  
  2468.                   case DID_OK:
  2469.                      Default.sCellHeight = sCHeight;
  2470.                      Default.sCellWidth = sCWidth;
  2471.                      WinDismissDlg (hwnd, TRUE);
  2472.                      return 0;
  2473.  
  2474.                   case DID_CANCEL:
  2475.                      WinDismissDlg (hwnd, FALSE);
  2476.                      return 0;
  2477.          }
  2478.    }
  2479.    return WinDefDlgProc (hwnd, msg, mp1, mp2);
  2480. }
  2481.