home *** CD-ROM | disk | FTP | other *** search
/ PC Press 1997 July / Sezamfile97_2.iso / windows / program / activex / axtsamp.exe / TSBRANCH.EXE / LOCSERVE / LOCSERVE.CPP < prev    next >
C/C++ Source or Header  |  1996-12-29  |  35KB  |  1,045 lines
  1. /*+==========================================================================
  2.   File:      LOCSERVE.CPP
  3.  
  4.   Summary:   Based largely on the DLLCLIEN.EXE source code, this
  5.              module implements the main framework for an Win32 .EXE
  6.              application.  This application is meant to run hidden as a
  7.              local COM server that offers the Car, UtilityCar, and
  8.              CruiseCar components.  Though this local server offers a
  9.              simple main window and menu system these are not seen during
  10.              normal operation.  This server can be run stand-alone for
  11.              debugging purposes by explicitly using the -embedding command
  12.              line switch and invoking LOCSERVE prior to the client.
  13.  
  14.              This local server supports self-registration and this module
  15.              recognizes the -RegServer and -UnregServer command line
  16.              switches and has the appropriate functions (RegisterServer
  17.              and UnregisterServer) to register this local server in the
  18.              system Registry.
  19.  
  20.              For a comprehensive tutorial code tour of LOCSERVE's
  21.              contents and offerings see the tutorial LOCSERVE.HTM file.
  22.              For more specific technical details on the internal workings
  23.              see the comments dispersed throughout the LOCSERVE source code.
  24.              For more details on the LOCCLIEN.EXE that LOCSERVE works with
  25.              see the LOCCLIEN.HTM file in the main tutorial directory.
  26.  
  27.   Classes:   CMainWindow
  28.  
  29.   Functions: InitApplication, WinMain
  30.  
  31.   Origin:    11-14-95: atrent - Editor-inheritance from the DLLCLIEN source.
  32.  
  33. ----------------------------------------------------------------------------
  34.   This file is part of the Microsoft ActiveX Tutorial Code Samples.
  35.  
  36.   Copyright (C) Microsoft Corporation, 1997.  All rights reserved.
  37.  
  38.   This source code is intended only as a supplement to Microsoft
  39.   Development Tools and/or on-line documentation.  See these other
  40.   materials for detailed information regarding Microsoft code samples.
  41.  
  42.   THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY
  43.   KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  44.   IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
  45.   PARTICULAR PURPOSE.
  46. ==========================================================================+*/
  47.  
  48. /*--------------------------------------------------------------------------
  49.   We include WINDOWS.H for all Win32 applications.
  50.   We include OLE2.H because we will be calling the COM/OLE Libraries.
  51.   We include INITGUID.H only once (here) in the entire app because we
  52.     will be defining GUIDs and want them as constants in the data segment.
  53.   We include APPUTIL.H because we will be building this application using
  54.     the convenient Virtual Window and Dialog classes and other
  55.     utility functions in the APPUTIL Library (ie, APPUTIL.LIB).
  56.   We include MICARS.H and CARGUIDS.H for the common car-related Interface
  57.     class, GUID, and CLSID specifications.
  58.   We include LOCSERVE.H because it has class and resource definitions
  59.     specific to this LOCSERVE application.
  60.   We include SERVER.H because it has the necessary internal class and
  61.     resource definitions for this server.
  62.   We include FACTORY.H because it has the necessary internal class factory
  63.     declarations for this component server.
  64. ---------------------------------------------------------------------------*/
  65. #include <windows.h>
  66. #include <ole2.h>
  67. #include <initguid.h>
  68. #include <apputil.h>
  69. #include <micars.h>
  70. #include <carguids.h>
  71. #include "locserve.h"
  72. #include "server.h"
  73. #include "factory.h"
  74.  
  75.  
  76. // We encapsulate the control of this COM server (eg, lock and object
  77. // counting) in a server control C++ object.  Here is it's pointer.
  78. CServer*  g_pServer = NULL;
  79.  
  80. // Here is a pointer for use by the global Trace Message logging macros.
  81. CSendLog* g_pMsgLog = NULL;
  82.  
  83.  
  84. /*M+M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M
  85.   Method:   CMainWindow::CMainWindow
  86.  
  87.   Summary:  CMainWindow Constructor.
  88.  
  89.   Args:     .
  90.  
  91.   Modifies: .
  92.  
  93.   Returns:  .
  94. M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M-M*/
  95. CMainWindow::CMainWindow()
  96. {
  97.   m_pMsgBox = NULL;
  98. }
  99.  
  100.  
  101. /*M+M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M
  102.   Method:   CMainWindow::~CMainWindow
  103.  
  104.   Summary:  CMainWindow Destructor.  Destruction of the main window
  105.             indicates that the application should quit and thus the
  106.             PostQuitMessage API is called.
  107.  
  108.   Args:     .
  109.  
  110.   Modifies: .
  111.  
  112.   Returns:  .
  113. M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M-M*/
  114. CMainWindow::~CMainWindow()
  115. {
  116.   // CMainWindow is derived from CVirWindow which traps the WM_DESTROY
  117.   // message and causes a delete of CMainWindow which in turn causes this
  118.   // destructor to run. The WM_DESTROY results when the window is destoyed
  119.   // after a close of the window. Prior to exiting the main message loop:
  120.  
  121.   // Close down the factories (ie, Revoke and release the Class Factories).
  122.   if (NULL != g_pServer)
  123.     g_pServer->CloseFactories();
  124.  
  125.   LOG("L: Exiting LOCSERVE local server application.");
  126.  
  127.   // We delete the CMsgBox and CMsgLog objects that were made in
  128.   // Initinstance and the server control object, CServer.
  129.   DELETE_POINTER(g_pServer);
  130.   DELETE_POINTER(m_pMsgBox);
  131.   DELETE_POINTER(m_pMsgLog);
  132.  
  133.   // We then post a WM_QUIT message to cause an exit of the main thread's
  134.   // message loop and an exit of this instance of the application.
  135.   PostQuitMessage(0);
  136. }
  137.  
  138.  
  139. /*F+F++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  140.   Function: SetRegKeyValue
  141.  
  142.   Summary:  Internal utility function to set a Key, Subkey, and value
  143.             in the system Registry.
  144.  
  145.   Args:     LPTSTR pszKey,
  146.             LPTSTR pszSubkey,
  147.             LPTSTR pszValue)
  148.  
  149.   Returns:  BOOL
  150.               TRUE if success; FALSE if not.
  151. ------------------------------------------------------------------------F-F*/
  152. BOOL SetRegKeyValue(
  153.        LPTSTR pszKey,
  154.        LPTSTR pszSubkey,
  155.        LPTSTR pszValue)
  156. {
  157.   BOOL bOk = FALSE;
  158.   LONG ec;
  159.   HKEY hKey;
  160.   TCHAR szKey[MAX_STRING_LENGTH];
  161.  
  162.   lstrcpy(szKey, pszKey);
  163.  
  164.   if (NULL != pszSubkey)
  165.   {
  166.     lstrcat(szKey, TEXT("\\"));
  167.     lstrcat(szKey, pszSubkey);
  168.   }
  169.  
  170.   ec = RegCreateKeyEx(
  171.          HKEY_CLASSES_ROOT,
  172.          szKey,
  173.          0,
  174.          NULL,
  175.          REG_OPTION_NON_VOLATILE,
  176.          KEY_ALL_ACCESS,
  177.          NULL,
  178.          &hKey,
  179.          NULL);
  180.  
  181.   if (NULL != pszValue && ERROR_SUCCESS == ec)
  182.   {
  183.     ec = RegSetValueEx(
  184.            hKey,
  185.            NULL,
  186.            0,
  187.            REG_SZ,
  188.            (BYTE *)pszValue,
  189.            (lstrlen(pszValue)+1)*sizeof(TCHAR));
  190.     if (ERROR_SUCCESS == ec)
  191.       bOk = TRUE;
  192.     RegCloseKey(hKey);
  193.   }
  194.  
  195.   return bOk;
  196. }
  197.  
  198.  
  199. /*M+M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M
  200.   Method:   CMainWindow::RegisterServer
  201.  
  202.   Summary:  Member function used by this server to register itself in the
  203.             system registry.
  204.  
  205.   Args:     void.
  206.  
  207.   Returns:  BOOL
  208.               TRUE
  209. M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M-M*/
  210. BOOL CMainWindow::RegisterServer(void)
  211. {
  212.   BOOL  bOk = TRUE;
  213.   TCHAR szID[GUID_SIZE+1];
  214.   TCHAR szCLSID[GUID_SIZE+1];
  215.   TCHAR szModulePath[MAX_PATH];
  216.  
  217.   // Obtain the path to this module's executable file for later use.
  218.   GetModuleFileName(
  219.     g_pServer->m_hInstServer,
  220.     szModulePath,
  221.     sizeof(szModulePath)/sizeof(TCHAR));
  222.  
  223.   /*-------------------------------------------------------------------------
  224.     Create registry entries for the LocCar Component.
  225.   -------------------------------------------------------------------------*/
  226.   // Create some base key strings.
  227.   StringFromGUID2(CLSID_LocCar, szID, GUID_SIZE);
  228.   lstrcpy(szCLSID, TEXT("CLSID\\"));
  229.   lstrcat(szCLSID, szID);
  230.  
  231.   // Create ProgID keys.
  232.   SetRegKeyValue(
  233.     TEXT("LocCar1.0"),
  234.     NULL,
  235.     TEXT("LocCar Component - LOCSERVE Code Sample"));
  236.   SetRegKeyValue(
  237.     TEXT("LocCar1.0"),
  238.     TEXT("CLSID"),
  239.     szID);
  240.  
  241.   // Create VersionIndependentProgID keys.
  242.   SetRegKeyValue(
  243.     TEXT("LocCar"),
  244.     NULL,
  245.     TEXT("LocCar Component - LOCSERVE Code Sample"));
  246.   SetRegKeyValue(
  247.     TEXT("LocCar"),
  248.     TEXT("CurVer"),
  249.     TEXT("LocCar1.0"));
  250.   SetRegKeyValue(
  251.     TEXT("LocCar"),
  252.     TEXT("CLSID"),
  253.     szID);
  254.  
  255.   // Create entries under CLSID.
  256.   SetRegKeyValue(
  257.     szCLSID,
  258.     NULL,
  259.     TEXT("LocCar Component - LOCSERVE Code Sample"));
  260.   SetRegKeyValue(
  261.     szCLSID,
  262.     TEXT("ProgID"),
  263.     TEXT("LocCar1.0"));
  264.   SetRegKeyValue(
  265.     szCLSID,
  266.     TEXT("VersionIndependentProgID"),
  267.     TEXT("LocCar"));
  268.   SetRegKeyValue(
  269.     szCLSID,
  270.     TEXT("NotInsertable"),
  271.     NULL);
  272.   SetRegKeyValue(
  273.     szCLSID,
  274.     TEXT("LaunchPermission"),
  275.     TEXT("Y"));
  276.   SetRegKeyValue(
  277.     szCLSID,
  278.     TEXT("LocalServer32"),
  279.     szModulePath);
  280.  
  281.   /*-------------------------------------------------------------------------
  282.     Create registry entries for the LocUtilityCar Component.
  283.   -------------------------------------------------------------------------*/
  284.   // Create some base key strings.
  285.   StringFromGUID2(CLSID_LocUtilityCar, szID, GUID_SIZE);
  286.   lstrcpy(szCLSID, TEXT("CLSID\\"));
  287.   lstrcat(szCLSID, szID);
  288.  
  289.   // Create ProgID keys.
  290.   SetRegKeyValue(
  291.     TEXT("LocUtilityCar1.0"),
  292.     NULL,
  293.     TEXT("LocUtilityCar Component - LOCSERVE Code Sample"));
  294.   SetRegKeyValue(
  295.     TEXT("LocUtilityCar1.0"),
  296.     TEXT("CLSID"),
  297.     szID);
  298.  
  299.   // Create VersionIndependentProgID keys.
  300.   SetRegKeyValue(
  301.     TEXT("LocUtilityCar"),
  302.     NULL,
  303.     TEXT("LocUtilityCar Component - LOCSERVE Code Sample"));
  304.   SetRegKeyValue(
  305.     TEXT("LocUtilityCar"),
  306.     TEXT("CurVer"),
  307.     TEXT("LocUtilityCar1.0"));
  308.   SetRegKeyValue(
  309.     TEXT("LocUtilityCar"),
  310.     TEXT("CLSID"),
  311.     szID);
  312.  
  313.   // Create entries under CLSID.
  314.   SetRegKeyValue(
  315.     szCLSID,
  316.     NULL,
  317.     TEXT("LocUtilityCar Component - LOCSERVE Code Sample"));
  318.   SetRegKeyValue(
  319.     szCLSID,
  320.     TEXT("ProgID"),
  321.     TEXT("LocUtilityCar1.0"));
  322.   SetRegKeyValue(
  323.     szCLSID,
  324.     TEXT("VersionIndependentProgID"),
  325.     TEXT("LocUtilityCar"));
  326.   SetRegKeyValue(
  327.     szCLSID,
  328.     TEXT("NotInsertable"),
  329.     NULL);
  330.   SetRegKeyValue(
  331.     szCLSID,
  332.     TEXT("LaunchPermission"),
  333.     TEXT("Y"));
  334.   SetRegKeyValue(
  335.     szCLSID,
  336.     TEXT("LocalServer32"),
  337.     szModulePath);
  338.  
  339.   /*-------------------------------------------------------------------------
  340.     Create registry entries for the LocCruiseCar Component.
  341.   -------------------------------------------------------------------------*/
  342.   // Create some base key strings.
  343.   StringFromGUID2(CLSID_LocCruiseCar, szID, GUID_SIZE);
  344.   lstrcpy(szCLSID, TEXT("CLSID\\"));
  345.   lstrcat(szCLSID, szID);
  346.  
  347.   // Create ProgID keys.
  348.   SetRegKeyValue(
  349.     TEXT("LocCruiseCar1.0"),
  350.     NULL,
  351.     TEXT("LocCruiseCar Component - LOCSERVE Code Sample"));
  352.   SetRegKeyValue(
  353.     TEXT("LocCruiseCar1.0"),
  354.     TEXT("CLSID"),
  355.     szID);
  356.  
  357.   // Create VersionIndependentProgID keys.
  358.   SetRegKeyValue(
  359.     TEXT("LocCruiseCar"),
  360.     NULL,
  361.     TEXT("LocCruiseCar Component - LOCSERVE Code Sample"));
  362.   SetRegKeyValue(
  363.     TEXT("LocCruiseCar"),
  364.     TEXT("CurVer"),
  365.     TEXT("LocCruiseCar1.0"));
  366.   SetRegKeyValue(
  367.     TEXT("LocCruiseCar"),
  368.     TEXT("CLSID"),
  369.     szID);
  370.  
  371.   // Create entries under CLSID.
  372.   SetRegKeyValue(
  373.     szCLSID,
  374.     NULL,
  375.     TEXT("LocCruiseCar Component - LOCSERVE Code Sample"));
  376.   SetRegKeyValue(
  377.     szCLSID,
  378.     TEXT("ProgID"),
  379.     TEXT("LocCruiseCar1.0"));
  380.   SetRegKeyValue(
  381.     szCLSID,
  382.     TEXT("VersionIndependentProgID"),
  383.     TEXT("LocCruiseCar"));
  384.   SetRegKeyValue(
  385.     szCLSID,
  386.     TEXT("NotInsertable"),
  387.     NULL);
  388.   SetRegKeyValue(
  389.     szCLSID,
  390.     TEXT("LaunchPermission"),
  391.     TEXT("Y"));
  392.   SetRegKeyValue(
  393.     szCLSID,
  394.     TEXT("LocalServer32"),
  395.     szModulePath);
  396.  
  397.   return bOk;
  398. }
  399.  
  400.  
  401. /*M+M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M
  402.   Method:   CMainWindow::UnregisterServer
  403.  
  404.   Summary:  Member function used by this server to unregister itself from
  405.             the system Registry.
  406.  
  407.   Args:     void.
  408.  
  409.   Returns:  BOOL
  410.               TRUE
  411. M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M-M*/
  412. BOOL CMainWindow::UnregisterServer(void)
  413. {
  414.   BOOL  bOk = TRUE;
  415.   TCHAR szID[GUID_SIZE+1];
  416.   TCHAR szCLSID[GUID_SIZE+1];
  417.   TCHAR szTemp[GUID_SIZE+1];
  418.  
  419.   /*-------------------------------------------------------------------------
  420.     Delete registry entries for the LocCar Component.
  421.   -------------------------------------------------------------------------*/
  422.   //Create some base key strings.
  423.   StringFromGUID2(CLSID_LocCar, szID, GUID_SIZE);
  424.   lstrcpy(szCLSID, TEXT("CLSID\\"));
  425.   lstrcat(szCLSID, szID);
  426.  
  427.   RegDeleteKey(HKEY_CLASSES_ROOT, TEXT("LocCar\\CurVer"));
  428.   RegDeleteKey(HKEY_CLASSES_ROOT, TEXT("LocCar\\CLSID"));
  429.   RegDeleteKey(HKEY_CLASSES_ROOT, TEXT("LocCar"));
  430.  
  431.   RegDeleteKey(HKEY_CLASSES_ROOT, TEXT("LocCar1.0\\CLSID"));
  432.   RegDeleteKey(HKEY_CLASSES_ROOT, TEXT("LocCar1.0"));
  433.  
  434.   wsprintf(szTemp, TEXT("%s\\%s"), szCLSID, TEXT("ProgID"));
  435.   RegDeleteKey(HKEY_CLASSES_ROOT, szTemp);
  436.  
  437.   wsprintf(szTemp, TEXT("%s\\%s"), szCLSID, TEXT("VersionIndependentProgID"));
  438.   RegDeleteKey(HKEY_CLASSES_ROOT, szTemp);
  439.  
  440.   wsprintf(szTemp, TEXT("%s\\%s"), szCLSID, TEXT("NotInsertable"));
  441.   RegDeleteKey(HKEY_CLASSES_ROOT, szTemp);
  442.  
  443.   wsprintf(szTemp, TEXT("%s\\%s"), szCLSID, TEXT("LaunchPermission"));
  444.   RegDeleteKey(HKEY_CLASSES_ROOT, szTemp);
  445.  
  446.   wsprintf(szTemp, TEXT("%s\\%s"), szCLSID, TEXT("LocalServer32"));
  447.   RegDeleteKey(HKEY_CLASSES_ROOT, szTemp);
  448.  
  449.   RegDeleteKey(HKEY_CLASSES_ROOT, szCLSID);
  450.  
  451.   /*-------------------------------------------------------------------------
  452.     Delete registry entries for the LocUtilityCar Component.
  453.   -------------------------------------------------------------------------*/
  454.   //Create some base key strings.
  455.   StringFromGUID2(CLSID_LocUtilityCar, szID, GUID_SIZE);
  456.   lstrcpy(szCLSID, TEXT("CLSID\\"));
  457.   lstrcat(szCLSID, szID);
  458.  
  459.   RegDeleteKey(HKEY_CLASSES_ROOT, TEXT("LocUtilityCar\\CurVer"));
  460.   RegDeleteKey(HKEY_CLASSES_ROOT, TEXT("LocUtilityCar\\CLSID"));
  461.   RegDeleteKey(HKEY_CLASSES_ROOT, TEXT("LocUtilityCar"));
  462.  
  463.   RegDeleteKey(HKEY_CLASSES_ROOT, TEXT("LocUtilityCar1.0\\CLSID"));
  464.   RegDeleteKey(HKEY_CLASSES_ROOT, TEXT("LocUtilityCar1.0"));
  465.  
  466.   wsprintf(szTemp, TEXT("%s\\%s"), szCLSID, TEXT("ProgID"));
  467.   RegDeleteKey(HKEY_CLASSES_ROOT, szTemp);
  468.  
  469.   wsprintf(szTemp, TEXT("%s\\%s"), szCLSID, TEXT("VersionIndependentProgID"));
  470.   RegDeleteKey(HKEY_CLASSES_ROOT, szTemp);
  471.  
  472.   wsprintf(szTemp, TEXT("%s\\%s"), szCLSID, TEXT("NotInsertable"));
  473.   RegDeleteKey(HKEY_CLASSES_ROOT, szTemp);
  474.  
  475.   wsprintf(szTemp, TEXT("%s\\%s"), szCLSID, TEXT("LaunchPermission"));
  476.   RegDeleteKey(HKEY_CLASSES_ROOT, szTemp);
  477.  
  478.   wsprintf(szTemp, TEXT("%s\\%s"), szCLSID, TEXT("LocalServer32"));
  479.   RegDeleteKey(HKEY_CLASSES_ROOT, szTemp);
  480.  
  481.   RegDeleteKey(HKEY_CLASSES_ROOT, szCLSID);
  482.  
  483.   /*-------------------------------------------------------------------------
  484.     Delete registry entries for the LocCruiseCar Component.
  485.   -------------------------------------------------------------------------*/
  486.   //Create some base key strings.
  487.   StringFromGUID2(CLSID_LocCruiseCar, szID, GUID_SIZE);
  488.   lstrcpy(szCLSID, TEXT("CLSID\\"));
  489.   lstrcat(szCLSID, szID);
  490.  
  491.   RegDeleteKey(HKEY_CLASSES_ROOT, TEXT("LocCruiseCar\\CurVer"));
  492.   RegDeleteKey(HKEY_CLASSES_ROOT, TEXT("LocCruiseCar\\CLSID"));
  493.   RegDeleteKey(HKEY_CLASSES_ROOT, TEXT("LocCruiseCar"));
  494.  
  495.   RegDeleteKey(HKEY_CLASSES_ROOT, TEXT("LocCruiseCar1.0\\CLSID"));
  496.   RegDeleteKey(HKEY_CLASSES_ROOT, TEXT("LocCruiseCar1.0"));
  497.  
  498.   wsprintf(szTemp, TEXT("%s\\%s"), szCLSID, TEXT("ProgID"));
  499.   RegDeleteKey(HKEY_CLASSES_ROOT, szTemp);
  500.  
  501.   wsprintf(szTemp, TEXT("%s\\%s"), szCLSID, TEXT("VersionIndependentProgID"));
  502.   RegDeleteKey(HKEY_CLASSES_ROOT, szTemp);
  503.  
  504.   wsprintf(szTemp, TEXT("%s\\%s"), szCLSID, TEXT("NotInsertable"));
  505.   RegDeleteKey(HKEY_CLASSES_ROOT, szTemp);
  506.  
  507.   wsprintf(szTemp, TEXT("%s\\%s"), szCLSID, TEXT("LaunchPermission"));
  508.   RegDeleteKey(HKEY_CLASSES_ROOT, szTemp);
  509.  
  510.   wsprintf(szTemp, TEXT("%s\\%s"), szCLSID, TEXT("LocalServer32"));
  511.   RegDeleteKey(HKEY_CLASSES_ROOT, szTemp);
  512.  
  513.   RegDeleteKey(HKEY_CLASSES_ROOT, szCLSID);
  514.  
  515.   return bOk;
  516. }
  517.  
  518.  
  519. /*M+M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M
  520.   Method:   CMainWindow::DoMenu
  521.  
  522.   Summary:  Dispatch and handle the main menu commands.
  523.  
  524.   Args:     WPARAM wParam,
  525.               First message parameter (word sized).
  526.             LPARAM lParam)
  527.               Second message parameter (long sized).
  528.  
  529.   Modifies: ...
  530.  
  531.   Returns:  LRESULT
  532.               Standard Windows WindowProc return value.
  533. M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M-M*/
  534. LRESULT CMainWindow::DoMenu(
  535.           WPARAM wParam,
  536.           LPARAM lParam)
  537. {
  538.   LRESULT lResult = FALSE;
  539.   HMENU hMenu  = ::GetMenu(m_hWnd);
  540.  
  541.   switch (LOWORD(wParam))
  542.   {
  543.     //----------------------------------------------------------------------
  544.     // Handle File Menu Commands.
  545.     //----------------------------------------------------------------------
  546.     case IDM_FILE_EXIT:
  547.       // The user commands us to exit this application so we tell the
  548.       // Main window to close itself.
  549.       ::PostMessage(m_hWnd, WM_CLOSE, 0, 0);
  550.       break;
  551.  
  552.     //----------------------------------------------------------------------
  553.     // Handle Log Menu Commands.
  554.     //----------------------------------------------------------------------
  555.     case IDM_LOG_LOGCLEAR:
  556.       // Clear the message log.
  557.       g_pMsgLog->Clear();
  558.       // Use macro to log messages.
  559.       LOGID(IDS_LOGTO_SERVER);
  560.       break;
  561.     case IDM_LOG_COPYCLIP:
  562.       // Copy trace message log to clipboard.
  563.       g_pMsgLog->Copy();
  564.       break;
  565.  
  566.     //----------------------------------------------------------------------
  567.     // Handle Help Menu Commands.
  568.     //----------------------------------------------------------------------
  569.     case IDM_HELP_ABOUT:
  570.       {
  571.         CAboutBox dlgAboutBox;
  572.         HWND hWnd = FindWindow(NULL, TEXT(CLIENT_WINDOW_TITLE));
  573.         if (NULL == hWnd)
  574.           hWnd = m_hWnd;
  575.  
  576.         LOG("L: === Help Menu: About LOCSERVE.");
  577.         // Show the standard About Box dialog for this EXE by telling the
  578.         // dialog C++ object to show itself by invoking its ShowDialog
  579.         // method.  Pass it this EXE instance and the parent window handle.
  580.         // Use a dialog resource ID for the dialog template stored in
  581.         // this EXE module's resources.
  582.         dlgAboutBox.ShowDialog(
  583.           m_hInst,
  584.           MAKEINTRESOURCE(IDM_HELP_ABOUT),
  585.           hWnd);
  586.       }
  587.       break;
  588.  
  589.     default:
  590.       // Defer all messages NOT handled here to the Default Window Proc.
  591.       lResult = ::DefWindowProc(m_hWnd, WM_COMMAND, wParam, lParam);
  592.       break;
  593.   }
  594.  
  595.   return(lResult);
  596. }
  597.  
  598.  
  599. /*M+M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M
  600.   Method:   CMainWindow::InitInstance
  601.  
  602.   Summary:  Instantiates an instance of the main application window.
  603.             This method must be called only once, immediately after
  604.             window class construction.  We take care to delete 'this'
  605.             CMainWindow if we must return the error condition FALSE.
  606.  
  607.   Args:     HINSTANCE hInstance,
  608.               Handle of the application instance.
  609.             int nShow)
  610.               Command to pass to ShowWindow.
  611.  
  612.   Modifies: m_szHelpFile, m_pMsgBox, m_pMsgLog.
  613.  
  614.   Returns:  BOOL.
  615.               TRUE if succeeded.
  616.               FALSE if failed.
  617. M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M-M*/
  618. BOOL CMainWindow::InitInstance(
  619.        HINSTANCE hInstance,
  620.        int nShow)
  621. {
  622.   BOOL bOk = FALSE;
  623.   HWND hWnd;
  624.  
  625.   // Create the Message Box object.
  626.   m_pMsgBox = new CMsgBox;
  627.   m_pMsgLog = new CSendLog;
  628.  
  629.   if (NULL != m_pMsgBox && NULL != m_pMsgLog)
  630.   {
  631.     // Note, the Create method sets the m_hWnd member so we don't
  632.     // need to set it explicitly here first.
  633.  
  634.     // Here is the create of this window.  Size the window reasonably.
  635.     // Create sets both m_hInst and m_hWnd.
  636.     hWnd = Create(
  637.              TEXT(MAIN_WINDOW_CLASS_NAME_STR),
  638.              TEXT(MAIN_WINDOW_TITLE_STR),
  639.              WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX
  640.                | WS_MAXIMIZEBOX | WS_THICKFRAME,
  641.              CW_USEDEFAULT,
  642.              CW_USEDEFAULT,
  643.              ::GetSystemMetrics(SM_CXSCREEN)*3/5,
  644.              ::GetSystemMetrics(SM_CYSCREEN)*3/5,
  645.              NULL,
  646.              NULL,
  647.              hInstance);
  648.     if (hWnd)
  649.     {
  650.       // Assign the server's copy of the main window handle.
  651.       g_pServer->m_hWndServer = m_hWnd;
  652.  
  653.       // Init the Message Box object.
  654.       if (m_pMsgBox->Init(m_hInst, m_hWnd))
  655.       {
  656.         bOk = TRUE;
  657.         // If the Client's Main window is found then set up logging to it.
  658.         hWnd = FindWindow(NULL, TEXT(CLIENT_WINDOW_TITLE));
  659.         if (NULL != hWnd)
  660.         {
  661.           // Tell the CSendLog object that we are logging to client.
  662.           m_pMsgLog->LogToServer(FALSE);
  663.           // Assign the global MsgLog pointer.
  664.           g_pMsgLog = m_pMsgLog;
  665.           m_pMsgLog->SetClient(m_hInst, m_hWnd, hWnd);
  666.           LOGID(IDS_LOGTO_CLIENT);
  667.         }
  668.         else
  669.         {
  670.           // If the client window can't be found then create and show the
  671.           // log display in this local server.
  672.  
  673.           // Indicate we are logging to our own server log facility.
  674.           m_pMsgLog->LogToServer(TRUE);
  675.  
  676.           // Ensure the new window is shown on screen and its content
  677.           // is painted.
  678.           ::ShowWindow(m_hWnd, nShow);
  679.           ::UpdateWindow(m_hWnd);
  680.  
  681.           // Create the Trace Message Log ListBox as a child window that
  682.           // fits the client area of the Main Window (the TRUE 3rd argument
  683.           // specifies such an inside child). If you want the Trace Message
  684.           // Log in a separate (but owned) window, then pass a FALSE
  685.           // instead for the 3rd argument.
  686.           if (m_pMsgLog->CreateServerLog(m_hInst, m_hWnd, TRUE))
  687.           {
  688.             // Assign the global MsgLog pointer.
  689.             g_pMsgLog = m_pMsgLog;
  690.             // Use macro to log an initial start messsage.
  691.             LOGID(IDS_LOGTO_SERVER);
  692.           }
  693.           else
  694.             bOk = FALSE;
  695.         }
  696.       }
  697.     }
  698.   }
  699.  
  700.   if (!bOk)
  701.   {
  702.     DELETE_POINTER(m_pMsgBox);
  703.     DELETE_POINTER(m_pMsgLog);
  704.   }
  705.  
  706.   return (bOk);
  707. }
  708.  
  709.  
  710. /*M+M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M
  711.   Method:   CMainWindow::WindowProc
  712.  
  713.   Summary:  Main window procedure for this window object.  See CVirWindow
  714.             in the APPUTIL library (APPUTIL.CPP) for details on how this
  715.             method gets called by the global WindowProc.
  716.  
  717.   Args:     UINT uMsg,
  718.               Windows message that is "sent" to this window.
  719.             WPARAM wParam,
  720.               First message parameter (word sized).
  721.             LPARAM lParam)
  722.               Second message parameter (long sized).
  723.  
  724.   Modifies: ...
  725.  
  726.   Returns:  LRESULT
  727.               Standard Windows WindowProc return value.
  728. M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M-M*/
  729. LRESULT CMainWindow::WindowProc(
  730.           UINT uMsg,
  731.           WPARAM wParam,
  732.           LPARAM lParam)
  733. {
  734.   LRESULT lResult = FALSE;
  735.  
  736.   switch (uMsg)
  737.   {
  738.     case WM_CREATE:
  739.       break;
  740.  
  741.     case WM_COMMAND:
  742.       // Dispatch and handle any Menu command messages received.
  743.       lResult = DoMenu(wParam, lParam);
  744.       break;
  745.  
  746.     case WM_CLOSE:
  747.       // The user selected Close on the main window's System menu
  748.       // or Exit on the File menu.
  749.     case WM_QUIT:
  750.       // If the app is being quit then close any associated help windows.
  751.       // ::WinHelp(m_hWnd, m_szHelpFile, HELP_QUIT, 0);
  752.     default:
  753.       // Defer all messages NOT handled here to the Default Window Proc.
  754.       lResult = ::DefWindowProc(m_hWnd, uMsg, wParam, lParam);
  755.       break;
  756.   }
  757.  
  758.   return(lResult);
  759. }
  760.  
  761.  
  762. /*F+F++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  763.   Function: UnicodeOk
  764.  
  765.   Summary:  Checks if the platform will handle unicode versions of
  766.             Win32 string API calls.
  767.  
  768.   Args:     void
  769.  
  770.   Returns:  BOOL
  771.               TRUE if unicode support; FALSE if not.
  772. ------------------------------------------------------------------------F-F*/
  773. BOOL UnicodeOk(void)
  774. {
  775.   BOOL bOk = TRUE;
  776.   TCHAR szUserName[MAX_STRING_LENGTH];
  777.   DWORD dwSize = MAX_STRING_LENGTH;
  778.  
  779.   if (!GetUserName(szUserName, &dwSize))
  780.     bOk = ERROR_CALL_NOT_IMPLEMENTED == GetLastError() ? FALSE : TRUE;
  781.  
  782.   return bOk;
  783. }
  784.  
  785.  
  786. /*F+F++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  787.   Function: InitApplication
  788.  
  789.   Summary:  Initializes the application and registers its main window
  790.             class. InitApplication is called only once (in WinMain).
  791.  
  792.   Args:     HINSTANCE hInstance)
  793.               Handle to the first instance of the application.
  794.  
  795.   Returns:  BOOL.
  796.               TRUE if success.
  797.               FALSE if fail.
  798. ------------------------------------------------------------------------F-F*/
  799. BOOL InitApplication(
  800.        HINSTANCE hInstance)
  801. {
  802.   BOOL bOK;
  803.   // The window class for all instances of the main frame window.
  804.   WNDCLASSEX wcf;
  805.  
  806.   // Assign the appropriate values for this main frame window class.
  807.   wcf.cbSize        = sizeof(WNDCLASSEX);
  808.   wcf.style         = CS_HREDRAW | CS_VREDRAW; // Class style(s).
  809.   wcf.lpfnWndProc   = &WindowProc;             // Global Window Procedure for
  810.                                                //   all windows of this class.
  811.   wcf.cbClsExtra    = 0;                       // No per-class extra data.
  812.   wcf.cbWndExtra    = 0;                       // No per-window extra data.
  813.   wcf.hInstance     = hInstance;               // Owner of this class.
  814.   wcf.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);       // Default color.
  815.   wcf.lpszMenuName  = TEXT(MAIN_WINDOW_CLASS_MENU_STR); // Menu name from .RC.
  816.   wcf.lpszClassName = TEXT(MAIN_WINDOW_CLASS_NAME_STR); // Class name from .RC.
  817.   wcf.hCursor       = LoadCursor(NULL, IDC_ARROW);      // Cursor.
  818.   wcf.hIcon         = LoadIcon(                         // Icon name from .RC.
  819.                         hInstance,
  820.                         TEXT("AppIcon"));
  821.   wcf.hIconSm       = LoadImage(                        // Load small icon.
  822.                         hInstance,
  823.                         TEXT("AppIcon"),
  824.                         IMAGE_ICON,
  825.                         16, 16,
  826.                         0);
  827.  
  828.   // Register the window class and return FALSE if unsuccesful.
  829.   bOK = RegisterClassEx(&wcf);
  830.   if (!bOK)
  831.   {
  832.     // Assume we are running on NT where RegisterClassEx() is
  833.     // not implemented, so let's try calling RegisterClass().
  834.     bOK = RegisterClass((LPWNDCLASS)&wcf.style);
  835.   }
  836.  
  837.   return (bOK);
  838. }
  839.  
  840.  
  841. /*F+F+++F+++F+++F+++F+++F+++F+++F+++F+++F+++F+++F+++F+++F+++F+++F+++F+++F+++F
  842.   Function: WinMain
  843.  
  844.   Summary:  The Windows main entry point function for this application.
  845.             Initializes the application, the COM Libraries, and starts
  846.             the main application message loop.
  847.  
  848.   Args:     HINSTANCE hInstance,
  849.               Instance handle; a new one for each invocation of this app.
  850.             HINSTANCE hPrevInstance,
  851.               Instance handle of the previous instance. NULL in Win32.
  852.             LPSTR lpCmdLine,
  853.               Windows passes a pointer to the application's
  854.               invocation command line.
  855.             int nCmdShow)
  856.               Bits telling the show state of the application.
  857.  
  858.   Returns:  int
  859.               msg.wParam (upon exit of message loop).
  860.               FALSE if this instance couldn't initialize and run.
  861. F---F---F---F---F---F---F---F---F---F---F---F---F---F---F---F---F---F---F-F*/
  862. extern "C" int WINAPI WinMain(
  863.                         HINSTANCE hInstance,
  864.                         HINSTANCE hPrevInstance,
  865.                         LPSTR lpCmdLine,
  866.                         int nCmdShow)
  867. {
  868.   CMainWindow* pWin = NULL;
  869.   int iRun = TRUE;
  870.   MSG msg;
  871.  
  872.   // If we were compiled for UNICODE and the platform seems OK with this
  873.   // then proceed.  Else we error and exit the app.
  874.   if (UnicodeOk())
  875.   {
  876.     // Call to initialize the COM Library.  Use the SUCCEEDED macro
  877.     // to detect success.  If fail then exit app with error message.
  878.     if (SUCCEEDED(CoInitialize(NULL)))
  879.     {
  880.       // If we succeeded in initializing the COM Library we proceed to
  881.       // initialize the application.  If we can't init the application
  882.       // then we signal shut down with an error message exit.
  883.       iRun = InitApplication(hInstance);
  884.       if (iRun)
  885.       {
  886.         // Assume we'll set iRun to TRUE when initialization is done.
  887.         iRun = FALSE;
  888.  
  889.         // We are still go for running so we try to create a nifty new
  890.         // CMainWindow object for this app instance.
  891.         pWin = new CMainWindow;
  892.         if (NULL != pWin)
  893.         {
  894.           // Setup the server control object.
  895.           g_pServer = new CServer;
  896.           if (NULL != g_pServer)
  897.           {
  898.             // Assign the server's instance handle.
  899.             g_pServer->m_hInstServer = hInstance;
  900.  
  901.             // Check command line for switches to register or unregister
  902.             // this server's managed components.   iRun will be set to 2
  903.             // to signal an immediate and quiet exit of this application
  904.             // if such registration or unregistration is requested.
  905.             if (0 == lstrcmpiA(lpCmdLine, "-RegServer")
  906.                 || 0 == lstrcmpiA(lpCmdLine, "/RegServer"))
  907.             {
  908.               if (pWin->RegisterServer())
  909.                 iRun = 2;
  910.             }
  911.             else if (0 == lstrcmpiA(lpCmdLine, "-UnregServer")
  912.                      || 0 == lstrcmpiA(lpCmdLine, "/UnregServer"))
  913.             {
  914.               if (pWin->UnregisterServer())
  915.                 iRun = 2;
  916.             }
  917.  
  918.             if (FALSE == iRun)
  919.             {
  920.               // If we did not process a command line switch that
  921.               // requires immediate exit, then initialize an instance of
  922.               // the new CMainWindow. This entails creating the main window.
  923.               // Note: if InitInstance fails then it would have already
  924.               // deleted pWin so we wouldn't need to delete it here.
  925.               if (pWin->InitInstance(hInstance, nCmdShow))
  926.               {
  927.                 LOGF1("L: CmdLine Switches= %s", lpCmdLine);
  928.                 // Create and register the Class Factories.  But only do so
  929.                 // if this application has been launched by COM as indicated
  930.                 // by the -Embedding command line switch.
  931.                 if (0 == lstrcmpiA(lpCmdLine, "-Embedding")
  932.                     || 0 == lstrcmpiA(lpCmdLine, "/Embedding"))
  933.                   iRun = g_pServer->OpenFactories();
  934.               }
  935.             }
  936.           }
  937.         }
  938.       }
  939.  
  940.       switch (iRun)
  941.       {
  942.         case TRUE:
  943.           {
  944.             // If we initialized the app instance properly then we are still
  945.             // go for running.  We then start up the main message pump for
  946.             // the application.  The application will live hidden as a local
  947.             // server.
  948.             while (GetMessage(&msg, NULL, 0, 0))
  949.             {
  950.               TranslateMessage(&msg);
  951.               DispatchMessage(&msg);
  952.             }
  953.  
  954.             // We'll pass to the OS the reason why we exited the message
  955.             // loop.
  956.             iRun = msg.wParam;
  957.           }
  958.           break;
  959.  
  960.         case FALSE:
  961.           {
  962.             // We failed to initialize the application--issue an error
  963.             // messagebox.  Can't initialize or can't run stand-alone.
  964.             TCHAR szMsg[MAX_STRING_LENGTH];
  965.  
  966.             // Load the error message string from the resources.
  967.             if (LoadString(
  968.                   hInstance,
  969.                   IDS_APPINITFAILED,
  970.                   szMsg,
  971.                   MAX_STRING_LENGTH))
  972.             {
  973.               // Put up error message box saying that application couldn't
  974.               // be initialized.  Parent window is desktop (ie, NULL).
  975.               MessageBox(
  976.                 NULL,
  977.                 szMsg,
  978.                 TEXT(ERROR_TITLE_STR),
  979.                 MB_OK | MB_ICONEXCLAMATION);
  980.             }
  981.  
  982.             // Delete the CMainWindow object.
  983.             DELETE_POINTER(pWin);
  984.  
  985.             // Pass the OS an error code of 1.
  986.             iRun = 1;
  987.           }
  988.           break;
  989.  
  990.         default:
  991.           // Pass the OS an error code of 0.
  992.           iRun = 0;
  993.           break;
  994.       }
  995.  
  996.       // We're exiting this app (either normally or by init failure) so
  997.       // shut down the COM Library.
  998.       CoUninitialize();
  999.     }
  1000.     else
  1001.     {
  1002.       // We failed to Initialize the COM Library.
  1003.       TCHAR szMsg[MAX_STRING_LENGTH];
  1004.  
  1005.       // Load the error message string from the resources.
  1006.       if (LoadString(
  1007.             hInstance,
  1008.             IDS_COMINITFAILED,
  1009.             szMsg,
  1010.             MAX_STRING_LENGTH))
  1011.       {
  1012.         // Put up error message box saying that COM Library
  1013.         // couldn't be initialized.  Parent window is desktop (ie, NULL).
  1014.         // And exit the failed application.
  1015.         MessageBox(
  1016.           NULL,
  1017.           szMsg,
  1018.           TEXT(ERROR_TITLE_STR),
  1019.           MB_OK | MB_ICONEXCLAMATION);
  1020.       }
  1021.     }
  1022.   }
  1023.   else
  1024.   {
  1025.     // If we were compiled for UNICODE but the platform has problems with
  1026.     // this then indicate an error and exit the app immediately.
  1027.     CHAR szMsg[MAX_STRING_LENGTH];
  1028.  
  1029.     if (LoadStringA(
  1030.           hInstance,
  1031.           IDS_NOUNICODE,
  1032.           szMsg,
  1033.           MAX_STRING_LENGTH))
  1034.     {
  1035.       MessageBoxA(
  1036.         NULL,
  1037.         szMsg,
  1038.         ERROR_TITLE_STR,
  1039.         MB_OK | MB_ICONEXCLAMATION);
  1040.     }
  1041.   }
  1042.  
  1043.   return iRun;
  1044. }
  1045.