home *** CD-ROM | disk | FTP | other *** search
/ Borland Programmer's Resource / Borland_Programmers_Resource_CD_1995.iso / code / tkern10 / src / tkfmangr.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-05-19  |  4.9 KB  |  231 lines
  1. /*
  2.  *  This file forms part of "TKERN" - "Troy's Kernel for Windows".
  3.  *
  4.  *  This library is free software; you can redistribute it and/or
  5.  *  modify it under the terms of the GNU Library General Public
  6.  *  License as published by the Free Software Foundation; either
  7.  *  version 2 of the License, or (at your option) any later version.
  8.  *
  9.  *  This library is distributed in the hope that it will be useful,
  10.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12.  *  Library General Public License for more details.
  13.  *
  14.  *  You should have received a copy of the GNU Library General Public
  15.  *  License along with this library; if not, write to the Free
  16.  *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17.  */
  18.  
  19. #include <windows.h>
  20. #include <toolhelp.h>
  21. #include <sys/tdevice.h>
  22. #include <sys/tfile.h>
  23.  
  24. extern    void    tkern_seterrno(int, int);
  25. extern    void    tkern_register_manager(HWND);
  26. extern    void    tkern_kill_ok(void);
  27. extern    void    tkern_program_dead(HTASK, int);
  28. extern    void    tkern_program_started(HTASK);
  29.  
  30. HINSTANCE    hInstance;
  31. int    nLocks = 0;    // The number of things which must be freed before
  32.             // we can exit
  33. int    nError = 0;
  34. BOOL    bTriedToExit = FALSE;
  35.  
  36. void
  37. LockManager(void)
  38. {
  39.     nLocks++;
  40. }
  41.  
  42. void
  43. UnlockManager(void)
  44. {
  45.     nLocks--;
  46.     if (!nLocks && bTriedToExit)
  47.     {
  48.         bTriedToExit = FALSE;
  49.         tkern_kill_ok();
  50.     }
  51. }
  52.  
  53. int
  54. GetMessages(void)
  55. {
  56.     MSG    msg;
  57.  
  58.     if (!GetMessage(&msg, 0, 0, 0))
  59.         return 0;
  60.     TranslateMessage(&msg);
  61.     DispatchMessage(&msg);
  62.     return 1;
  63. }
  64.  
  65. void
  66. FlushMessages(void)
  67. {
  68.     MSG    msg;
  69.  
  70.     while (PeekMessage(&msg, 0, 0, 0, PM_REMOVE))
  71.     {
  72.         TranslateMessage(&msg);
  73.         DispatchMessage(&msg);
  74.     }
  75. }
  76.  
  77. LRESULT    CALLBACK _export
  78. CommsWindowProc(HWND    hWnd,
  79.         UINT    wMsg,
  80.         WPARAM    wParam,
  81.         LPARAM    lParam)
  82. {
  83.     struct    tfunc    *ptf = (struct tfunc *) lParam;
  84.     int        idFile = wParam;
  85.     LONG    nResult;
  86.  
  87.     nError = 0;
  88.  
  89.     switch(wMsg)
  90.     {
  91.     case TKWM_OPEN:
  92.         nResult =  (*dev_list[ptf->iDevice].open_strat)
  93.                 (ptf->achFile,
  94.                  ptf->nMode,
  95.                  ptf->nAccess);
  96.         tkern_seterrno(nError, ptf->iTask);
  97.         return nResult;
  98.  
  99.     case TKWM_CLOSE:
  100.         nResult =  (*dev_list[ptf->iDevice].close_strat) (idFile);
  101.         tkern_seterrno(nError, ptf->iTask);
  102.         return nResult;
  103.  
  104.     case TKWM_SEEK:
  105.         nResult =  (*dev_list[ptf->iDevice].seek_strat)
  106.                 (idFile,
  107.                  ptf->nPosition,
  108.                  ptf->nFrom);
  109.         tkern_seterrno(nError, ptf->iTask);
  110.         return nResult;
  111.  
  112.     case TKWM_READ:
  113.         nResult =  (*dev_list[ptf->iDevice].read_strat)
  114.                 (idFile,
  115.                  ptf->achBuffer,
  116.                  ptf->nBytes);
  117.         tkern_seterrno(nError, ptf->iTask);
  118.         return nResult;
  119.  
  120.     case TKWM_WRITE:
  121.         nResult =  (*dev_list[ptf->iDevice].write_strat)
  122.                 (idFile,
  123.                  ptf->achBuffer,
  124.                  ptf->nBytes);
  125.         tkern_seterrno(nError, ptf->iTask);
  126.         return nResult;
  127.  
  128.     case TKWM_IOCTL:
  129.         nResult =  (*dev_list[ptf->iDevice].ioctl_strat) (idFile,
  130.                                   &ptf->tki);
  131.         tkern_seterrno(nError, ptf->iTask);
  132.         return nResult;
  133.  
  134.     case TKWM_GETDEVNO:
  135.         nResult =  get_device_number(ptf->achFile);
  136.         tkern_seterrno(nError, ptf->iTask);
  137.         return nResult;
  138.  
  139.     case TKWM_ISATTY:
  140.         nResult = (dev_list[ptf->iDevice].flags & DF_TTY) ? 1 : 0;
  141.         tkern_seterrno(nError, ptf->iTask);
  142.         return nResult;
  143.  
  144.     case TKWM_ALLDONE:
  145.         if (nLocks)
  146.             bTriedToExit = TRUE;
  147.         else
  148.             PostQuitMessage(0);
  149.         return 1;
  150.  
  151.     default:
  152.         return DefWindowProc(hWnd, wMsg, wParam, lParam);
  153.     }
  154. }
  155.  
  156. BOOL    CALLBACK _export
  157. NotifyProc(    WORD    wID,
  158.         DWORD    dwData)
  159. {
  160.     NFYRIP    *prip;
  161.  
  162.     switch(wID)
  163.     {
  164.     case NFY_EXITTASK:
  165.         tkern_program_dead(GetCurrentTask(), LOWORD(dwData));
  166.         break;
  167.  
  168.     case NFY_STARTTASK:
  169.         tkern_program_started(GetCurrentTask());
  170.         break;
  171.     }
  172.     return FALSE;
  173. }
  174.  
  175. #pragma argsused
  176. int    far    pascal
  177. WinMain(HINSTANCE hInstance,
  178.     HINSTANCE hPrec,
  179.     LPSTR    lpCmdLine,
  180.     int    nShow)
  181. {
  182.     MSG    msg;
  183.     WNDCLASS wc;
  184.     HWND    hWnd;
  185.     LPFNNOTIFYCALLBACK lpfnNotify;
  186.     char    achBuffer[80];
  187.  
  188.     wc.style = CS_GLOBALCLASS |
  189.            CS_HREDRAW |
  190.            CS_VREDRAW;
  191.     wc.lpfnWndProc = CommsWindowProc;
  192.     wc.cbClsExtra = 0;
  193.     wc.cbWndExtra = 0;
  194.     wc.hInstance = hInstance;
  195.     wc.hIcon = LoadIcon(hInstance, "TKERN_ICO");
  196.     wc.hCursor = 0;
  197.     wc.hbrBackground = (HBRUSH) (COLOR_WINDOW + 1);
  198.     wc.lpszMenuName = 0;
  199.     wc.lpszClassName = "Troy's Kernel Comms";
  200.     RegisterClass(&wc);
  201.  
  202.     hWnd = CreateWindow(    "Troy's Kernel Comms",
  203.                 "TKERN Communications",
  204.                 WS_OVERLAPPEDWINDOW,
  205.                 CW_USEDEFAULT,
  206.                 0,
  207.                 CW_USEDEFAULT,
  208.                 0,
  209.                 0,
  210.                 0,
  211.                 hInstance,
  212.                 0
  213.             );
  214.  
  215.     tkern_register_manager(hWnd);
  216.  
  217.     FlushMessages(); // If this isn't done, the NotifyRegister below, while
  218.              // returning success, just doesn't work.
  219.  
  220.     lpfnNotify = (LPFNNOTIFYCALLBACK) MakeProcInstance((FARPROC) NotifyProc, hInstance);
  221.     NotifyRegister(GetCurrentTask(), lpfnNotify, NF_TASKSWITCH);
  222.  
  223.     while(GetMessages());
  224.  
  225.     NotifyUnRegister(GetCurrentTask());
  226.     FreeProcInstance((FARPROC) lpfnNotify);
  227.     DestroyWindow(hWnd);
  228.  
  229.     return 0;
  230. }
  231.