home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 10 / 10.iso / m / m003_1 / sb_bc.ddi / BC / CH5 / WINAPP-5.CPP < prev    next >
Encoding:
C/C++ Source or Header  |  1991-12-10  |  10.1 KB  |  438 lines
  1. /***              Windows Application 5                ***/
  2. /***                                                   ***/
  3. /***              WINAPP-5 includes                    ***/
  4. /***                       (1) WINAPP-5.CPP            ***/
  5. /***                       (2) WINAPP-5.DEF            ***/
  6.  
  7. #pragma hdrfile "windows.sym"
  8. #include <windows.h>
  9. #pragma hdrstop
  10.  
  11. #include"winapp-2.h"
  12.  
  13. #ifndef min
  14. #define min(a,b)            (((a) < (b)) ? (a) : (b))
  15. #endif
  16.  
  17. #ifndef max
  18. #define max(a,b)            (((a) > (b)) ? (a) : (b))
  19. #endif
  20.  
  21. // Declaration
  22.  
  23. long FAR PASCAL _export AppWndProc (HWND, WORD, WORD, LONG) ;
  24.  
  25.  
  26. class Main
  27. { public:
  28.     static HANDLE hInstance ;
  29.     static HANDLE hPrevInstance ;
  30.     static int    nCmdShow ;
  31.  
  32.     static int MessageLoop(void) ;
  33. } ;
  34.  
  35. HANDLE Main::hInstance = 0 ;
  36. HANDLE Main::hPrevInstance = 0 ;
  37. int    Main::nCmdShow = 0 ;
  38.  
  39. int Main::MessageLoop(void)
  40. { MSG msg ;
  41.  
  42.   while ( GetMessage(&msg, NULL, 0, 0) )
  43.     { TranslateMessage(&msg) ;
  44.       DispatchMessage(&msg) ;
  45.     }
  46.   return msg.wParam ;
  47. }
  48.  
  49.  
  50. ////////// Base Class -> Window
  51. //////////
  52. class Window
  53. { protected:
  54.     HWND hwnd ;
  55.  
  56.   public:
  57.     HWND GetHandle(void)     // get the window handle in the class
  58.     { return hwnd ; }
  59.  
  60.     BOOL Show(int nCmdShow)
  61.     { return ShowWindow(hwnd,nCmdShow) ; }
  62.  
  63.     void Update(void)
  64.     { UpdateWindow(hwnd) ; }
  65.  
  66.     virtual long CreateProc(HWND hwnd,
  67.                 WORD wParam, LONG lParam) = 0 ;
  68.  
  69.     virtual long AppWndProc(WORD message,
  70.                 WORD wParam, LONG lParam) = 0 ;
  71. } ;
  72.  
  73.  
  74. class ScrollBar : public Window
  75. { private :
  76.     int nBar ;
  77.     short int nMax, nPos, nInc ;
  78.  
  79.   public :
  80.  
  81.     inline void Init(HWND hWnd, int bar)
  82.     { hwnd = hWnd ;
  83.       nBar = bar ;
  84.     }
  85.  
  86.     inline short int Get_nMax(void)
  87.     { return nMax ; }
  88.  
  89.     inline short int Get_nPos(void)
  90.     { return nPos ; }
  91.  
  92.     inline short int Get_nInc(void)
  93.     { return nInc ; }
  94.  
  95.     inline void Set_nMax(short int m)
  96.     { nMax = m ; }
  97.  
  98.     inline void Set_nPos(short int p)
  99.     { nPos = p ; }
  100.  
  101.     inline void Set_nInc(short int i)
  102.     { nInc = i ; }
  103.  
  104.     inline void SetRange(BOOL bRedraw)
  105.     { SetScrollRange(hwnd, nBar, 0, nMax, bRedraw) ; }
  106.  
  107.     inline void SetPos(BOOL bRedraw)
  108.     { SetScrollPos(hwnd, nBar, nPos, bRedraw) ; }
  109.  
  110.     inline void ScrollWin(int XAmount, int YAmount)
  111.     { ScrollWindow(hwnd, XAmount, YAmount, NULL, NULL) ; }
  112.  
  113.     virtual long CreateProc(HWND hwnd,
  114.                 WORD wParam, LONG lParam) = 0 ;
  115.  
  116.     virtual long AppWndProc(WORD message,
  117.                 WORD wParam, LONG lParam) = 0 ;
  118. } ;
  119.  
  120.  
  121. ////////// Derived Class -> MainWindow
  122. //////////
  123. class MainWindow : public Window
  124. { private:
  125.     static char szAppName[8] ;
  126.     struct { short int cxChar, cyChar, cxCaps, nMaxX ; } FontSize ;
  127.  
  128.     ScrollBar VSB, HSB ;
  129.  
  130.   public :
  131.     static void Register(void) ;
  132.     MainWindow(void) ;              // constructor
  133.  
  134.     virtual long CreateProc(HWND hwnd,
  135.                 WORD wParam, LONG lParam) ;
  136.  
  137.     virtual long AppWndProc(WORD message,
  138.                 WORD wParam, LONG lParam) ;
  139. } ;
  140.  
  141. char MainWindow::szAppName[] = "WinApp5" ;
  142.  
  143. void MainWindow::Register(void)
  144. { WNDCLASS wndclass ;
  145.  
  146.   wndclass.style      = CS_HREDRAW | CS_VREDRAW ;
  147.   wndclass.lpfnWndProc      = ::AppWndProc ;
  148.   wndclass.cbClsExtra       = 0 ;
  149.   wndclass.cbWndExtra      = sizeof(MainWindow *) ;
  150.   wndclass.hInstance       = Main::hInstance ;
  151.   wndclass.hIcon      = LoadIcon(NULL,IDI_APPLICATION) ;
  152.   wndclass.hCursor      = LoadCursor(NULL,IDC_ARROW) ;
  153.   wndclass.hbrBackground  = GetStockObject(WHITE_BRUSH) ;
  154.   wndclass.lpszMenuName      = NULL ;
  155.   wndclass.lpszClassName  = szAppName ;
  156.  
  157.   RegisterClass(&wndclass) ;
  158. }
  159.  
  160. MainWindow::MainWindow(void)
  161. {
  162.   hwnd = CreateWindow(szAppName,                // window class name
  163.               "Windows Application 2",  // window caption
  164.               WS_OVERLAPPEDWINDOW |
  165.               WS_VSCROLL |
  166.               WS_HSCROLL ,         // window style
  167.               CW_USEDEFAULT,       // initial x position
  168.               0,                   // initial y position
  169.               CW_USEDEFAULT,       // initial x length
  170.               0,                   // initial y length
  171.               NULL,                // parent window handle
  172.               NULL,                // window menu handle
  173.               Main::hInstance,     // program instance handle
  174.               (LPSTR) this) ;      // parameters , different
  175.                        //   from WINAPP-2
  176.   Show(Main::nCmdShow) ;
  177.   Update() ;
  178. }
  179.  
  180.  
  181. //  special case
  182.  
  183. #pragma argsused
  184. long MainWindow::CreateProc(HWND hwnd,
  185.                 WORD wParam, LONG lParam)
  186. { HDC hdc ;
  187.   TEXTMETRIC tm ;
  188.  
  189.   hdc = GetDC(hwnd) ;
  190.  
  191.   GetTextMetrics(hdc,&tm) ;
  192.   FontSize.cxChar = tm.tmAveCharWidth ;
  193.   FontSize.cyChar = tm.tmHeight + tm.tmExternalLeading ;
  194.   FontSize.cxCaps = (tm.tmPitchAndFamily & 1 ? 3 : 2) *
  195.             FontSize.cxChar / 2 ;
  196.  
  197.   ReleaseDC(hwnd,hdc) ;
  198.  
  199.   FontSize.nMaxX = 20 * FontSize.cxCaps + 45 * FontSize.cxChar ;
  200.  
  201.   HSB.Init(hwnd, SB_HORZ) ;
  202.   VSB.Init(hwnd, SB_VERT) ;
  203.  
  204.   return 0L ;
  205. }
  206.  
  207.  
  208. long MainWindow::AppWndProc(WORD message,
  209.                 WORD wParam, LONG lParam)
  210. { HDC hdc ;
  211.   PAINTSTRUCT ps ;
  212.  
  213.   static short int cxClient, cyClient ;
  214.  
  215.   short int nBeginLine, nEndLine ;
  216.   short int i,x,y ;
  217.  
  218.   switch (message)
  219.     { case WM_SIZE :
  220.        cxClient = LOWORD(lParam) ;
  221.        cyClient = HIWORD(lParam) ;
  222.  
  223.        VSB.Set_nMax(max(0, NUMLINE+2-cyClient/FontSize.cyChar));
  224.        VSB.Set_nPos( min(VSB.Get_nMax(),VSB.Get_nPos()) ) ;
  225.        VSB.SetRange(FALSE) ;
  226.        VSB.SetPos(TRUE) ;
  227.  
  228.        HSB.Set_nMax( max(0, (FontSize.nMaxX-cxClient) /
  229.                 FontSize.cxChar+2) ) ;
  230.        HSB.Set_nPos( min(HSB.Get_nMax(),HSB.Get_nPos()) ) ;
  231.        HSB.SetRange(FALSE) ;
  232.        HSB.SetPos(TRUE) ;
  233.  
  234.        break ;
  235.  
  236.  
  237.       case WM_VSCROLL :
  238.        switch (wParam)
  239.          { case SB_TOP :
  240.             VSB.Set_nInc(VSB.Get_nInc() - VSB.Get_nPos()) ;
  241.             break ;
  242.  
  243.            case SB_BOTTOM :
  244.             VSB.Set_nInc(VSB.Get_nMax() - VSB.Get_nPos()) ;
  245.             break ;
  246.  
  247.            case SB_LINEUP :
  248.             VSB.Set_nInc(-1) ;
  249.             break ;
  250.  
  251.            case SB_LINEDOWN :
  252.             VSB.Set_nInc(1) ;
  253.             break ;
  254.  
  255.            case SB_PAGEUP :
  256.             VSB.Set_nInc(min(-1,-cyClient/FontSize.cyChar) );
  257.             break ;
  258.  
  259.            case SB_PAGEDOWN :
  260.             VSB.Set_nInc(max(1,cyClient/FontSize.cyChar) );
  261.             break ;
  262.  
  263.            case SB_THUMBTRACK :
  264.             VSB.Set_nInc(LOWORD(lParam)-VSB.Get_nPos()) ;
  265.             break ;
  266.  
  267.            default :
  268.             VSB.Set_nInc(0) ;
  269.             break ;
  270.          }
  271.  
  272.        VSB.Set_nInc(min(VSB.Get_nInc() ,
  273.                 VSB.Get_nMax()-VSB.Get_nPos()) ) ;
  274.        VSB.Set_nInc(max(VSB.Get_nInc() ,
  275.                 -VSB.Get_nPos()) ) ;
  276.  
  277.        if (VSB.Get_nInc())
  278.           { VSB.Set_nPos(VSB.Get_nPos() + VSB.Get_nInc() ) ;
  279.         VSB.ScrollWin(0, -FontSize.cyChar*VSB.Get_nInc()) ;
  280.         VSB.SetPos(TRUE) ;
  281.         Update() ;
  282.           }
  283.        break ;
  284.  
  285.  
  286.       case WM_HSCROLL :
  287.        switch (wParam)
  288.          { case SB_TOP :
  289.             HSB.Set_nInc(HSB.Get_nInc() - HSB.Get_nPos()) ;
  290.             break ;
  291.  
  292.            case SB_BOTTOM :
  293.             HSB.Set_nInc(HSB.Get_nMax() - HSB.Get_nPos()) ;
  294.             break ;
  295.  
  296.            case SB_LINEUP :
  297.             HSB.Set_nInc(-1) ;
  298.             break ;
  299.  
  300.            case SB_LINEDOWN :
  301.             HSB.Set_nInc(1) ;
  302.             break ;
  303.  
  304.            case SB_PAGEUP :
  305.             HSB.Set_nInc(min(-1,-cxClient/FontSize.cxChar)) ;
  306.             break ;
  307.  
  308.            case SB_PAGEDOWN :
  309.             HSB.Set_nInc(max(1,cxClient/FontSize.cxChar)) ;
  310.             break ;
  311.  
  312.            case SB_THUMBTRACK :
  313.             HSB.Set_nInc(LOWORD(lParam)-HSB.Get_nPos()) ;
  314.             break ;
  315.  
  316.            default :
  317.             HSB.Set_nInc(0) ;
  318.             break ;
  319.          }
  320.  
  321.        HSB.Set_nInc(min(HSB.Get_nInc() ,
  322.                 HSB.Get_nMax()-HSB.Get_nPos()) ) ;
  323.        HSB.Set_nInc(max(HSB.Get_nInc() ,
  324.                 -HSB.Get_nPos()) ) ;
  325.  
  326.        if (HSB.Get_nInc())
  327.           { HSB.Set_nPos(HSB.Get_nPos() + HSB.Get_nInc() ) ;
  328.         HSB.ScrollWin(-FontSize.cxChar*HSB.Get_nInc(), 0) ;
  329.         HSB.SetPos(TRUE) ;
  330.         Update() ;
  331.           }
  332.        break ;
  333.  
  334.  
  335.       case WM_PAINT :
  336.        hdc = BeginPaint(hwnd, &ps) ;
  337.  
  338.        nBeginLine = max(0,VSB.Get_nPos() + ps.rcPaint.top /
  339.                            FontSize.cyChar - 1) ;
  340.        nEndLine = min(NUMLINE,VSB.Get_nPos() + ps.rcPaint.bottom/
  341.                            FontSize.cyChar) ;
  342.  
  343.        for (i=nBeginLine ; i<nEndLine ; i++)
  344.          { x = FontSize.cxChar * (1-HSB.Get_nPos()) ;
  345.            y = FontSize.cyChar * (1-VSB.Get_nPos()+i) ;
  346.  
  347.            TextOut(hdc, x, y,
  348.                WinStruct[i].szStruct,
  349.                lstrlen(WinStruct[i].szStruct)) ;
  350.  
  351.            TextOut(hdc, x+20*FontSize.cxCaps, y,
  352.                WinStruct[i].szDescriptor,
  353.                lstrlen(WinStruct[i].szDescriptor)) ;
  354.          }
  355.  
  356.        EndPaint(hwnd, &ps) ;
  357.        break ;
  358.  
  359.  
  360.       case WM_DESTROY :
  361.        PostQuitMessage(0) ;
  362.        break ;
  363.  
  364.  
  365.       default :
  366.        return DefWindowProc(hwnd, message, wParam, lParam) ;
  367.     }
  368.  
  369.   return 0L ;
  370. }
  371.  
  372.  
  373. #if defined(__SMALL__) || defined(__MEDIUM__)
  374. inline Window *GetPointer( HWND hWnd )
  375. {
  376.     return (Window *) GetWindowWord( hWnd, 0 );
  377. }
  378. inline void SetPointer( HWND hWnd, Window *pWindow )
  379. {
  380.     SetWindowWord( hWnd, 0, (WORD) pWindow );
  381. }
  382.  
  383. // else pointers are far
  384. #elif defined(__LARGE__) || defined(__COMPACT__)
  385. inline Window *GetPointer( HWND hWnd )
  386. {
  387.     return (Window *) GetWindowLong( hWnd, 0 );
  388. }
  389. inline void SetPointer( HWND hWnd, Window *pWindow )
  390. {
  391.     SetWindowLong( hWnd, 0, (LONG) pWindow );
  392. }
  393.  
  394. #else
  395.     #error Choose another memory model!
  396. #endif
  397.  
  398.  
  399. long FAR PASCAL _export AppWndProc (HWND hwnd,   WORD message,
  400.                     WORD wParam, LONG lParam)
  401. { Window *pWindow = GetPointer( hwnd );
  402.  
  403.   if ( pWindow == 0 )
  404.      { if ( message == WM_CREATE )
  405.       { LPCREATESTRUCT lpcs;
  406.  
  407.         lpcs = (LPCREATESTRUCT) lParam;
  408.         pWindow = (Window *) lpcs->lpCreateParams;
  409.  
  410.         SetPointer(hwnd,pWindow);
  411.  
  412.         return pWindow->CreateProc(hwnd, wParam, lParam);
  413.       }
  414.        else return DefWindowProc(hwnd, message, wParam, lParam);
  415.      }
  416.   else return pWindow->AppWndProc(message, wParam, lParam);
  417. }
  418.  
  419.  
  420. #pragma argsused
  421.  
  422. #pragma option -w-aus
  423.  
  424. int PASCAL WinMain(HANDLE hInstance,
  425.            HANDLE hPrevInstance,
  426.            LPSTR  lpszCmdLine,
  427.            int    nCmdShow)
  428. { Main::hInstance = hInstance ;
  429.   Main::hPrevInstance = hPrevInstance ;
  430.   Main::nCmdShow = nCmdShow ;
  431.  
  432.   if (! Main::hPrevInstance) MainWindow::Register() ;
  433.  
  434.   MainWindow mainwindow ;
  435.  
  436.   return Main::MessageLoop() ;
  437. }
  438.