home *** CD-ROM | disk | FTP | other *** search
/ Borland Programmer's Resource / Borland_Programmers_Resource_CD_1995.iso / ntcode / holep / holeport.c next >
Encoding:
C/C++ Source or Header  |  1995-05-19  |  25.8 KB  |  1,012 lines
  1. #include "os2win.h"
  2. #include <stdio.h>
  3. #include <string.h>
  4. #include <malloc.h>
  5. #include <ctype.h>
  6.  
  7. HANDLE hinst;
  8. CRITICAL_SECTION HP_cs_mutex;
  9. HANDLE           HP_event_sem;
  10.  
  11. int main(int argc, char *argv[])
  12. {
  13.     return(0);
  14. }
  15.  
  16. VOID HP_SetHinst(HANDLE h)
  17. {
  18.     hinst = h;
  19.     return;
  20. }
  21.  
  22. LONG HP_gpiCharStringAt(HDC hdc, PPOINTL ppl, int cb, LPCSTR pch)
  23. {
  24.     UINT uintSave;
  25.     uintSave = GetTextAlign(hdc);
  26.     SetTextAlign(hdc, uintSave | TA_UPDATECP);
  27.     MoveToEx(hdc, ppl->x, ppl->y, NULL);
  28.     TextOut(hdc, 0, 0, pch, cb);
  29.     SetTextAlign(hdc, uintSave);
  30.     return(TRUE);
  31. }
  32.  
  33. USHORT HP_dosReallocSeg(USHORT usNew, SEL sel)
  34. {
  35.     UINT cb = LocalSize(sel);
  36.  
  37.     if ((UINT) usNew > cb)
  38.         MessageBox(NULL, "Cannot Grow memory with cheater libs.",
  39.             "OS/2 conversion Error", MB_ICONHAND | MB_OK);
  40.     return(0);
  41.     
  42. }
  43.  
  44.  
  45. USHORT HP_dosFreeSeg( SEL sel)
  46. {
  47.     LocalFree(sel);
  48.     return(0);
  49. }
  50.  
  51. USHORT HP_dosAllocSeg( USHORT usSize, PSEL psel, USHORT fs)
  52. {
  53.     if (fs & (SEG_GIVEABLE | SEG_GETTABLE))
  54.         MessageBox(NULL, "Give/Get Seg not supported.",
  55.             "OS/2 conversion Error", MB_ICONHAND | MB_OK);
  56.  
  57.     *psel = LocalAlloc(LPTR, (UINT) usSize);
  58.  
  59.     return(0);
  60. }
  61.  
  62. BOOL HP_winQueryCursorInfo(HWND hd, PCURSORINFO pcsri)
  63. {
  64.     POINT ptl;
  65.     GetCursorPos(&ptl);
  66.  
  67.     pcsri->hwnd = WindowFromPoint(ptl);
  68.     pcsri->x =  ptl.x;
  69.     pcsri->y =  ptl.y;
  70.     pcsri->cx =  0;   // USE Defaults.
  71.     pcsri->cy =  0;
  72.     pcsri->fs = 0;    // CURSOR_SOLID
  73.     GetClipCursor(&pcsri->rclClip);
  74.     return(TRUE);
  75. }
  76.  
  77.  
  78.  
  79. HWND HP_winQueryWindow(HWND hwnd, SHORT cmd, BOOL b)
  80. {
  81.     switch (cmd)
  82.     {
  83.     case QW_NEXT:
  84.         return(GetNextWindow(hwnd, GW_HWNDNEXT));
  85.         break;
  86.     case QW_PREV:
  87.         return(GetNextWindow(hwnd, GW_HWNDPREV));
  88.         break;
  89.     case QW_TOP:
  90.         return(GetTopWindow(hwnd));
  91.         break;
  92.     case QW_BOTTOM:
  93.         return(GetWindow(GetWindow(hwnd,GW_CHILD), GW_HWNDLAST));
  94.         break;
  95.     case QW_OWNER:
  96.         return(GetWindow(hwnd, GW_OWNER));
  97.         break;
  98.     case QW_PARENT:
  99.         return(GetParent(hwnd));
  100.         break;
  101.     case QW_NEXTTOP:
  102.         return(GetWindow(hwnd, GW_HWNDNEXT));
  103.         break;
  104.     case QW_PREVTOP:
  105.         return(GetWindow(hwnd, GW_HWNDPREV));
  106.         break;
  107.     default:
  108.         return(NULL);
  109.         break;
  110.     }
  111. }
  112.  
  113. HANDLE HP_winQuerySysPointer(HWND hd, SHORT s, BOOL b)
  114. {
  115.     switch(s)
  116.     {
  117.     case SPTR_APPICON:
  118.         LoadIcon(NULL, IDI_APPLICATION);
  119.         break;
  120.     case SPTR_ARROW:
  121.         LoadCursor(NULL, IDC_ARROW);
  122.         break;
  123.     case SPTR_ICONERROR:
  124.         LoadIcon(NULL, IDI_HAND);
  125.         break;
  126.     case SPTR_ICONINFORMATION:
  127.         LoadIcon(NULL, IDI_ASTERISK);
  128.         break;
  129.     case SPTR_ICONQUESTION:
  130.         LoadIcon(NULL, IDI_QUESTION);
  131.         break;
  132.     case SPTR_ICONWARNING:
  133.         LoadIcon(NULL, IDI_EXCLAMATION);
  134.         break;
  135.     case SPTR_MOVE:
  136.         MessageBox(NULL, "No SPTR_MOVE ICON in Windows",
  137.             "OS/2 conversion Error", MB_ICONHAND | MB_OK);
  138.         return(NULL);
  139.         break;
  140.     case SPTR_SIZENESW:
  141.         LoadCursor(NULL, IDC_SIZENESW);
  142.         break;
  143.     case SPTR_SIZENS:
  144.         LoadCursor(NULL, IDC_SIZENS);
  145.         break;
  146.     case SPTR_SIZENWSE:
  147.         LoadCursor(NULL, IDC_SIZENWSE);
  148.         break;
  149.     case SPTR_SIZEWE:
  150.         LoadCursor(NULL, IDC_SIZEWE);
  151.         break;
  152.     case SPTR_TEXT:
  153.         LoadCursor(NULL, IDC_IBEAM);
  154.         break;
  155.     case SPTR_WAIT:
  156.         LoadCursor(NULL, IDC_WAIT);
  157.         break;
  158.     }
  159. }
  160.  
  161. USHORT HP_dosChgFilePtr(HANDLE h, LONG l, USHORT M, PULONG pul)
  162. {
  163.     DWORD dw;
  164.     dw = SetFilePointer(h, l, NULL, M);
  165.  
  166.     if (pul) 
  167.         *pul = SetFilePointer(h, l, NULL, M);
  168.     return( (dw) ? 0 : -1);
  169. }
  170.  
  171. VOID HP_dosExit( USHORT usF, USHORT usC)
  172. {
  173.     if (usF == EXIT_THREAD)
  174.         ExitThread(usC);
  175.  
  176.     MessageBox(NULL, "Exited Process with DosExit",
  177.         "Poss. OS/2 conversion Error", MB_ICONHAND | MB_OK);
  178.     ExitProcess(usC);
  179. }
  180.  
  181. USHORT HP_dosQHandType( HANDLE h, PULONG pul, PUSHORT pus)
  182. {
  183.     DWORD dw = GetFileType(h);
  184.  
  185.     if (pul) 
  186.         *pul = dw;
  187.     return( (dw) ? 0 : -1);
  188. }
  189.  
  190. USHORT HP_dosQFileMode( PSZ psz, PULONG pul, DWORD d)
  191. {
  192.     DWORD dw = GetFileAttributes(psz);
  193.  
  194.     if (pul) 
  195.         *pul = dw;
  196.     return( (dw) ? 0 : -1);
  197. }
  198.  
  199. USHORT HP_dosGetProcAddress( HANDLE h, PSZ psz, PPFN pul)
  200. {
  201.     FARPROC dw = GetProcAddress(h, psz);
  202.  
  203.     if (pul) 
  204.         *pul = dw;
  205.     return( (dw) ? 0 : -1);
  206. }
  207.  
  208. DWORD HP_dosMakeNmPipe(PSZ pszName, PHPIPE php, USHORT fsOpenMode,
  209.     USHORT fsPipeMode, USHORT cbOutBuf, USHORT cbInBuf, DWORD ulTimeOut)
  210.     {
  211.     *php = CreateNamedPipe( pszName, fsOpenMode, fsPipeMode,
  212.         1L, cbOutBuf, cbInBuf, ulTimeOut, NULL);
  213.     if (*php != NULL)
  214.         return(0);
  215.     else
  216.         return(GetLastError());
  217.     }
  218.  
  219. DWORD HP_dosOpen(PSZ pszFileName, PHANDLE phf, PUSHORT pusAction,
  220.     ULONG ulFileSize, USHORT usAttribute, USHORT fsOpenFlags, 
  221.     USHORT fsOpenMode, ULONG ul)
  222.     {
  223.     DWORD fdwAccess, fdwShareMode, fdwCreate, fdwAttr;
  224.     USHORT usTmp;
  225.     SECURITY_ATTRIBUTES sa;
  226.  
  227.     fdwAccess = fdwShareMode = fdwCreate = 0L;
  228.  
  229.     if (fsOpenFlags == FILE_CREATE)   fdwAccess = CREATE_NEW;
  230.     if (fsOpenFlags == FILE_OPEN)     fdwAccess = OPEN_EXISTING;
  231.     if (fsOpenFlags == FILE_TRUNCATE) fdwAccess = TRUNCATE_EXISTING;
  232.  
  233.     if (fsOpenFlags == (FILE_CREATE | FILE_TRUNCATE)) 
  234.         fdwAccess = CREATE_ALWAYS;
  235.  
  236.     if (fsOpenFlags == (FILE_CREATE | FILE_OPEN)) 
  237.         fdwAccess = OPEN_ALWAYS;
  238.  
  239.     if (fsOpenMode & OPEN_ACCESS_WRITEONLY) 
  240.         fdwAccess = GENERIC_WRITE;
  241.     else if (fsOpenMode & OPEN_ACCESS_READWRITE) 
  242.         fdwAccess = GENERIC_WRITE | GENERIC_READ;
  243.     else
  244.         fdwAccess = GENERIC_READ;
  245.  
  246.     fdwAttr = (DWORD) usAttribute;
  247.     if (fsOpenMode & OPEN_FLAGS_WRITE_THROUGH)
  248.         fdwAttr |= FILE_FLAG_WRITE_THROUGH;
  249.     if (fsOpenMode & OPEN_FLAGS_NO_CACHE)
  250.         fdwAttr |= FILE_FLAG_NO_BUFFERING;
  251.     if (fsOpenMode & OPEN_FLAGS_SEQUENTIAL)
  252.         fdwAttr |= FILE_FLAG_SEQUENTIAL_SCAN;
  253.     if (fsOpenMode & OPEN_FLAGS_RANDOM)
  254.         fdwAttr |= FILE_FLAG_RANDOM_ACCESS;
  255.  
  256.     usTmp = fsOpenMode & 0x0070;
  257.     if (usTmp == OPEN_SHARE_DENYREAD)  fdwShareMode = FILE_SHARE_WRITE;
  258.     if (usTmp == OPEN_SHARE_DENYWRITE) fdwShareMode = FILE_SHARE_READ;
  259.     if (usTmp == OPEN_SHARE_DENYNONE)  
  260.         fdwShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE;
  261.  
  262.     sa.nLength              = sizeof(SECURITY_ATTRIBUTES);
  263.     sa.lpSecurityDescriptor = NULL;
  264.     if (fsOpenMode & OPEN_FLAGS_NOINHERIT)
  265.         sa.bInheritHandle = FALSE;
  266.     else
  267.         sa.bInheritHandle = TRUE;
  268.  
  269.     *phf = CreateFile( pszFileName, fdwAccess, fdwShareMode,
  270.             &sa, fdwCreate, fdwAttr, NULL);
  271.     if (*phf != NULL)
  272.         return(0);
  273.     else
  274.         return(GetLastError());
  275.     }
  276.  
  277. USHORT HP_dosQCurDir(USHORT usDriveNum, PSZ pszPath, PUSHORT pcb)
  278. {
  279.     char chCurrent[MAX_PATH], chOther[MAX_PATH];
  280.     char ch;
  281.     USHORT usCurrent;
  282.  
  283.     GetCurrentDirectory(MAX_PATH, chCurrent);
  284.     ch = toupper(chCurrent[0]);
  285.     usCurrent = (char) ((0x007F & ch) - (0x007F & 'A') + 1);
  286.     if (usDriveNum == 0 || usDriveNum == usCurrent)
  287.         strcpy( chOther, chCurrent);
  288.     else
  289.         {
  290.         strcpy( chOther, "A:");
  291.         ch = usDriveNum + (0x007F & 'A') - 1;
  292.         chOther[0] = ch;
  293.         SetCurrentDirectory(chOther);
  294.         GetCurrentDirectory(MAX_PATH, chOther);
  295.         SetCurrentDirectory(chCurrent);
  296.         }
  297.  
  298.     if ((strlen(chOther) - 1) > *pcb)
  299.         return(ERROR_BUFFER_OVERFLOW);
  300.     else
  301.         {
  302.         strcpy( pszPath, &chOther[2]);
  303.         return(0);
  304.         }
  305. }
  306.  
  307. USHORT HP_dosQCurDisk(PUSHORT pusDriveNum, PULONG pul)
  308. {
  309.     char chCurrent[MAX_PATH];
  310.     char ch;
  311.  
  312.     GetCurrentDirectory(MAX_PATH, chCurrent);
  313.     ch = toupper(chCurrent[0]);
  314.     *pusDriveNum = (0x007F & ch) - (0x007F & 'A') + 1;
  315.     *pul = GetLogicalDrives();
  316.     return(0);
  317.  
  318.     
  319. }
  320.  
  321. USHORT HP_dosSelectDisk(USHORT usDriveNum)
  322. {
  323.     char chOther[MAX_PATH];
  324.     char ch;
  325.  
  326.     strcpy( chOther, "A:");
  327.     ch = (char)(usDriveNum + (0x007F & 'A') - 1);
  328.     chOther[0] = ch;
  329.     SetCurrentDirectory(chOther);
  330.     return(0);
  331. }
  332.  
  333. HFONT HP_SimpleFont( LPCTSTR szFaceName, LONG size, LONG width, DWORD fs)
  334. {
  335.     LOGFONT lf;
  336.     lf.lfHeight = size;
  337.     lf.lfWidth = width;
  338.     lf.lfEscapement = 0;
  339.     lf.lfOrientation  = 0;
  340.     lf.lfWeight = (fs & FATTR_SEL_BOLD) ? FW_BOLD : FW_NORMAL;
  341.     lf.lfItalic = (fs & FATTR_SEL_ITALIC) ? TRUE : FALSE;
  342.     lf.lfUnderline = (fs & FATTR_SEL_UNDERSCORE) ? TRUE : FALSE;
  343.     lf.lfStrikeOut = (fs & FATTR_SEL_STRIKEOUT) ? TRUE : FALSE;
  344.     lf.lfCharSet = ANSI_CHARSET;
  345.     lf.lfOutPrecision = OUT_DEFAULT_PRECIS;
  346.     lf.lfClipPrecision = CLIP_DEFAULT_PRECIS;
  347.     lf.lfQuality       = DEFAULT_QUALITY;
  348.     lf.lfPitchAndFamily = DEFAULT_PITCH | FF_DONTCARE;
  349.     
  350.     strcpy( lf.lfFaceName, szFaceName);
  351.  
  352.      return(CreateFontIndirect(&lf));
  353.  
  354. }
  355.  
  356. void HP_RegisterClass(LPCTSTR pszClassName, PFN pfn, DWORD fs, int cb)
  357.     {
  358.     WNDCLASS wc;
  359.      ATOM     aClass;
  360.  
  361.     wc.lpfnWndProc   = (WNDPROC) pfn;
  362.     wc.cbClsExtra    = 0;
  363.     wc.cbWndExtra    = cb;
  364.     wc.hInstance     = hinst;
  365.     wc.hIcon         = LoadIcon(NULL, IDI_APPLICATION);
  366.     wc.hCursor       = LoadCursor(NULL, IDC_ARROW);
  367.     wc.hbrBackground = (HBRUSH) (COLOR_APPWORKSPACE + 1);
  368.     wc.lpszMenuName  = NULL;
  369.     wc.lpszClassName = pszClassName;
  370.     wc.style         = 0;
  371.     wc.style        |= (fs & HP_CS_SAVEBITS) ? CS_SAVEBITS : 0;
  372.     wc.style        |= (fs & HP_CS_SIZEREDRAW) ? (CS_HREDRAW | CS_VREDRAW) : 0;
  373.  
  374.      aClass = RegisterClass(&wc);
  375.      if (aClass == 0x0000)
  376.           fprintf( stderr, "RegisterClass Failure! \n" );
  377.  
  378.     }
  379.  
  380. HWND HP_CreateStdWindow(HWND hwndParent, DWORD flStyle1, LPDWORD pflStyle2,
  381.     LPCTSTR pszClass, LPCTSTR pszTitle, DWORD flStyle3, HMODULE hmod,
  382.     DWORD lpv, PHWND phwndClient)
  383.     {
  384.     DWORD dwStyle = 0;
  385.     HWND  hwnd;
  386.      DWORD flStyle2 = (pflStyle2) ? *pflStyle2 : 0;
  387.      HMENU hMenu;
  388.  
  389.     flStyle1 |= flStyle3;
  390.     dwStyle |= (flStyle1 & HP_FS_DLGBORDER ) ? WS_BORDER : 0;
  391.     dwStyle |= (flStyle1 & HP_FS_BORDER ) ? WS_BORDER : 0;
  392.     dwStyle |= (flStyle1 & HP_FS_SIZEBORDER ) ? WS_THICKFRAME : 0;
  393.     dwStyle |= (flStyle1 & HP_FS_STANDARD ) ? WS_OVERLAPPEDWINDOW : 0;
  394.     dwStyle |= (flStyle1 & HP_WS_VISIBLE ) ? WS_VISIBLE : 0;
  395.     dwStyle |= (flStyle1 & HP_WS_DISABLED ) ? WS_DISABLED : 0;
  396.     dwStyle |= (flStyle1 & HP_WS_CLIPCHILDREN ) ? WS_CLIPCHILDREN : 0;
  397.     dwStyle |= (flStyle1 & HP_WS_CLIPSIBLINGS ) ? WS_CLIPSIBLINGS : 0;
  398.     dwStyle |= (flStyle1 & HP_WS_MINIMIZED ) ? WS_MINIMIZE : 0;
  399.     dwStyle |= (flStyle1 & HP_WS_MAXIMIZED ) ? WS_MAXIMIZE : 0;
  400.     dwStyle |= (flStyle1 & HP_WS_GROUP ) ? WS_GROUP : 0;
  401.     dwStyle |= (flStyle1 & HP_WS_TABSTOP ) ? WS_TABSTOP : 0;
  402.     dwStyle |= (flStyle2 & HP_FCF_TITLEBAR ) ? WS_CAPTION : 0;
  403.     dwStyle |= (flStyle2 & HP_FCF_SYSMENU ) ? WS_SYSMENU : 0;
  404.     dwStyle |= (flStyle2 & HP_FCF_SIZEBORDER ) ? WS_THICKFRAME : 0;
  405.     dwStyle |= (flStyle2 & HP_FCF_MINBUTTON ) ? WS_MINIMIZEBOX : 0;
  406.     dwStyle |= (flStyle2 & HP_FCF_MAXBUTTON ) ? WS_MAXIMIZEBOX : 0;
  407.     dwStyle |= (flStyle2 & HP_FCF_VERTSCROLL ) ? WS_VSCROLL : 0;
  408.     dwStyle |= (flStyle2 & HP_FCF_HORZSCROLL ) ? WS_HSCROLL : 0;
  409.     dwStyle |= (flStyle2 & HP_FCF_DLGBORDER ) ? WS_BORDER : 0;
  410.     dwStyle |= (flStyle2 & HP_FCF_BORDER ) ? WS_BORDER : 0;
  411.     dwStyle |= (flStyle2 & HP_FCF_STANDARD ) ? WS_OVERLAPPED : 0;
  412.  
  413.      hMenu = LoadMenu(hinst, MAKEINTRESOURCE(lpv));
  414.  
  415.      try {
  416.          hwnd = CreateWindow(pszClass, pszTitle, dwStyle, CW_USEDEFAULT,
  417.                          CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
  418.                          hwndParent, hMenu, hinst, NULL);
  419.           }
  420.      except( EXCEPTION_EXECUTE_HANDLER)
  421.            {
  422.           fprintf( stderr, "CreateWindow Exception %ld\n", GetExceptionCode());
  423.           }
  424.  
  425.     if (phwndClient)
  426.         *phwndClient = hwnd;
  427.  
  428.     return(hwnd);
  429.     }
  430.  
  431. UINT HP_Message(HWND hwnd, UINT msg, WPARAM mp1, LPARAM mp2, UINT fSend)
  432. {
  433.     WPARAM wParam = mp1;
  434.     LPARAM lParam = mp2;
  435.     UINT   uRet;
  436.  
  437.     switch(msg)
  438.         {
  439.         case WM_SETICON:
  440.             SetClassLong(hwnd, GCL_HICON, mp1);
  441.             return(TRUE);
  442.             break;
  443.         case HP_SBM_SETPOS:
  444.             // Assume Vertical scroll bar.
  445.             SetScrollPos(hwnd, SB_VERT, LOWORD(mp1), TRUE);
  446.             return(TRUE);
  447.             break;
  448.         case HP_SBM_SETSCROLLBAR:
  449.             SetScrollRange(hwnd, SB_VERT, LOWORD(mp2), HIWORD(mp2), FALSE);
  450.             SetScrollPos(hwnd, SB_VERT, LOWORD(mp1), TRUE);
  451.             return(TRUE);
  452.             break;
  453.         case HP_SBM_QUERYPOS:
  454.             return(GetScrollPos(hwnd, SB_VERT));
  455.         case HP_SBM_QUERYRANGE:
  456.             {
  457.             DWORD dwLow, dwHigh;
  458.             GetScrollRange(hwnd, SB_VERT, &dwLow, &dwHigh);
  459.             return(MAKELONG(LOWORD(dwLow),LOWORD(dwHigh)));
  460.             }
  461.         case WM_CHAR:
  462.             {
  463.             PACKED_LONG pl;
  464.  
  465.             pl.dw = 0;
  466.  
  467.             wParam = 0x000000FF & CHAR1FROMMP(mp2);
  468.             pl.shl = CHAR3FROMMP(mp1);
  469.             pl.ch[2] = CHAR4FROMMP(mp1);
  470.             lParam = pl.dw;
  471.             }
  472.             break;
  473.  
  474.         case MM_SETITEMATTR:
  475.             {
  476.             USHORT idItem  = LOWORD(mp1);
  477.             USHORT usChg   = LOWORD(mp2);
  478.             USHORT usFlags = HIWORD(mp2);
  479.  
  480.             if (usChg & HP_MIA_CHECKED)
  481.                 {
  482.                 CheckMenuItem(GetMenu(hwnd), idItem, 
  483.                     (usFlags & HP_MIA_CHECKED) ? MF_CHECKED : MF_UNCHECKED);
  484.                 }
  485.             if (usChg & HP_MIA_HILITED)
  486.                 {
  487.                 HiliteMenuItem(hwnd, GetMenu(hwnd), idItem, 
  488.                     (usFlags & HP_MIA_HILITED) ? MF_HILITE : MF_UNHILITE);
  489.                 }
  490.             if (usChg & HP_MIA_DISABLED)
  491.                 {
  492.                 CheckMenuItem(GetMenu(hwnd), idItem, 
  493.                     (usFlags & HP_MIA_DISABLED) ? (MF_DISABLED | MF_GRAYED)
  494.                         : MF_ENABLED);
  495.                 }
  496.             }
  497.             break;
  498.         default:
  499.             break;
  500.         }
  501.  
  502.     if (fSend)
  503.         uRet = SendMessage(hwnd,msg,wParam,lParam);
  504.     else
  505.         uRet = PostMessage(hwnd,msg,wParam,lParam);
  506.  
  507.     return(uRet);
  508. }
  509.  
  510. UINT HP_DlgItemMessage(HWND hwnd, int idDlg, UINT msg, WPARAM mp1, LPARAM mp2)
  511. {
  512.     WPARAM wParam = mp1;
  513.     LPARAM lParam = mp2;
  514.     UINT   uRet;
  515.  
  516.     switch(msg)
  517.         {
  518.         case HP_LB_GETTEXT:
  519.             wParam = LOWORD(mp1);
  520.             break;
  521.         case HP_BM_GETSTATE:   // They just want the hilite!
  522.             {
  523.             UINT uState = SendDlgItemMessage(hwnd,idDlg,msg,wParam,lParam);
  524.             return((uState & 0x0004) ? TRUE : FALSE);
  525.             }
  526.         case HP_EM_GETMODIFY:
  527.             uRet = SendDlgItemMessage(hwnd,idDlg,msg,0,0);
  528.             SendDlgItemMessage(hwnd,idDlg, EM_SETMODIFY, FALSE, 0);
  529.             return(uRet);
  530.         case HP_EM_GETSEL:
  531.             {
  532.             DWORD dwLow, dwHigh;
  533.  
  534.             SendDlgItemMessage(hwnd,idDlg,msg,(DWORD)&dwLow,(DWORD)&dwHigh);
  535.             return(MAKELONG(LOWORD(dwLow),LOWORD(dwHigh)));
  536.             }
  537.         case HP_EM_SETSEL:
  538.             wParam = LOWORD(mp1);
  539.             lParam = HIWORD(mp1);
  540.             break;
  541.  
  542.         case HP_MLM_QUERYSEL:
  543.             {
  544.             DWORD dwLow, dwHigh;
  545.             SendDlgItemMessage(hwnd,idDlg,msg,(DWORD)&dwLow,(DWORD)&dwHigh);
  546.             switch( mp1)
  547.                 {
  548.                 case MLFQS_MINMAXSEL:
  549.                     return(MAKELONG(LOWORD(dwLow),LOWORD(dwHigh)));
  550.                 case MLFQS_CURSORSEL: // Incorrect, but we'll live.
  551.                 case MLFQS_ANCHORSEL:
  552.                 case MLFQS_MINSEL:
  553.                     return(dwLow);
  554.                 case MLFQS_MAXSEL:
  555.                     return(dwHigh);
  556.                 default:
  557.                     return(0);
  558.  
  559.                 }
  560.             }
  561.             break;
  562.  
  563.         case HP_LB_SELITEMRANGE:
  564.             wParam = mp2;
  565.             lParam = MAKELONG(LOWORD(mp1),LOWORD(mp1));
  566.             break;
  567.  
  568.         case HP_LM_SETITEMTEXT:
  569.             SendDlgItemMessage(hwnd,idDlg,LB_DELETESTRING,LOWORD(mp1),0);
  570.             SendDlgItemMessage(hwnd,idDlg,LB_INSERTSTRING,LOWORD(mp1),0);
  571.             return(TRUE);
  572.  
  573.         default:
  574.             break;
  575.         }
  576.  
  577.     uRet = SendDlgItemMessage(hwnd,idDlg,msg,wParam,lParam);
  578.  
  579.     return(uRet);
  580. }
  581.  
  582.  
  583. int HP_IsPtr( LPVOID lpv)
  584. {
  585.     char ch;
  586.     int  bPtr = TRUE;
  587.  
  588.     try
  589.         {
  590.         ch = *((char *) lpv);
  591.         }
  592.     except (EXCEPTION_EXECUTE_HANDLER)
  593.         {
  594.         bPtr = FALSE;
  595.         }
  596.  
  597.     return(bPtr);
  598. }
  599.  
  600. #define HP_RAM_SEM(lpv) ((LPDWORD)(lpv))
  601. #define HP_VALID_RAM_SEM(lpv) (*(HP_RAM_SEM(lpv)) == 0 || *(HP_RAM_SEM(lpv)) == 1)
  602.  
  603. DWORD HP_dosCreateSem(int bExclusive, LPHANDLE lph, LPCTSTR lpch)
  604. {
  605.     char chName[256];
  606.  
  607.     strcpy( chName, "sem_");
  608.  
  609.     lpch += 5;  // Skip over leading "\sem\"
  610.  
  611.     strcat( chName, lpch);
  612.     *lph = CreateSemaphore(NULL, 1, 1, chName);
  613.  
  614.     return( (*lph) ? 0 : GetLastError());
  615. }
  616.  
  617.  
  618. DWORD HP_dosOpenSem( LPHANDLE lph, LPCTSTR lpch, DWORD dwAccess)
  619. {
  620.     char chName[256];
  621.  
  622.     strcpy( chName, "sem_");
  623.  
  624.     lpch += 5;  // Skip over leading "\sem\"
  625.  
  626.     strcat( chName, lpch);
  627.     *lph = OpenSemaphore(dwAccess, TRUE, chName);
  628.  
  629.     return( (*lph) ? 0 : GetLastError());
  630. }
  631.  
  632. USHORT HP_dosSemClear(HANDLE lpv)
  633. {
  634.     DWORD dw;
  635.     if (HP_IsPtr((LPVOID)lpv) && HP_VALID_RAM_SEM(lpv))
  636.         {
  637.         EnterCriticalSection(&HP_cs_mutex);
  638.         dw = *(HP_RAM_SEM(lpv));
  639.         *(HP_RAM_SEM(lpv)) = 1;
  640.         if (dw != 1)
  641.             {
  642.             // This should release all waiting threads
  643.             SetEvent(HP_event_sem);
  644.  
  645.             // Reclose the door.  I assume everyone is free.
  646.             ResetEvent(HP_event_sem);
  647.             }
  648.         LeaveCriticalSection(&HP_cs_mutex);
  649.         return(0);
  650.         }
  651.  
  652. }
  653.  
  654. USHORT HP_dosSemSet(HANDLE lpv)
  655. {
  656.     if (HP_IsPtr((LPVOID)lpv) && HP_VALID_RAM_SEM(lpv))
  657.         {
  658.         EnterCriticalSection(&HP_cs_mutex);
  659.         *(HP_RAM_SEM(lpv)) = 0;
  660.         LeaveCriticalSection(&HP_cs_mutex);
  661.         return(0);
  662.         }
  663.  
  664. }
  665.  
  666.  
  667. USHORT HP_dosSemWait(HANDLE lpv, DWORD lTimeOut)
  668. {
  669.     DWORD dw;
  670.     DWORD dwRet;
  671.     DWORD dwRet2;
  672.  
  673.     if (HP_IsPtr((LPVOID)lpv) && HP_VALID_RAM_SEM(lpv))
  674.         {
  675.         EnterCriticalSection(&HP_cs_mutex);
  676.         dw = *(HP_RAM_SEM(lpv));
  677.         while (dw == 0)
  678.             {
  679.             LeaveCriticalSection(&HP_cs_mutex);
  680.  
  681.             // Warning, timeout reset on every loop!
  682.             dwRet = WaitForSingleObject(HP_event_sem, lTimeOut);
  683.             if (dwRet)
  684.                 return((USHORT) dwRet);
  685.  
  686.             EnterCriticalSection(&HP_cs_mutex);
  687.             dw = *(HP_RAM_SEM(lpv));
  688.             }
  689.  
  690.  
  691.         LeaveCriticalSection(&HP_cs_mutex);
  692.         return(0);
  693.         }
  694.  
  695.     else
  696.         {
  697.         do
  698.             {
  699.             dwRet  = WaitForSingleObject(lpv, lTimeOut);
  700.             dwRet2 = ReleaseSemaphore(lpv, 1, NULL);
  701.             } while (dwRet2 == FALSE);
  702.         }
  703. }
  704.  
  705.  
  706. USHORT HP_dosSemRequest(HANDLE lpv, DWORD lTimeOut)
  707. {
  708.     DWORD dw;
  709.     DWORD dwRet;
  710.  
  711.     if (HP_IsPtr((LPVOID)lpv) && HP_VALID_RAM_SEM(lpv))
  712.         {
  713.         EnterCriticalSection(&HP_cs_mutex);
  714.         dw = *(HP_RAM_SEM(lpv));
  715.         while (dw == 0)
  716.             {
  717.             LeaveCriticalSection(&HP_cs_mutex);
  718.  
  719.             // Warning, timeout reset on every loop!
  720.             dwRet = WaitForSingleObject(HP_event_sem, lTimeOut);
  721.             if (dwRet)
  722.                 return((USHORT) dwRet);
  723.  
  724.             EnterCriticalSection(&HP_cs_mutex);
  725.             dw = *(HP_RAM_SEM(lpv));
  726.             }
  727.  
  728.         *(HP_RAM_SEM(lpv)) = 0;
  729.  
  730.         LeaveCriticalSection(&HP_cs_mutex);
  731.         return(0);
  732.         }
  733.     else
  734.         {
  735.         return((USHORT) WaitForSingleObject(lpv, lTimeOut));
  736.         }
  737.  
  738. }
  739.  
  740. #define MAX_SEARCH 16
  741.  
  742. int iNumSearches = -1;
  743. typedef struct _ff
  744.     {
  745.     HANDLE  hSearch;
  746.     DWORD   dwAttr;
  747.     } HP_FIND;
  748.  
  749. HP_FIND hp_fSearches[MAX_SEARCH + 1];
  750.  
  751.  
  752. DWORD HP_dosFindFirst(LPTSTR pszSpec, LPDWORD ph, USHORT usAttr,
  753.     LPWIN32_FIND_DATA lpdata, USHORT usBufLen, PUSHORT pusCount)
  754. {
  755.  
  756.     int iCreate = (int) *ph;
  757.     HANDLE hFind;
  758.     DWORD  dwAttr = (DWORD) usAttr;
  759.     int    iMax = *pusCount;
  760.     int    ii = 0;
  761.     BOOL   bOk = TRUE;
  762.  
  763.  
  764.     if (iNumSearches == -1)
  765.         {
  766.         for (ii = 0; ii < (MAX_SEARCH + 1); ii++)
  767.             hp_fSearches[ii].hSearch = NULL;
  768.         ii = 0;
  769.         iNumSearches = 0;
  770.         }
  771.  
  772.  
  773.     if (sizeof(WIN32_FIND_DATA) * iMax > (DWORD) usBufLen)
  774.         iMax = usBufLen / sizeof(WIN32_FIND_DATA);
  775.  
  776.     if (iCreate == HDIR_SYSTEM && hp_fSearches[MAX_SEARCH].hSearch != NULL)
  777.         {
  778.         CloseHandle(hp_fSearches[MAX_SEARCH].hSearch);
  779.         hp_fSearches[MAX_SEARCH].hSearch = NULL;
  780.         }
  781.     else if ( iNumSearches == MAX_SEARCH)
  782.         {
  783.         return(0xFFFF);  // SHOULD be ERROR_NO_MORE_SEARCH_HANDLES
  784.         }
  785.  
  786.  
  787.     if (dwAttr == 0)
  788.         dwAttr = FILE_ATTRIBUTE_NORMAL;
  789.  
  790.     hFind = FindFirstFile( pszSpec, lpdata);
  791.  
  792.     if (hFind == NULL)
  793.         return(GetLastError());
  794.  
  795.     while (bOk && (ii < iMax))
  796.         {
  797.         if (lpdata->dwFileAttributes & dwAttr)
  798.             {
  799.             ii++;
  800.             lpdata++;
  801.             }
  802.  
  803.  
  804.         bOk = FindNextFile (hFind, lpdata);
  805.         if (bOk == FALSE && GetLastError() == ERROR_NO_MORE_FILES
  806.             && ii == 0)
  807.             return(ERROR_NO_MORE_FILES);
  808.  
  809.         }
  810.  
  811.     *pusCount = ii;
  812.  
  813.     if (iCreate == HDIR_SYSTEM)
  814.         {
  815.         hp_fSearches[MAX_SEARCH].hSearch = hFind;
  816.         hp_fSearches[MAX_SEARCH].dwAttr  = dwAttr;
  817.         *ph = MAX_SEARCH;
  818.         }
  819.     else
  820.         {
  821.         for (ii = 0; ii < MAX_SEARCH &&
  822.             hp_fSearches[ii].hSearch != NULL; ii++) ;
  823.  
  824.         hp_fSearches[ii].hSearch = hFind;
  825.         hp_fSearches[ii].dwAttr  = dwAttr;
  826.         *ph = ii;
  827.         iNumSearches++;
  828.         }
  829.  
  830.     return(0);
  831.  
  832. }
  833.  
  834. USHORT HP_dosFindNext(DWORD dw, LPWIN32_FIND_DATA lpdata,
  835.         USHORT usBufLen, PUSHORT pusCount)
  836. {
  837.  
  838.     HANDLE hFind;
  839.     DWORD  dwAttr;
  840.     int    iMax = *pusCount;
  841.     int    ii = 0;
  842.     BOOL   bOk = TRUE;
  843.  
  844.     if (sizeof(WIN32_FIND_DATA) * iMax > (DWORD) usBufLen)
  845.         iMax = usBufLen / sizeof(WIN32_FIND_DATA);
  846.  
  847.  
  848.     if (dw < 0 || dw > (MAX_SEARCH + 1))
  849.         return(ERROR_INVALID_HANDLE);
  850.  
  851.     hFind  = hp_fSearches[dw].hSearch;
  852.     dwAttr = hp_fSearches[dw].dwAttr;
  853.  
  854.     do
  855.         {
  856.         bOk = FindNextFile (hFind, lpdata);
  857.         if (bOk == FALSE && GetLastError() == ERROR_NO_MORE_FILES
  858.             && ii == 0)
  859.             return(ERROR_NO_MORE_FILES);
  860.  
  861.         if (lpdata->dwFileAttributes & dwAttr)
  862.             {
  863.             ii++;
  864.             lpdata++;
  865.             }
  866.  
  867.         } while (bOk && (ii < iMax));
  868.  
  869.  
  870.     *pusCount = ii;
  871.  
  872.     return(0);
  873.  
  874. }
  875.  
  876. USHORT HP_dosFindClose(DWORD dw)
  877. {
  878.     if (dw < 0 || dw > (MAX_SEARCH + 1))
  879.         return(ERROR_INVALID_HANDLE);
  880.  
  881.     CloseHandle(hp_fSearches[dw].hSearch);
  882.     hp_fSearches[dw].hSearch = NULL;
  883.  
  884.     if (dw != MAX_SEARCH)
  885.         iNumSearches--;
  886.  
  887.     return(0);
  888.  
  889. }
  890.  
  891. DWORD HP_dosNewSize(HANDLE h, DWORD dwSize)
  892. {
  893.     DWORD dwCurrent;
  894.  
  895.     dwCurrent = SetFilePointer(h, 0, NULL, FILE_CURRENT);
  896.     if (dwCurrent == NEG_ONE)
  897.         return(GetLastError());
  898.  
  899.     SetFilePointer(h, dwSize, NULL, FILE_CURRENT);
  900.     SetEndOfFile(h);
  901.     SetFilePointer(h, dwCurrent, NULL, FILE_BEGIN);
  902.     return(0);
  903. }
  904.  
  905. DWORD HP_dosFileLocks(HANDLE h, PFILELOCK pfUnlock, PFILELOCK pfLock)
  906. {
  907.     BOOL bOk = TRUE;
  908.  
  909.     if (pfUnlock)
  910.         bOk = UnlockFile(h, pfUnlock->lOffset, 0, pfUnlock->lRange, 0);
  911.  
  912.     if (bOk == FALSE)
  913.         return(GetLastError());
  914.  
  915.     if (pfLock)
  916.         bOk = LockFile(h, pfLock->lOffset, 0, pfLock->lRange, 0);
  917.  
  918.     if (bOk == FALSE)
  919.         return(GetLastError());
  920.  
  921.     return(0);
  922.  
  923. }
  924.  
  925. DWORD HP_dosMakePipe( LPHANDLE lpR, LPHANDLE lpW, USHORT us)
  926. {
  927.     return( CreatePipe(lpR, lpW, NULL, (DWORD) us) ? 0 : GetLastError());
  928. }
  929.  
  930. HP_dosError(USHORT f)
  931. {
  932.     UINT ufError = 0;
  933.  
  934.     if (f == HARDERROR_ENABLE)
  935.         ufError = SEM_FAILCRITICALERRORS | SEM_NOOPENFILEERRORBOX;
  936.  
  937.     SetErrorMode(ufError);
  938.     return(0);
  939. }
  940.  
  941. HP_dosLoadModule( LPCTSTR lpName, LPHANDLE ph)
  942. {
  943.     if (ph)
  944.         *ph = LoadLibrary(lpName);
  945.     else
  946.         return(1);
  947.     return(0);
  948. }
  949.  
  950. HP_dosGetModHandle( LPCTSTR lpName, LPHANDLE ph)
  951. {
  952.     if (ph == NULL)
  953.         return(-1);
  954.  
  955.     return( (*ph = GetModuleHandle(lpName)) ? 0 : GetLastError());
  956. }
  957.  
  958. HWND HP_winWindowFromID( HWND hwnd, USHORT usID)
  959. {
  960.     int id = usID;
  961.  
  962.     switch (id)
  963.         {
  964.         case FID_HORZSCROLL: 
  965.         case FID_VERTSCROLL: 
  966.         case FID_TITLEBAR: 
  967.         case FID_MINMAX:
  968.  
  969.            MessageBox(NULL, "Window Controls are not independent Windows",
  970.                 "OS/2 conversion Error", MB_ICONHAND | MB_OK);
  971.  
  972.             // FALL THRU
  973.         case FID_CLIENT:
  974.             return(hwnd);
  975.  
  976.         case FID_MENU:
  977.             return((HWND) GetMenu(hwnd));
  978.  
  979.         case FID_SYSMENU:
  980.             return((HWND) GetSystemMenu(hwnd, FALSE));
  981.  
  982.         default:
  983.             return(GetDlgItem(hwnd, id));
  984.  
  985.         }
  986. }
  987.  
  988.  
  989. BOOL  HP_Entry (HANDLE hDLL, DWORD dwReason, LPVOID lpReserved)
  990. { 
  991.   switch (dwReason)
  992.   { 
  993.   case DLL_PROCESS_ATTACH:
  994.         InitializeCriticalSection(&HP_cs_mutex);
  995.         HP_event_sem = CreateEvent(NULL, TRUE, FALSE, NULL);
  996.  
  997.       break;
  998.   case DLL_THREAD_ATTACH:
  999.       break;
  1000.   case DLL_THREAD_DETACH:
  1001.       break;
  1002.   case DLL_PROCESS_DETACH:
  1003.         DeleteCriticalSection(&HP_cs_mutex);
  1004.         CloseHandle(HP_event_sem);
  1005.       break;
  1006.   }
  1007.   return TRUE;
  1008.   UNREFERENCED_PARAMETER(hDLL);
  1009.   UNREFERENCED_PARAMETER(lpReserved);
  1010. }
  1011.  
  1012.