home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Windows Gam…ming Gurus (2nd Edition) / Disc2.iso / msdn_vcb / samples / vc98 / sdk / com / tutsamp / dcomdraw / dcomdraw.cpp next >
C/C++ Source or Header  |  1997-08-30  |  33KB  |  901 lines
  1. /*+==========================================================================
  2.   File:      DCOMDRAW.CPP
  3.  
  4.   Summary:   This client loads and accesses the Connectable SharePaper
  5.              component provided in a separate out-of-process COM Server
  6.              (DCDSERVE built in the sibling DCDSERVE directory). Thus to
  7.              run DCOMDRAW you must build DCDSERVE first. This client
  8.              application is meant to exercise the DCDSERVE out-of-process
  9.              server and to illustrate the use of a shared single COPaper
  10.              COM object in a remote server. Distributed COM (DCOM) is
  11.              used. The shared COPaper object can store its drawing data in
  12.              the structured storage of a single compound file.
  13.  
  14.              The COPaper object maintains logic and data to represent a
  15.              white sheet of free-form drawing paper. The behavior is much
  16.              like other C++ scribble code samples except that the
  17.              DCOMDRAW/DCDSERVE pair are implemented using custom COM
  18.              objects, interfaces, and standard COM services. The client
  19.              mouse activity is used to draw ink lines on the paper
  20.              surface. The COPaper object keeps a memory array of the Ink
  21.              data but performs no GUI display. This DCOMDRAW (largely
  22.              within the CGuiPaper object) manages the display of the
  23.              current drawing data.
  24.  
  25.              There is no GUI behavior in the server--it is all in this
  26.              client.  This client instantiates one instance of the
  27.              server's COPaper COM object and then allows the user to
  28.              use the mouse to draw lines in the client area of the
  29.              main window. If other clients are run they access the same
  30.              shared drawing even if the server requested is on a remote
  31.              machine. DCDSERVE registers its COPaper component so that
  32.              there is one shared drawing per machine.
  33.  
  34.              For a comprehensive tutorial code tour of DCOMDRAW's contents
  35.              and offerings see the tutorial DCOMDRAW.HTM file. For
  36.              more specific technical details on the internal workings see
  37.              the comments dispersed throughout the DCOMDRAW source code.
  38.              For more details on the DCDSERVE.DLL that DCOMDRAW works with
  39.              see the DCDSERVE.HTM file in the main tutorial directory.
  40.  
  41.   Classes:   CMainWindow.
  42.  
  43.   Functions: InitApplication, WinMain
  44.  
  45.   Origin:    8-23-97: atrent - Editor-inheritance from the CONCLIEN source.
  46.                [Revised]
  47.  
  48. ----------------------------------------------------------------------------
  49.   This file is part of the Microsoft COM Tutorial Code Samples.
  50.  
  51.   Copyright (C) Microsoft Corporation, 1997.  All rights reserved.
  52.  
  53.   This source code is intended only as a supplement to Microsoft
  54.   Development Tools and/or on-line documentation.  See these other
  55.   materials for detailed information regarding Microsoft code samples.
  56.  
  57.   THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY
  58.   KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  59.   IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
  60.   PARTICULAR PURPOSE.
  61. ==========================================================================+*/
  62.  
  63. /*--------------------------------------------------------------------------
  64.   We include WINDOWS.H for all Win32 applications.
  65.   We include OLE2.H because we will be calling the COM/OLE Libraries.
  66.   We include OLECTL.H because it has definitions for connectable objects.
  67.   We include INITGUID.H only once (here) in the entire app because we
  68.     will be defining GUIDs and want them as constants in the data segment.
  69.   We include COMMDLG.H because we will be using the Open File
  70.     and potentially other Common dialogs.
  71.   We include APPUTIL.H because we will be building this application using
  72.     the convenient Virtual Window and Dialog classes and other
  73.     utility functions in the APPUTIL Library (ie, APPUTIL.LIB).
  74.   We include PAPINT.H and PAPGUIDS.H for the common paper-related Interface
  75.     class, GUID, and CLSID specifications.
  76.   We include GUIPAPER.H because it has the C++ class used for GUI display
  77.     of the drawing paper.
  78.   We include DCOMDRAW.H because it has class and resource definitions
  79.     specific to this DCOMDRAW application.
  80. ---------------------------------------------------------------------------*/
  81. #include <windows.h>
  82. #include <ole2.h>
  83. #include <olectl.h>
  84. #include <initguid.h>
  85. #include <commdlg.h>
  86. #include <apputil.h>
  87. #include <papint.h>
  88. #include <papguids.h>
  89. #include "guipaper.h"
  90. #include "dcomdraw.h"
  91.  
  92.  
  93. // Here is a structure for storing the remote server info.
  94. COSERVERINFO g_ServerInfo;
  95. // Storage for the user entered remote machine name.
  96. TCHAR g_szMachineName[MAX_PATH] = TEXT("");
  97. OLECHAR g_wszMachineName[MAX_PATH];
  98.  
  99.  
  100. /*M+M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M
  101.   Method:   CMainWindow::CMainWindow
  102.  
  103.   Summary:  CMainWindow Constructor.
  104.  
  105.   Args:     .
  106.  
  107.   Returns:  .
  108. M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M-M*/
  109. CMainWindow::CMainWindow()
  110. {
  111.   // Ensure these member variable strings are null strings.
  112.   m_szFileName[0] = 0;
  113.  
  114.   // Fill in the Open File Name Common Dialog's OPENFILENAME structure.
  115.   m_ofnFile.lStructSize = sizeof(OPENFILENAME);
  116.   m_ofnFile.hwndOwner = m_hWnd;
  117.   m_ofnFile.hInstance = m_hInst;
  118.   m_ofnFile.lpstrFilter = TEXT(OFN_DEFAULTFILES_STR);
  119.   m_ofnFile.lpstrCustomFilter = NULL;
  120.   m_ofnFile.nMaxCustFilter = 0;
  121.   m_ofnFile.nFilterIndex = 1;
  122.   m_ofnFile.lpstrFile = m_szFileName;
  123.   m_ofnFile.nMaxFile = MAX_PATH;
  124.   m_ofnFile.lpstrInitialDir = TEXT(".");
  125.   m_ofnFile.lpstrFileTitle = m_szFileTitle;
  126.   m_ofnFile.nMaxFileTitle = MAX_PATH;
  127.   m_ofnFile.lpstrTitle = TEXT(OFN_DEFAULTTITLE_STR);
  128.   m_ofnFile.lpstrDefExt = NULL;
  129.   m_ofnFile.Flags = OFN_HIDEREADONLY;
  130.  
  131.   m_pMsgBox  = NULL;
  132.   m_pGuiPaper = NULL;
  133. }
  134.  
  135.  
  136. /*M+M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M
  137.   Method:   CMainWindow::~CMainWindow
  138.  
  139.   Summary:  CMainWindow Destructor.  Destruction of the main window
  140.             indicates that the application should quit and thus the
  141.             PostQuitMessage API is called.
  142.  
  143.   Args:     .
  144.  
  145.   Returns:  .
  146. M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M-M*/
  147. CMainWindow::~CMainWindow()
  148. {
  149.   // CMainWindow is derived from CVirWindow which traps the WM_DESTROY
  150.   // message and causes a delete of CMainWindow which in turn causes this
  151.   // destructor to run. The WM_DESTROY results when the window is destoyed
  152.   // after a close of the window. Prior to exiting the main message loop:
  153.  
  154.   // We delete the CGuiPaper and CMsgBox objects that were made in
  155.   // Initinstance.
  156.   DELETE_POINTER(m_pGuiPaper);
  157.   DELETE_POINTER(m_pMsgBox);
  158.  
  159.   // We then post a WM_QUIT message to cause an exit of the main
  160.   // message loop and an exit of this instance of the application.
  161.   PostQuitMessage(0);
  162. }
  163.  
  164.  
  165. /*M+M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M
  166.   Method:   CMainWindow::InitInstance
  167.  
  168.   Summary:  Instantiates an instance of the main application window.
  169.             This method must be called only once, immediately after
  170.             window class construction.  We take care to delete 'this'
  171.             CMainWindow if we must return the error condition FALSE.
  172.  
  173.   Args:     HINSTANCE hInstance,
  174.               Handle of the application instance.
  175.             LPSTR pszCmdLine,
  176.               Pointer to the application's invocation command line.
  177.             int nCmdShow)
  178.               Command to pass to ShowWindow.
  179.  
  180.   Modifies: m_szHelpFile, m_pMsgBox.
  181.  
  182.   Returns:  BOOL.
  183.               TRUE if succeeded.
  184.               FALSE if failed.
  185. M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M-M*/
  186. BOOL CMainWindow::InitInstance(
  187.        HINSTANCE hInstance,
  188.        LPSTR pszCmdLine,
  189.        int nCmdShow)
  190. {
  191.   BOOL bOk = FALSE;
  192.   HWND hWnd = NULL;
  193.   HRESULT hr = E_FAIL;
  194.  
  195.   // Create the Message Box and Message Log objects.
  196.   m_pMsgBox = new CMsgBox;
  197.  
  198.   // Create the CGuiPaper C++ object.
  199.   m_pGuiPaper = new CGuiPaper;
  200.  
  201.   if (NULL != m_pMsgBox && NULL != m_pGuiPaper)
  202.   {
  203.     // Note, the Create method sets the m_hWnd member so we don't
  204.     // need to set it explicitly here first. Here is the create of this
  205.     // window.  Size the window reasonably. Create sets both m_hInst and
  206.     // m_hWnd. This creates the main client window.
  207.     hWnd = Create(
  208.              TEXT(MAIN_WINDOW_CLASS_NAME_STR),
  209.              TEXT(MAIN_APP_NAME_STR),
  210.              WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX
  211.                | WS_MAXIMIZEBOX | WS_THICKFRAME,
  212.              CW_USEDEFAULT,
  213.              CW_USEDEFAULT,
  214.              ::GetSystemMetrics(SM_CXSCREEN)*2/5,
  215.              ::GetSystemMetrics(SM_CYSCREEN)*2/5,
  216.              NULL,
  217.              NULL,
  218.              hInstance);
  219.     if (NULL != hWnd)
  220.     {
  221.       // Init the new GuiPaper.
  222.       bOk = m_pGuiPaper->Init(m_hInst, m_hWnd);
  223.       if (bOk)
  224.       {
  225.         // Ensure the new window is shown on screen and content
  226.         // is painted.
  227.         ::ShowWindow(m_hWnd, nCmdShow);
  228.         ::UpdateWindow(m_hWnd);
  229.  
  230.         // Build a path to where the help file should be (it should be in
  231.         // the same directory as the .EXE but with the .HTM extension).
  232.         MakeFamilyPath(hInstance, m_szHelpFile, TEXT(HELP_FILE_EXT));
  233.  
  234.         // Init the Message Box object.
  235.         bOk = m_pMsgBox->Init(m_hInst, m_hWnd);
  236.  
  237.         // Connect the new Paper Sink in this client to receive event
  238.         // calls from a COPaper source in the server.
  239.         hr = m_pGuiPaper->ConnectPaperSink();
  240.         if (SUCCEEDED(hr))
  241.         {
  242.           // Lock the paper object for drawing by this client. Can't draw
  243.           // with mouse until doing this. Set the proper checkmark
  244.           // indicator on the menu selections as well.
  245.           hr = m_pGuiPaper->Lock(TRUE);
  246.           if (SUCCEEDED(hr))
  247.           {
  248.             // Try to load drawing data from local COPaper's compound file.
  249.             hr = m_pGuiPaper->Load();
  250.           }
  251.           else
  252.           {
  253.             // Shared drawing already loaded by another client.
  254.             // Paint this client's window with the shared drawing.
  255.             hr = m_pGuiPaper->PaintWin();
  256.           }
  257.         }
  258.       }
  259.     }
  260.   }
  261.  
  262.   bOk = SUCCEEDED(hr);
  263.  
  264.   if (!bOk)
  265.   {
  266.     DELETE_POINTER(m_pMsgBox);
  267.     DELETE_POINTER(m_pGuiPaper);
  268.   }
  269.  
  270.   return (bOk);
  271. }
  272.  
  273.  
  274. /*M+M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M
  275.   Method:   CMainWindow::DoMenu
  276.  
  277.   Summary:  Dispatch and handle the main menu commands.
  278.  
  279.   Args:     WPARAM wParam,
  280.               First message parameter (word sized).
  281.             LPARAM lParam)
  282.               Second message parameter (long sized).
  283.  
  284.   Modifies: m_ofnFile, ...
  285.  
  286.   Returns:  LRESULT
  287.               Standard Windows WindowProc return value.
  288. M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M-M*/
  289. LRESULT CMainWindow::DoMenu(
  290.           WPARAM wParam,
  291.           LPARAM lParam)
  292. {
  293.   LRESULT lResult = FALSE;
  294.   HRESULT hr;
  295.  
  296.   switch (LOWORD(wParam))
  297.   {
  298.     //----------------------------------------------------------------------
  299.     // Handle File Menu Commands.
  300.     //----------------------------------------------------------------------
  301.     case IDM_FILE_LOADREMOTE:
  302.       // Ask the user for the name of the machine where the remote
  303.       // DCDSERVE server is.
  304.       hr = m_pGuiPaper->LoadRemote();
  305.       if (FAILED(hr))
  306.         Beep(2000, 200);
  307.       break;
  308.     case IDM_FILE_LOADLOCAL:
  309.       // Ask COPaper to load the drawing from the local DCDSERVE server.
  310.       hr = m_pGuiPaper->LoadLocal();
  311.       if (FAILED(hr))
  312.         Beep(2000, 200);
  313.       break;
  314.     case IDM_FILE_SAVE:
  315.       // Ask COPaper to save the current shared drawing.
  316.       hr = E_FAIL;
  317.       if (m_pGuiPaper->Master())
  318.         hr = m_pGuiPaper->Save();
  319.       if (FAILED(hr))
  320.         Beep(2000, 200);
  321.       break;
  322.     case IDM_FILE_EXIT:
  323.       // The user commands us to exit this application so we tell the
  324.       // Main window to close itself.
  325.       ::PostMessage(m_hWnd, WM_CLOSE, 0, 0);
  326.       break;
  327.  
  328.     //----------------------------------------------------------------------
  329.     // Handle Draw Menu Choice Commands.
  330.     //----------------------------------------------------------------------
  331.     case IDM_DRAW_MASTER:
  332.       // Lock the paper object for drawing by this client. Can't draw
  333.       // with mouse until doing this. This makes this client the master
  334.       // client that currently owns the drawing. Drawing activity in the
  335.       // master is echoed to any other connected slave clients.
  336.       hr = E_FAIL;
  337.       if (!m_pGuiPaper->Master())
  338.         hr = m_pGuiPaper->Lock(TRUE);
  339.       if (FAILED(hr))
  340.         Beep(2000, 200);
  341.       break;
  342.     case IDM_DRAW_SLAVE:
  343.       // Unlock the paper object for drawing by this client. This
  344.       // makes this client a slave to a separate other master client.
  345.       hr = E_FAIL;
  346.       if (m_pGuiPaper->Master())
  347.         hr = m_pGuiPaper->Lock(FALSE);
  348.       if (FAILED(hr))
  349.         Beep(2000, 200);
  350.       break;
  351.     case IDM_DRAW_REDRAW:
  352.       // Ask Paper object to redraw its current content.
  353.       m_pGuiPaper->ClearWin();
  354.       m_pGuiPaper->PaintWin();
  355.       break;
  356.     case IDM_DRAW_ERASE:
  357.       // Ask Paper object to erase its current content and if it can
  358.       // Clear drawing display window.
  359.       hr = E_FAIL;
  360.       if (m_pGuiPaper->Master())
  361.         hr = m_pGuiPaper->Erase();
  362.       if (FAILED(hr))
  363.         Beep(2000, 200);
  364.       break;
  365.  
  366.     //----------------------------------------------------------------------
  367.     // Handle Pen Menu Commands.
  368.     //----------------------------------------------------------------------
  369.     case IDM_PEN_COLOR:
  370.       // Select Ink drawing color using ChooseColor common dialog.
  371.       hr = E_FAIL;
  372.       if (m_pGuiPaper->Master())
  373.       {
  374.         COLORREF crNewColor = m_pGuiPaper->PickColor();
  375.         hr = m_pGuiPaper->InkColor(crNewColor);
  376.       }
  377.       if (FAILED(hr))
  378.         Beep(2000, 200);
  379.       break;
  380.     case IDM_PEN_THIN:
  381.       // Select thin Ink width. Set menu check indicator.
  382.       hr = E_FAIL;
  383.       if (m_pGuiPaper->Master())
  384.         hr = m_pGuiPaper->InkWidth(INK_THIN);
  385.       if (FAILED(hr))
  386.         Beep(2000, 200);
  387.       break;
  388.     case IDM_PEN_MEDIUM:
  389.       // Select medium Ink width. Set menu check indicator.
  390.       hr = E_FAIL;
  391.       if (m_pGuiPaper->Master())
  392.         hr = m_pGuiPaper->InkWidth(INK_MEDIUM);
  393.       if (FAILED(hr))
  394.         Beep(2000, 200);
  395.       break;
  396.     case IDM_PEN_THICK:
  397.       // Select thick Ink width. Set menu check indicator.
  398.       hr = E_FAIL;
  399.       if (m_pGuiPaper->Master())
  400.         hr = m_pGuiPaper->InkWidth(INK_THICK);
  401.       if (FAILED(hr))
  402.         Beep(2000, 200);
  403.       break;
  404.  
  405.     //----------------------------------------------------------------------
  406.     // Handle Help Menu Commands.
  407.     //----------------------------------------------------------------------
  408.     case IDM_HELP_CONTENTS:
  409.       // We have some stubbed support here for bringing up the online
  410.       // Help for this application.
  411.       ReadHelp(m_hWnd, m_szHelpFile);
  412.       break;
  413.     case IDM_HELP_TUTORIAL:
  414.       // Call the APPUTIL utility function, ReadTutorial, to Browse the HTML
  415.       // tutorial narrative file associated with this tutorial code sample.
  416.       ReadTutorial(m_hInst, m_hWnd, TEXT(HTML_FILE_EXT));
  417.       break;
  418.     case IDM_HELP_TUTSERVER:
  419.       // Call the APPUTIL utility function, ReadTutorial, to Browse the HTML
  420.       // tutorial narrative file associated with the DCDSERVE COM server.
  421.       ReadTutorial(m_hInst, m_hWnd, TEXT(SERVER_TUTFILE_STR));
  422.       break;
  423.     case IDM_HELP_TUTMARSH:
  424.       // Call the APPUTIL utility function, ReadTutorial, to Browse the HTML
  425.       // tutorial narrative file associated with the DCDMARSH COM server.
  426.       ReadTutorial(m_hInst, m_hWnd, TEXT(MARSHAL_TUTFILE_STR));
  427.       break;
  428.     case IDM_HELP_READSOURCE:
  429.       // Call the APPUTIL utility function ReadSource to allow the
  430.       // user to open and read any of the source files of DCOMDRAW.
  431.       ReadSource(m_hWnd, &m_ofnFile);
  432.       break;
  433.     case IDM_HELP_ABOUT:
  434.       {
  435.         CAboutBox dlgAboutBox;
  436.  
  437.         // Show the standard About Box dialog for this EXE by telling the
  438.         // dialog C++ object to show itself by invoking its ShowDialog
  439.         // method.  Pass it this EXE instance and the parent window handle.
  440.         // Use a dialog resource ID for the dialog template stored in
  441.         // this EXE module's resources.
  442.         dlgAboutBox.ShowDialog(
  443.           m_hInst,
  444.           MAKEINTRESOURCE(IDM_HELP_ABOUT),
  445.           m_hWnd);
  446.       }
  447.       break;
  448.  
  449.     default:
  450.       // Defer all messages NOT handled here to the Default Window Proc.
  451.       lResult = ::DefWindowProc(m_hWnd, WM_COMMAND, wParam, lParam);
  452.       break;
  453.   }
  454.  
  455.   return(lResult);
  456. }
  457.  
  458.  
  459. /*M+M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M
  460.   Method:   CDlgLoadRemote::DialogProc
  461.  
  462.   Summary:  Dialog proc for the Remote Load dialog box.  This DialogProc
  463.             method definition overrides the same-named pure virtual
  464.             function in abstract base class CVirDialog thus giving unique
  465.             message dispatching behavior to this derivation of CVirDialog.
  466.             The remaining behavior of CDlgRemoteInfo is inherited from
  467.             CVirDialog and is common to all CVirDialogs.
  468.  
  469.   Args:     HWND hWndDlg,
  470.               Handle to the dialog.
  471.             UINT uMsg,
  472.               Windows message to dialog.
  473.             WPARAM wParam,
  474.               First message parameter (word sized).
  475.             LPARAM lParam)
  476.               Second message parameter (long sized).
  477.  
  478.   Returns:  BOOL.  TRUE if message was handled; FALSE otherwise.
  479. M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M-M*/
  480. BOOL CDlgLoadRemote::DialogProc(
  481.        HWND hWndDlg,
  482.        UINT uMsg,
  483.        WPARAM wParam,
  484.        LPARAM lParam)
  485. {
  486.   BOOL bResult = TRUE;
  487.   HWND hCtrl = GetDlgItem(hWndDlg, IDC_EDIT_MACHINE);
  488.  
  489.   switch (uMsg)
  490.   {
  491.     case WM_INITDIALOG:
  492.       SetDlgItemText(hWndDlg, IDC_EDIT_MACHINE, g_szMachineName);
  493.       SetFocus(hCtrl);
  494.       bResult = FALSE;
  495.       break;
  496.  
  497.     case WM_COMMAND:
  498.       {
  499.         WORD wCmd = LOWORD(wParam);
  500.  
  501.         if (wCmd == IDOK)
  502.         {
  503.           // Obtain the machine name from the edit control.
  504.           GetDlgItemText(hWndDlg, IDC_EDIT_MACHINE, g_szMachineName, MAX_PATH);
  505. #if !defined(UNICODE)
  506.           // Convert to WideChar Unicode if we are NOT compiled for Unicode.
  507.           AnsiToUc(g_szMachineName, g_wszMachineName, 0);
  508. #endif
  509.           ::EndDialog(hWndDlg, IDOK);
  510.         }
  511.         else if (wCmd == IDCANCEL)
  512.           ::EndDialog(hWndDlg, IDCANCEL);
  513.       }
  514.       break;
  515.  
  516.     default:
  517.       bResult = FALSE;
  518.       break;
  519.   }
  520.  
  521.   return(bResult);
  522. }
  523.  
  524.  
  525. /*M+M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M
  526.   Method:   CMainWindow::WindowProc
  527.  
  528.   Summary:  Main window procedure for this window object.  See CVirWindow
  529.             in the APPUTIL library (APPUTIL.CPP) for details on how this
  530.             method gets called by the global WindowProc.
  531.  
  532.   Args:     UINT uMsg,
  533.               Windows message that is "sent" to this window.
  534.             WPARAM wParam,
  535.               First message parameter (word sized).
  536.             LPARAM lParam)
  537.               Second message parameter (long sized).
  538.  
  539.   Returns:  LRESULT
  540.               Standard Windows WindowProc return value.
  541. M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M-M*/
  542. LRESULT CMainWindow::WindowProc(
  543.           UINT uMsg,
  544.           WPARAM wParam,
  545.           LPARAM lParam)
  546. {
  547.   LRESULT lResult = FALSE;
  548.  
  549.   switch (uMsg)
  550.   {
  551.     case WM_CREATE:
  552.       break;
  553.  
  554.     case WM_ACTIVATE:
  555.       // If we were newly activated by a mouse click then don't just sit
  556.       // there--re-paint. This is needed when another window was topped
  557.       // over part of DCOMDRAW and the user then topped DCOMDRAW using
  558.       // a mouse click on the visible part of DCOMDRAW. In any case let
  559.       // the windows default WindowProc handle this message to set
  560.       // keyboard focus to the newly active window.
  561.       if (WA_CLICKACTIVE == LOWORD(wParam))
  562.         m_pGuiPaper->PaintWin();
  563.       lResult = ::DefWindowProc(m_hWnd, uMsg, wParam, lParam);
  564.       break;
  565.  
  566.     case WM_MEASUREITEM:
  567.       // Get setup for painting text in this window. For later evolution.
  568.       {
  569.         LPMEASUREITEMSTRUCT lpmis = (LPMEASUREITEMSTRUCT) lParam;
  570.         lpmis->itemHeight = m_tm.tmHeight + m_tm.tmExternalLeading;
  571.         lpmis->itemWidth = m_lWidth;
  572.         lResult = TRUE;
  573.       }
  574.  
  575.     case WM_SIZE:
  576.       // Handle a resize of this window.
  577.       if (m_pGuiPaper->Master())
  578.       {
  579.         m_lWidth = LOWORD(lParam);
  580.         m_lHeight = HIWORD(lParam);
  581.         // Inform CGuiPaper of the change.
  582.         m_pGuiPaper->Resize(m_lWidth, m_lHeight);
  583.       }
  584.       break;
  585.  
  586.     case WM_PAINT:
  587.       // If something major happened repaint the whole window.
  588.       {
  589.         PAINTSTRUCT ps;
  590.  
  591.         if(BeginPaint(m_hWnd, &ps))
  592.         {
  593.           m_pGuiPaper->PaintWin();
  594.           EndPaint(m_hWnd, &ps);
  595.         }
  596.       }
  597.       break;
  598.  
  599.     case WM_LBUTTONDOWN:
  600.       // Start sequence of ink drawing to the paper.
  601.       if (m_pGuiPaper->Master())
  602.         m_pGuiPaper->InkStart(LOWORD(lParam), HIWORD(lParam));
  603.       break;
  604.  
  605.     case WM_MOUSEMOVE:
  606.       // Draw inking sequence data.
  607.       if (m_pGuiPaper->Master())
  608.         m_pGuiPaper->InkDraw(LOWORD(lParam), HIWORD(lParam));
  609.       break;
  610.  
  611.     case WM_LBUTTONUP:
  612.       // Stop an ink drawing sequence.
  613.       if (m_pGuiPaper->Master())
  614.         m_pGuiPaper->InkStop(LOWORD(lParam), HIWORD(lParam));
  615.       break;
  616.  
  617.     case WM_COMMAND:
  618.       // Dispatch and handle any Menu command messages received.
  619.       lResult = DoMenu(wParam, lParam);
  620.       break;
  621.  
  622.     case WM_CHAR:
  623.       if (wParam == 0x1b)
  624.       {
  625.         // Exit this app if user hits ESC key.
  626.         ::PostMessage(m_hWnd, WM_CLOSE, 0, 0);
  627.       }
  628.       break;
  629.  
  630.     case WM_CLOSE:
  631.       // The user selected Close on the main window's System menu
  632.       // or Exit on the File menu.
  633.       // If there is ink data that has not been saved then ask user
  634.       // if it should be saved. If user cancels then cancel the exit.
  635.       if (IDCANCEL == m_pGuiPaper->AskSave())
  636.         break;
  637.     case WM_QUIT:
  638.       // If the app is being quit then close any associated help windows.
  639.     default:
  640.       // Defer all messages NOT handled above to the Default Window Proc.
  641.       lResult = ::DefWindowProc(m_hWnd, uMsg, wParam, lParam);
  642.       break;
  643.   }
  644.  
  645.   return(lResult);
  646. }
  647.  
  648.  
  649. /*F+F++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  650.   Function: UnicodeOk
  651.  
  652.   Summary:  Checks if the platform will handle unicode versions of
  653.             Win32 string API calls.
  654.  
  655.   Args:     void
  656.  
  657.   Returns:  BOOL
  658.               TRUE if unicode support; FALSE if not.
  659. ------------------------------------------------------------------------F-F*/
  660. BOOL UnicodeOk(void)
  661. {
  662.   BOOL bOk = TRUE;
  663.   TCHAR szUserName[MAX_STRING_LENGTH];
  664.   DWORD dwSize = MAX_STRING_LENGTH;
  665.  
  666.   if (!GetUserName(szUserName, &dwSize))
  667.     bOk = ERROR_CALL_NOT_IMPLEMENTED == GetLastError() ? FALSE : TRUE;
  668.  
  669.   return bOk;
  670. }
  671.  
  672.  
  673. /*F+F+++F+++F+++F+++F+++F+++F+++F+++F+++F+++F+++F+++F+++F+++F+++F+++F+++F+++F
  674.   Function: InitApplication
  675.  
  676.   Summary:  Initializes the application and registers its main window
  677.             class. InitApplication is called only once (in WinMain).
  678.  
  679.   Args:     HINSTANCE hInstance)
  680.               Handle to the first instance of the application.
  681.  
  682.   Returns:  BOOL.
  683.               TRUE if success.
  684.               FALSE if fail.
  685. F---F---F---F---F---F---F---F---F---F---F---F---F---F---F---F---F---F---F-F*/
  686. BOOL InitApplication(
  687.        HINSTANCE hInstance)
  688. {
  689.   BOOL bOk;
  690.   // The window class for all instances of the main frame window.
  691.   WNDCLASSEX wcf;
  692.  
  693.   // Assign the appropriate values for this main frame window class.
  694.   wcf.cbSize        = sizeof(WNDCLASSEX);
  695.   wcf.cbClsExtra    = 0;            // No per-class extra data.
  696.   wcf.cbWndExtra    = 0;            // No per-window extra data.
  697.   wcf.hInstance     = hInstance;    // Application module instance.
  698.   wcf.lpfnWndProc   = &WindowProc;  // Global Window Procedure (defined in
  699.                                     // APPUTIL for all CVirWindows).
  700.   wcf.hCursor       = NULL;                        // Load app cursor.
  701.   wcf.hIcon         = (HICON) LoadIcon(            // Load app icon.
  702.                                 hInstance,
  703.                                 TEXT("AppIcon"));
  704.   wcf.hIconSm       = (HICON) LoadImage(           // Load small icon.
  705.                                 hInstance,
  706.                                 TEXT("AppIcon"),
  707.                                 IMAGE_ICON,
  708.                                 16, 16,
  709.                                 0);
  710.   wcf.hbrBackground = (HBRUSH) GetStockObject(WHITE_BRUSH); // Backgnd color.
  711.   wcf.style         = CS_HREDRAW | CS_VREDRAW | CS_OWNDC; // Class style(s).
  712.   wcf.lpszClassName = TEXT(MAIN_WINDOW_CLASS_NAME_STR);   // Class name.
  713.   wcf.lpszMenuName  = TEXT(MAIN_WINDOW_CLASS_MENU_STR);   // Menu name.
  714.  
  715.   // Register the window class and return FALSE if unsuccesful.
  716.   bOk = RegisterClassEx(&wcf);
  717.  
  718.   // Zero the g_ServerInfo structure.
  719.   memset(&g_ServerInfo, 0, sizeof(COSERVERINFO));
  720.  
  721.   // Init the remote machine name.
  722.   g_wszMachineName[0] = 0;
  723. #ifdef UNICODE
  724.   g_ServerInfo.pwszName = &g_szMachineName[0];
  725. #else
  726.   g_ServerInfo.pwszName = &g_wszMachineName[0];
  727. #endif
  728.  
  729.   return (bOk);
  730. }
  731.  
  732.  
  733. /*F+F+++F+++F+++F+++F+++F+++F+++F+++F+++F+++F+++F+++F+++F+++F+++F+++F+++F+++F
  734.   Function: WinMain
  735.  
  736.   Summary:  The Windows main entry point function for this application.
  737.             Initializes the application, the COM Libraries, and starts
  738.             the main application message loop.
  739.  
  740.   Args:     HINSTANCE hInstance,
  741.               Instance handle; a new one for each invocation of this app.
  742.             HINSTANCE hPrevInstance,
  743.               Instance handle of the previous instance. NULL in Win32.
  744.             LPSTR pszCmdLine,
  745.               Windows passes a pointer to the application's
  746.               invocation command line.
  747.             int nCmdShow)
  748.               Bits telling the show state of the application.
  749.  
  750.   Returns:  int
  751.               msg.wParam (upon exit of message loop).
  752.               FALSE if this instance couldn't initialize and run.
  753. F---F---F---F---F---F---F---F---F---F---F---F---F---F---F---F---F---F---F-F*/
  754. extern "C" int PASCAL WinMain(
  755.                         HINSTANCE hInstance,
  756.                         HINSTANCE hPrevInstance,
  757.                         LPSTR pszCmdLine,
  758.                         int nCmdShow)
  759. {
  760.   CMainWindow* pWin = NULL;
  761.   MSG msg;
  762.   HACCEL hAccel;
  763.   HRESULT hr;
  764.   int iRun = FALSE;
  765.  
  766.   // If we were compiled for UNICODE and the platform seems OK with this
  767.   // then proceed.  Else we error and exit the app.
  768.   if (UnicodeOk())
  769.   {
  770.     // Call to initialize the COM Library.  Use the SUCCEEDED macro
  771.     // to detect success.  If fail then exit app with error message.
  772.     // Tell COM that this client process will use the Single Threaded
  773.     // Apartment model.
  774.     if (SUCCEEDED(CoInitialize(NULL)))
  775.     {
  776.       // Ensure that DCOM (Distributed COM) is installed.
  777.       if (DComOk())
  778.       {
  779.         // Initialize for Client process security. Allow COPaper to
  780.         // call back into the client (ie, the client can impersonate
  781.         // the server identity).
  782.         hr = CoInitializeSecurity(
  783.                NULL,                        //Points to security descriptor
  784.                -1,                          //Count of entries in asAuthSvc
  785.                NULL,                        //Array of names to register
  786.                NULL,                        //Reserved for future use
  787.                RPC_C_AUTHN_LEVEL_NONE,      //Default authentication level
  788.                                             // for proxies
  789.                RPC_C_IMP_LEVEL_IMPERSONATE, //Default impersonation level
  790.                                             // for proxies
  791.                NULL,                        //Reserved; must be set to NULL
  792.                EOAC_NONE,                   //Additional client or
  793.                                             // server-side capabilities
  794.                NULL);                       //Reserved for future use
  795.         if (SUCCEEDED(hr))
  796.         {
  797.           // If we succeeded in initializing the COM Library we proceed to
  798.           // initialize the application.  If we can't init the application
  799.           // then we signal shut down with an error message exit.
  800.           iRun = InitApplication(hInstance);
  801.           if (iRun)
  802.           {
  803.             // Assume we'll set iRun to TRUE when initialization is done.
  804.             iRun = FALSE;
  805.             // We are still go for running so we try to create a nifty new
  806.             // CMainWindow object for this app instance.
  807.             pWin = new CMainWindow;
  808.             if (NULL != pWin)
  809.             {
  810.               // Now we initialize an instance of the new CMainWindow.
  811.               // This includes creating the main window.
  812.               if (pWin->InitInstance(hInstance, pszCmdLine, nCmdShow))
  813.               {
  814.                 // Load the keyboard accelerators from the resources.
  815.                 hAccel = LoadAccelerators(hInstance, TEXT("AppAccel"));
  816.                 if (NULL != hAccel)
  817.                 {
  818.                   // Signal App Initialization is successfully done.
  819.                   iRun = TRUE;
  820.                 }
  821.               }
  822.             }
  823.           }
  824.         }
  825.  
  826.         if (iRun)
  827.         {
  828.           // If we initialized the app instance properly then we are still
  829.           // go for running.  We then start up the main message pump for
  830.           // the application.
  831.           while (GetMessage(&msg, NULL, 0, 0))
  832.           {
  833.             if (!TranslateAccelerator(pWin->GetHwnd(), hAccel, &msg))
  834.             {
  835.               TranslateMessage(&msg);
  836.               DispatchMessage(&msg);
  837.             }
  838.           }
  839.  
  840.           // We also ask COM to unload any unused COM Servers, including our
  841.           // friend, DCDSERVE.
  842.           CoFreeUnusedLibraries();
  843.  
  844.           // We'll pass to Windows the reason why we exited the message loop.
  845.           iRun = msg.wParam;
  846.         }
  847.         else
  848.         {
  849.           // We failed to initialize the application. Put up error message
  850.           // box saying that application couldn't be initialized.  Parent
  851.           // window is desktop (ie, NULL). Exit the failed application
  852.           // (ie, by returning FALSE to WinMain).
  853.           ErrorBox(hInstance, NULL, IDS_APPINITFAILED);
  854.  
  855.           // Delete the CMainWindow object.
  856.           DELETE_POINTER(pWin);
  857.         }
  858.  
  859.         // We're exiting this app (either normally or by init failure) so
  860.         // shut down the COM Library.
  861.         CoUninitialize();
  862.       }
  863.       else
  864.       {
  865.         // If DCOM isn't installed then indicate an error
  866.         // and exit the app immediately.
  867.         ErrorBox(hInstance, NULL, IDS_NODCOM);
  868.       }
  869.     }
  870.     else
  871.     {
  872.       // We failed to Initialize the COM Library. Put up error message
  873.       // box saying that COM Library couldn't be initialized.  Parent
  874.       // window is desktop (ie, NULL). Exit the failed application
  875.       // (ie, by returning FALSE to WinMain).
  876.       ErrorBox(hInstance, NULL, IDS_COMINITFAILED);
  877.     }
  878.   }
  879.   else
  880.   {
  881.     // If we were compiled for UNICODE but the platform has problems with
  882.     // this then indicate an error and exit the app immediately.
  883.     CHAR szMsg[MAX_STRING_LENGTH];
  884.  
  885.     if (LoadStringA(
  886.           hInstance,
  887.           IDS_NOUNICODE,
  888.           szMsg,
  889.           MAX_STRING_LENGTH))
  890.     {
  891.       MessageBoxA(
  892.         NULL,
  893.         szMsg,
  894.         ERROR_TITLE_STR,
  895.         MB_OK | MB_ICONEXCLAMATION);
  896.     }
  897.   }
  898.  
  899.   return iRun;
  900. }
  901.