home *** CD-ROM | disk | FTP | other *** search
/ Programming Windows 95 / Programming Windows 95.iso / code / CHAP20 / CALLPUB.C < prev    next >
Encoding:
C/C++ Source or Header  |  1996-01-01  |  14.4 KB  |  381 lines
  1. /*---------------------------------------------
  2.    CALLPUB.C -- Call into public OLE component
  3.                 (c) Paul Yao, 1996
  4.   ---------------------------------------------*/
  5. #include <windows.h>
  6. #include <initguid.h>
  7. #include "pubmem.h"
  8. #include "callpub.h"
  9.  
  10. LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM) ;
  11.  
  12. char szWndClass[] = "CallerWindow" ;
  13. char szAppName[]  = "Calls Public Malloc" ;
  14.  
  15. //-------------------------------------------------------------------
  16. int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, 
  17.                     PSTR lpszCmdLine, int cmdShow)       
  18.      {
  19.      HWND        hwnd ;
  20.      MSG         msg ;
  21.      WNDCLASSEX  wc ;
  22.  
  23.      wc.cbSize        = sizeof (wc) ;
  24.      wc.lpszClassName = szWndClass ;
  25.      wc.hInstance     = hInstance ;
  26.      wc.lpfnWndProc   = WndProc ;
  27.      wc.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
  28.      wc.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
  29.      wc.lpszMenuName  = "MAIN" ;
  30.      wc.hbrBackground = (HBRUSH) (COLOR_WINDOW + 1) ;
  31.      wc.style         = 0 ;
  32.      wc.cbClsExtra    = 0 ;
  33.      wc.cbWndExtra    = 0 ;
  34.      wc.hIconSm       = LoadIcon (NULL, IDI_APPLICATION) ;
  35.  
  36.      RegisterClassEx (&wc) ;
  37.  
  38.      hwnd = CreateWindowEx (0L, szWndClass, szAppName,
  39.                             WS_OVERLAPPEDWINDOW,  
  40.                             CW_USEDEFAULT, CW_USEDEFAULT,
  41.                             CW_USEDEFAULT, CW_USEDEFAULT,
  42.                             NULL, NULL, hInstance, NULL) ;
  43.      ShowWindow (hwnd, cmdShow) ;
  44.      UpdateWindow (hwnd) ;
  45.  
  46.      // Connect to OLE libraries
  47.      HRESULT hr = CoInitialize (NULL) ;
  48.      if (FAILED (hr))
  49.           {
  50.           // Fail app initialization
  51.           return FALSE ;
  52.           }
  53.  
  54.      while (GetMessage (&msg, NULL, 0, 0))
  55.           {
  56.           TranslateMessage (&msg) ; 
  57.           DispatchMessage (&msg) ;  
  58.           }
  59.  
  60.      // Disconnect from OLE libraries
  61.      CoUninitialize () ;
  62.  
  63.      return msg.wParam ;
  64.      }
  65.  
  66. //-------------------------------------------------------------------
  67. LRESULT CALLBACK
  68. WndProc (HWND hwnd, UINT iMsg, WPARAM wParam, LPARAM lParam) 
  69.      {
  70.      static int       iCurLine = 0 ;
  71.      static LPMALLOC  pMalloc = NULL ;
  72.      static LPSTR     szLine[10] ;
  73.      static RECT      rHit[10] ;
  74.  
  75.      switch (iMsg)
  76.           {
  77.           case WM_CREATE :
  78.                // Initialize data pointer array
  79.                ZeroMemory (szLine, sizeof (szLine)) ;
  80.                return 0 ;
  81.  
  82.           case WM_COMMAND :
  83.                switch (LOWORD (wParam))
  84.                     {
  85.                     case IDM_CREATE :
  86.                          {
  87.                          HRESULT hr = 
  88.                               CoCreateInstance (CLSID_ALLOCATOR,
  89.                                                 NULL,
  90.                                                 CLSCTX_INPROC_SERVER,
  91.                                                 IID_IMalloc,
  92.                                                 (void **) &pMalloc) ;
  93.    
  94.                          if (FAILED (hr))
  95.                               {
  96.                               MessageBox (hwnd, "Error: No allocator",
  97.                                           szAppName, MB_OK) ;
  98.                               return 0 ;
  99.                               }
  100.  
  101.                          InvalidateRect (hwnd, NULL, TRUE) ;
  102.                          return 0 ;
  103.                          }
  104.  
  105.                     case IDM_DESTROY :
  106.                          {
  107.                          int i ;
  108.  
  109.                          // Mark allocated blocks as invalid
  110.                          for (i = 0 ; i < 10 ; i++)
  111.                               {
  112.                               if ((szLine[i] != NULL) &&
  113.                                   (pMalloc->lpVtbl->DidAlloc (pMalloc,
  114.                                                               szLine[i])))
  115.                                    {
  116.                                    szLine[i] = NULL ;
  117.                                    }
  118.                               }
  119.  
  120.                          // Disconnect from & free allocator
  121.                          pMalloc->lpVtbl->Release (pMalloc) ;
  122.                          pMalloc = NULL ;
  123.  
  124.                          InvalidateRect (hwnd, NULL, TRUE) ;
  125.                          return 0 ;
  126.                          }
  127.  
  128.                     case IDM_IUNKNOWN :
  129.                          {
  130.                          LPUNKNOWN pUnk ;
  131.                          HRESULT hr =
  132.                               pMalloc->lpVtbl->QueryInterface (pMalloc,
  133.                                                                IID_IUnknown, 
  134.                                                                (void **) &pUnk) ;
  135.                          if (SUCCEEDED (hr))
  136.                               {
  137.                               pUnk->lpVtbl->Release (pUnk) ;
  138.                               MessageBox (hwnd, "IUnknown supported", 
  139.                                           szAppName, MB_OK) ;
  140.                               }
  141.                          else
  142.                               {
  143.                               MessageBox (hwnd, "IUnknown not supported", 
  144.                                           szAppName, MB_OK) ;
  145.                               }
  146.                          return 0 ;
  147.                          }
  148.  
  149.                     case IDM_IMALLOC :
  150.                          {
  151.                          LPUNKNOWN pUnk ;
  152.                          HRESULT hr =
  153.                               pMalloc->lpVtbl->QueryInterface (pMalloc,
  154.                                                                IID_IMalloc, 
  155.                                                                (void **) &pUnk) ;
  156.                                             
  157.                          if (SUCCEEDED (hr))
  158.                               {
  159.                               pUnk->lpVtbl->Release (pUnk) ;
  160.                               MessageBox (hwnd, "IMalloc supported", 
  161.                                           szAppName, MB_OK) ;
  162.                               }
  163.                          else
  164.                               {
  165.                               MessageBox (hwnd, "IMalloc not supported", 
  166.                                           szAppName, MB_OK) ;
  167.                               }
  168.                          return 0 ;
  169.                          }
  170.  
  171.                      case IDM_IMARSHAL :
  172.                           {
  173.                           LPUNKNOWN pUnk ;
  174.                           HRESULT hr =
  175.                                pMalloc->lpVtbl->QueryInterface (pMalloc,
  176.                                                                 IID_IMarshal, 
  177.                                                                 (void **) &pUnk) ;
  178.                           if (SUCCEEDED (hr))
  179.                                {
  180.                                pUnk->lpVtbl->Release (pUnk) ;
  181.                                MessageBox (hwnd, "IMarshal supported",
  182.                                            szAppName, MB_OK) ;
  183.                                }
  184.                           else
  185.                                {
  186.                                MessageBox (hwnd, "IMarshal not supported",
  187.                                            szAppName, MB_OK) ;
  188.                                }
  189.                           return 0 ;
  190.                           }
  191.  
  192.                     case IDM_ALLOCATE_CUSTOM :
  193.                          if (szLine[iCurLine] != NULL)
  194.                               {
  195.                               MessageBox (hwnd, "Error: Free First", 
  196.                                           szAppName, MB_OK) ;
  197.                               return 0 ;
  198.                               }
  199.  
  200.                          // Allocate from IMalloc interface
  201.                          szLine[iCurLine] = 
  202.                               (char *) pMalloc->lpVtbl->Alloc (pMalloc, 100) ;
  203.                          lstrcpy (szLine[iCurLine], "*IMalloc memory*") ;
  204.  
  205.                          InvalidateRect (hwnd, NULL, TRUE) ;
  206.                          return 0 ;
  207.  
  208.                     case IDM_ALLOCATE_DEFAULT :
  209.                          if (szLine[iCurLine] != NULL)
  210.                               {
  211.                               MessageBox (hwnd, "Error: Free First", 
  212.                                           szAppName, MB_OK) ;
  213.                               return 0 ;
  214.                               }
  215.  
  216.                          // Allocate from default heap
  217.                          szLine[iCurLine] = (char *) malloc (100) ;
  218.                          lstrcpy (szLine[iCurLine], "-Malloc memory-") ;
  219.  
  220.                          InvalidateRect (hwnd, NULL, TRUE) ;
  221.                          return 0 ;
  222.  
  223.                     case IDM_FREE :
  224.                          if (szLine[iCurLine] == NULL)
  225.                               {
  226.                               MessageBox (hwnd, "Error: Nothing to free", 
  227.                                           szAppName, MB_OK) ;
  228.                               return 0 ;
  229.                               }
  230.  
  231.                          if (pMalloc == NULL)
  232.                               {
  233.                               goto FreeMalloc ;
  234.                               }
  235.  
  236.                          // Free allocated object
  237.                          if (pMalloc->lpVtbl->DidAlloc (pMalloc,
  238.                                                         szLine[iCurLine]))
  239.                               {
  240.                               pMalloc->lpVtbl->Free (pMalloc,
  241.                                                      szLine[iCurLine]) ;
  242.                               }
  243.                          else
  244.                               {
  245.                FreeMalloc:
  246.                               free (szLine[iCurLine]) ;
  247.                               }
  248.  
  249.                          szLine[iCurLine] = NULL ;
  250.  
  251.                          InvalidateRect (hwnd, NULL, TRUE) ;
  252.                          return 0 ;
  253.                     }
  254.  
  255.           case WM_DESTROY :
  256.                // Disconnect from & free allocator
  257.                if (pMalloc)
  258.                     {
  259.                     pMalloc->lpVtbl->Release (pMalloc) ;
  260.                     pMalloc = NULL ;
  261.                     }
  262.  
  263.                PostQuitMessage (0) ;  // Handle application shutdown
  264.                return 0 ;
  265.  
  266.           case WM_INITMENU :
  267.                {
  268.                HMENU hMenu = (HMENU) wParam ;
  269.                if (pMalloc)
  270.                     {
  271.                     EnableMenuItem (hMenu, IDM_CREATE,          MF_GRAYED) ;
  272.                     EnableMenuItem (hMenu, IDM_DESTROY,         MF_ENABLED) ;
  273.                     EnableMenuItem (hMenu, IDM_ALLOCATE_CUSTOM, MF_ENABLED) ;
  274.                     EnableMenuItem (hMenu, IDM_IUNKNOWN,        MF_ENABLED) ;
  275.                     EnableMenuItem (hMenu, IDM_IMALLOC,         MF_ENABLED) ;
  276.                     EnableMenuItem (hMenu, IDM_IMARSHAL,        MF_ENABLED) ;
  277.                     }
  278.                else
  279.                     {
  280.                     EnableMenuItem(hMenu, IDM_CREATE,          MF_ENABLED) ;
  281.                     EnableMenuItem(hMenu, IDM_DESTROY,         MF_GRAYED) ;
  282.                     EnableMenuItem(hMenu, IDM_ALLOCATE_CUSTOM, MF_GRAYED) ;
  283.                     EnableMenuItem(hMenu, IDM_IUNKNOWN,        MF_GRAYED) ;
  284.                     EnableMenuItem(hMenu, IDM_IMALLOC,         MF_GRAYED) ;
  285.                     EnableMenuItem(hMenu, IDM_IMARSHAL,        MF_GRAYED) ;
  286.                     }
  287.                return 0 ;
  288.                }
  289.  
  290.           case WM_LBUTTONDOWN :
  291.                {
  292.                int i ;
  293.                int x = LOWORD (lParam) ;
  294.                int y = HIWORD (lParam) ;
  295.                POINT pt = { x, y } ;
  296.  
  297.                for (i = 0 ; i < 10 ; i++)
  298.                     {
  299.                     if (PtInRect (&rHit[i], pt))
  300.                          {
  301.                          if (iCurLine != i)  // Minimize screen blink
  302.                               {
  303.                               InvalidateRect (hwnd, &rHit[iCurLine], TRUE) ;
  304.                               InvalidateRect (hwnd, &rHit[i], TRUE) ;
  305.                               iCurLine = i ;
  306.                               }
  307.                          break ;
  308.                          }    
  309.                     }
  310.                return 0 ;
  311.                }
  312.  
  313.           case WM_PAINT :
  314.                {
  315.                char         szBuff[10] ;
  316.                COLORREF     crText, crBack ;
  317.                HDC          hdc ;
  318.                int          cc ;
  319.                int          i ;
  320.                int          XCount, XText, Y ;
  321.                int          cyLineHeight ;
  322.                PAINTSTRUCT  ps ;
  323.                RECT         rOpaque ;
  324.                TEXTMETRIC   tm ;
  325.  
  326.                hdc = BeginPaint (hwnd, &ps) ;
  327.  
  328.                // Fetch line height
  329.                GetTextMetrics (ps.hdc, &tm) ;
  330.                cyLineHeight = tm.tmHeight + tm.tmExternalLeading ;
  331.  
  332.                // Fetch current text colors
  333.                crText = GetTextColor (ps.hdc) ;
  334.                crBack = GetBkColor (ps.hdc) ;
  335.  
  336.                XCount = tm.tmAveCharWidth * 3 ;
  337.                XText  = XCount + tm.tmAveCharWidth * 7 ;
  338.                Y      = tm.tmHeight ;
  339.  
  340.                for (i = 0 ; i < 10 ; i++, Y += cyLineHeight)
  341.                     {
  342.                     // Set colors to highlight current line
  343.                     if (i == iCurLine)
  344.                          {
  345.                          SetTextColor (ps.hdc, crBack) ;
  346.                          SetBkColor (ps.hdc, crText) ;
  347.  
  348.                          SetRect (&rOpaque, 0, Y, 9999, Y + cyLineHeight) ;
  349.                          ExtTextOut(ps.hdc, 0, 0, ETO_OPAQUE, &rOpaque,
  350.                                     NULL, 0, NULL ) ;
  351.                          }
  352.                     else
  353.                          {
  354.                          SetTextColor (ps.hdc, crText) ;
  355.                          SetBkColor (ps.hdc, crBack) ;
  356.                          }
  357.  
  358.                     // Display line count
  359.                     cc = wsprintf (szBuff, "Line %d", i) ;
  360.                     TextOut (ps.hdc, XCount, Y, szBuff, cc) ;
  361.  
  362.                     // Display text if a string has been defined
  363.                     if (szLine[i] != NULL)
  364.                          {
  365.                          cc = lstrlen (szLine[i]) ;
  366.                          TextOut (ps.hdc, XText, Y, szLine[i], cc) ;
  367.                          }
  368.  
  369.                     // Calculate hit test rectangle
  370.                     SetRect (&rHit[i], 0, Y, 9999, Y + cyLineHeight) ;
  371.                     }
  372.  
  373.                EndPaint (hwnd, &ps) ;
  374.                return 0 ;
  375.                }
  376.  
  377.           default :
  378.                return DefWindowProc (hwnd, iMsg, wParam, lParam) ;
  379.           }
  380.      }
  381.