home *** CD-ROM | disk | FTP | other *** search
/ C Programming Starter Kit 2.0 / SamsPublishing-CProgrammingStarterKit-v2.0-Win31.iso / bc45 / idehook.pak / OLETOOLS.CPP < prev    next >
Encoding:
C/C++ Source or Header  |  1997-07-24  |  19.1 KB  |  581 lines
  1. ///////////////////////////////////////////////////////////////////////
  2. //
  3. // Copyright <c> Borland International, 1994
  4. //
  5. // Example Tools added for common OLE development.
  6. //
  7. ///////////////////////////////////////////////////////////////////////
  8. //
  9. // To enable the tools:
  10. // --------------------
  11. // 1) Build the OLETOOLS.DLL target.
  12. // 2) Add the following to the [AddOns] section of your BCW.INI file:
  13. //    Addon000=Drive:Path\OLETOOLS.DLL
  14. //    Note: The 000 must actually be the next numeric value in sequence.
  15. //          That is, if you already have an entry with 000, use 001 etc...
  16. //          If the [AddOns] section doesn't exist you may create it.
  17. // 3) On certain environments you will need to verify that the STDOLE.DLL
  18. //    resides in your windows system directory.
  19. //
  20. // Tools Descriptions:
  21. // ------------------
  22. // translateODLtoTLB
  23. //    Convert .odl to .tlb files. 
  24. //    (Requires Non-Borland distributed MkTypLib.exe)
  25. // msMKTypLib
  26. //    Internal (to example) tool used for converting from ODL to TLB files.
  27. // extractAndBindTLB
  28. //    Create .tlb from .exe/.dll bind .tlb back into .dll/.exe
  29. // oleRegister
  30. //    Internal (to example) tool used to invoke register.exe
  31. // oleExtractTLB
  32. //    Extract TypeLib Information
  33. // oleExtractReg
  34. //    Create a .reg file from .exe/.dll
  35. // oleRegEditAdvanced
  36. //    Tools Menu option to invoke regedit with /v parameter.
  37. // generateAndAddSource
  38. //    Create nodes (.cxx [.cpp] /.hxx [.h] ) in your target from .exe/.dll
  39. // oleAutoGen
  40. //    Internal (to example) tool used to invoke Autogen.
  41. //
  42. ///////////////////////////////////////////////////////////////////////
  43. #pragma hdrstop
  44. // Standard include files.
  45. #include <string.h>
  46. #include <windows.h>
  47. #include <dir.h>
  48.  
  49. // IDEHOOK include file.
  50. #include "idehook.h"
  51.  
  52. // OLE Tool names.
  53. static char translateODLtoTLB[]    = "OLE_ODLtoTLB";
  54. static char msMkTypLib[]           = "OLE_IMkTypeLib";
  55. static char extractAndBindTLB[]    = "OLE_ExtractAndBindTypeInfo";
  56. static char oleRegister[]          = "OLE_IRegister";
  57. static char oleExtractTLB[]        = "OLE_ExtractTypeInfo";
  58. static char oleExtractReg[]        = "OLE_ExtractReg";
  59. static char oleRegEditAdvanced[]   = "OLE_RegEditAdvanced";
  60. static char generateAndAddSource[] = "OLE_GenerateAndAddSource";
  61. static char oleAutoGen[]           = "OLE_IAutoGen";
  62.  
  63. // Existing tool names provided by BCW
  64. static char realLinker[]           = "LinkTarget";
  65. static char realResCompiler[]      = "CompileResources";
  66. static char realCppPreprocess[]    = "CppPreprocessor";
  67.  
  68. ///////////////////////////////////////////////////////////////////////
  69. //  LocalToolClient ctor
  70. //  Encapsulates the callback routines for tools.       
  71. ///////////////////////////////////////////////////////////////////////
  72. class _HOOKCLASS LocalToolClient : public ToolClient
  73. {
  74.  public:
  75.  
  76.     // Callback routines.
  77.      ToolReturn _HOOKEP RunGenerateAndAddSource( ToolInvokeArgs * );
  78.      ToolReturn _HOOKEP RunExtractAndBind( ToolInvokeArgs * );
  79.      ToolReturn _HOOKEP RunTypeLibrary( ToolInvokeArgs * );
  80.  
  81.     // Registers Callback routines
  82.      void RegisterMyCallBacks( ToolServer * );
  83.  
  84.  private:
  85.  
  86.      int registered; 
  87.      static ToolRegisterPack entryPoints[];
  88. };
  89.  
  90. // Instantiated LocalToolClient object.  
  91. static LocalToolClient localToolClient;
  92.  
  93. // Static ToolRegisterPack object.  
  94. ToolRegisterPack LocalToolClient::entryPoints[] =
  95. {
  96.  { ::generateAndAddSource, (ToolMethod)&LocalToolClient::RunGenerateAndAddSource },
  97.  { ::extractAndBindTLB, (ToolMethod)&LocalToolClient::RunExtractAndBind },
  98.  { ::translateODLtoTLB, (ToolMethod)&LocalToolClient::RunTypeLibrary },
  99.  { 0 }
  100. };
  101.  
  102. ///////////////////////////////////////////////////////////////////////////
  103. // LocalToolClient::RegisterMyCallBacks 
  104. //    Register tool callback routines.
  105. ///////////////////////////////////////////////////////////////////////////
  106. void                              
  107. LocalToolClient::RegisterMyCallBacks( ToolServer * ts )
  108. {
  109.  // Have these been registered before?
  110.  if (!registered)
  111.      {
  112.       registered = 1;
  113.       ts->ToolRegisterImplementor( this, entryPoints );
  114.      }
  115. }
  116.  
  117. ///////////////////////////////////////////////////////////////////////////
  118. // LocalToolClient::generateAndAddSource
  119. //    Create nodes (.cxx [.cpp] /.hxx [.h] ) in your target from .exe/.dll
  120. ///////////////////////////////////////////////////////////////////////////
  121. ToolReturn _HOOKEP
  122. LocalToolClient::RunGenerateAndAddSource(ToolInvokeArgs * args)
  123. {
  124.  ToolReq trTool;           // Tool Requestor.
  125.  ProjectReq prProject;     // Project Requestor
  126.  ToolReturn trReturn = FatalError;  // Return Value.
  127.  
  128.  ProjectNode pnParent = args->numNodes ? *args->nodeArray : 0;
  129.  
  130.  if (pnParent)
  131.      {
  132.       // Obtain code generation tool.
  133.       ToolObj toAutoGen = trTool->ToolFind(::oleAutoGen);
  134.  
  135.       if (toAutoGen)
  136.           {
  137.             // Base used for new file names.
  138.             char acBaseName[10];
  139.  
  140.             // Project Node Information.
  141.             ProjectNodeInfo pniParent;
  142.  
  143.             // Get filename from node information.
  144.             prProject->QueryNodeInfo(pnParent,pniParent);
  145.  
  146.             // Extract base file name.
  147.             fnsplit(pniParent.name,NULL,NULL,acBaseName,NULL);
  148.  
  149.             // Check for valid name.
  150.             if (acBaseName[0] != 0)
  151.                 {
  152.              char acNodeNameCXX[14];
  153.                 char acNodeNameHXX[14];
  154.  
  155.              // Create New Node Names
  156.              wsprintf(acNodeNameCXX,"%s.cxx",acBaseName);
  157.              wsprintf(acNodeNameHXX,"%s.hxx",acBaseName);
  158.  
  159.                  ToolObj regServer = trTool->ToolFind( oleRegister );
  160.  
  161.                  if (regServer)
  162.                      {
  163.                  // Create needed .olb file.
  164.                       if (trTool->ToolInvoke( regServer, pnParent, "$TARGET -TypeLib=$NAME($TARGET).olb") == Success)
  165.                           {
  166.                             // Invoke tool and generate new source modules.
  167.                             // upon success, add new source modules to the project.
  168.                      if (trTool->ToolInvoke( toAutoGen, (const char *)0, "$NAME($TARGET).olb" ) == Success )
  169.                              {
  170.                          // Add generated source code to project.
  171.                               ProjectNode pnCpp = prProject->NodeAdd(pnParent,acNodeNameCXX,".cpp");
  172.                               prProject->NodeAdd(pnCpp,acNodeNameHXX,".h");
  173.                               trReturn = Success;
  174.                              }
  175.                          else
  176.                              ::MessageBox(::GetActiveWindow(),"AutoGen Reported Failure","Error",MB_ICONEXCLAMATION | MB_OK);
  177.                           }
  178.                  else
  179.                          ::MessageBox(::GetActiveWindow(),"Register Reported Failure","Error",MB_ICONEXCLAMATION | MB_OK);
  180.                 }
  181.              else
  182.                 ::MessageBox(::GetActiveWindow(),"REGISTER.EXE Not Found","Error",MB_ICONEXCLAMATION | MB_OK);
  183.                 }    
  184.             else
  185.               ::MessageBox(::GetActiveWindow(),"Base File Name Not Found","Error",MB_ICONEXCLAMATION | MB_OK);
  186.          }
  187.      else
  188.         ::MessageBox(::GetActiveWindow(),"AUTOGEN.EXE Not Found","Error",MB_ICONEXCLAMATION | MB_OK);
  189.     }
  190.  else
  191.     ::MessageBox(::GetActiveWindow(),"Parent Node Invalid","Error",MB_ICONEXCLAMATION | MB_OK);
  192.  
  193.  return (trReturn);
  194. }
  195.  
  196. ///////////////////////////////////////////////////////////////////////////
  197. // extractAndBindTLB
  198. //    Create .tlb from .exe/.dll bind .tlb back into .dll/.exe
  199. ///////////////////////////////////////////////////////////////////////////
  200. ToolReturn _HOOKEP
  201. LocalToolClient::RunExtractAndBind( ToolInvokeArgs * args )
  202. {
  203.  ProjectReq  ps;
  204.  EditorReq   editor;
  205.  ToolReq     server;
  206.  
  207.  ToolReturn trReturn = FatalError;
  208.  
  209.  ProjectNode targetNode = args->numNodes ? *args->nodeArray : 0;
  210.  
  211.  if (targetNode)
  212.      {
  213.       // Extract the .tlb from the .dll/.exe
  214.       ToolObj regServer = server->ToolFind( oleRegister );
  215.  
  216.       if (regServer)
  217.           {
  218.             server->ToolInvoke( regServer, targetNode, "$TARGET -TypeLib=__temp.tlb" );
  219.  
  220.             // Create a .rc node
  221.             static char rcNodeName[] = "__temp.rc";
  222.  
  223.             ProjectNode rcNode = ps->NodeAdd( targetNode, rcNodeName );
  224.  
  225.             if (rcNode)
  226.                 {
  227.                  // Create a edit buffer for the .rc script
  228.                  static char rcStatement[]  = "TYPELIB 1 __temp.tlb";
  229.  
  230.                  BufferId newBuffer_id  = editor->create_buffer( 0, rcNodeName, 0 );
  231.                  BufferId currBuffer_id = editor->set_buffer(newBuffer_id);
  232.  
  233.                  editor->insert( rcStatement  );
  234.  
  235.                  // Resource compile the .rc script
  236.                  ToolObj resCompiler = server->ToolFind( realResCompiler );
  237.  
  238.                  if (resCompiler)
  239.                      {
  240.                       server->ToolInvoke( resCompiler, rcNode, 0);
  241.  
  242.                       // Run the linker (this re-bind the .dll with the new .res)
  243.                       ToolObj linker = server->ToolFind( realLinker );
  244.  
  245.                       if (linker)
  246.                           {
  247.                             server->ToolInvoke( linker, targetNode, 0 );
  248.                             trReturn = Success;
  249.                           }
  250.                       else
  251.                           ::MessageBox(::GetActiveWindow(),"Internal Linker Not Found","Error!",MB_ICONEXCLAMATION | MB_OK);
  252.  
  253.                       // Re-register now that the .tlb is inside the .dll/.exe
  254.                       server->ToolInvoke( regServer, targetNode, "$TARGET -RegServer" );
  255.                      }
  256.                 else
  257.                   ::MessageBox(::GetActiveWindow(),"Internal Resource Compiler Not Found","Error!",MB_ICONEXCLAMATION | MB_OK);
  258.  
  259.                 // Restore the user's editor state
  260.                 editor->set_buffer( currBuffer_id );
  261.                 editor->delete_buffer( newBuffer_id );
  262.  
  263.                 // Remove temporary node.
  264.                 ps->NodeRemove(rcNode);
  265.               }
  266.           else
  267.               ::MessageBox(::GetActiveWindow(),"Unable to create a temporary node.","Error!",MB_ICONEXCLAMATION | MB_OK);
  268.           }
  269.       else
  270.           ::MessageBox(::GetActiveWindow(),"REGISTER.EXE Not Found","Error!",MB_ICONEXCLAMATION | MB_OK);
  271.      }
  272.  else
  273.      ::MessageBox(::GetActiveWindow(),"Target Node Not Found","Error!",MB_ICONEXCLAMATION | MB_OK);
  274.  
  275.  return( trReturn );
  276. }
  277.  
  278. ///////////////////////////////////////////////////////////////////////////////
  279. // translateODLtoTLB
  280. //    Convert .odl to .tlb files. (Requires Non-Borland distributed MkTypLib.exe?)
  281. ///////////////////////////////////////////////////////////////////////////////
  282. ToolReturn _HOOKEP
  283. LocalToolClient::RunTypeLibrary( ToolInvokeArgs * args )
  284. {
  285.  static char cppCmdLine[]
  286.                         = "+$RSP(-D__MKTYPLIB__;$DEF -I$INC -P- -otlbt@@@.tm~) $EDNAME";
  287.  
  288.  ToolReq   server;
  289.  
  290.  ProjectNode node = args->numNodes ? *args->nodeArray : 0;
  291.  
  292.  ToolObj preprocessor = server->ToolFind( realCppPreprocess );
  293.  ToolObj msTool = 0;
  294.  
  295.  if ( preprocessor )
  296.      {
  297.       if ( server->ToolInvoke( preprocessor, node, cppCmdLine) == Success )
  298.           {
  299.             if ((msTool = server->ToolFind( ::msMkTypLib )) == 0)
  300.             ::MessageBox(::GetActiveWindow(),"Can't find mktyplib.exe tool", "Error!",MB_ICONEXCLAMATION | MB_OK);
  301.           }
  302.       else
  303.         ::MessageBox(::GetActiveWindow(),"CppPreprocess did not complete ok!","Error!",MB_ICONEXCLAMATION | MB_OK);
  304.      }
  305.  
  306.  if ( msTool )
  307.      return( server->ToolInvoke( msTool, node, args->cmdLine ) );
  308.  
  309.  return( Errors );
  310. }
  311.  
  312. ///////////////////////////////////////////////////////////////////////
  313. //  Project Client Implementation
  314. //  Encapsulates Project Manager Notifications
  315. ///////////////////////////////////////////////////////////////////////
  316. class _HOOKCLASS LocalProjClient : public ProjectClient
  317. {
  318.  public:
  319.  
  320.      // Ctor
  321.      LocalProjClient();
  322.  
  323.      // Required pure virtual implementations.
  324.      virtual void _HOOKEP OpenNotify(const char * name);
  325.      virtual void _HOOKEP CloseNotify();
  326.      virtual void _HOOKEP NodeDeleteNotify(ProjectNode);
  327.      virtual void _HOOKEP DependencyQueryResponder(ProjectNode ,const char *);
  328.  
  329. };
  330.  
  331. // Instantiated LocalProjectClient object.  
  332. static LocalProjClient LocalProjClient;
  333.  
  334. ///////////////////////////////////////////////////////////////////////
  335. // LocalProjectClient Ctor
  336. // Register Project Client with IDE using a Project requestor.
  337. ///////////////////////////////////////////////////////////////////////
  338. LocalProjClient::LocalProjClient()
  339. {
  340.  ProjectReq ps;
  341.  ps->RegisterProjectClient(this);
  342. }
  343.  
  344. ///////////////////////////////////////////////////////////////////////
  345. // LocalProjectClient::OpenNotify 
  346. // Register Callbacks.
  347. // Add Tools to Project Manager.
  348. ///////////////////////////////////////////////////////////////////////
  349. void _HOOKEP
  350. LocalProjClient::OpenNotify(const char * /*name */)
  351. {
  352.  ///////////////////////////////////////////////////////////////////////
  353.  // Register Callbacks
  354.  ///////////////////////////////////////////////////////////////////////
  355.  
  356.  // Obtain a ToolRequestor.
  357.  ToolReq ts;
  358.  
  359.  // Register callbacks for tools.
  360.  localToolClient.RegisterMyCallBacks( ts );
  361.  
  362.  ///////////////////////////////////////////////////////////////////////
  363.  // Add Tools
  364.  ///////////////////////////////////////////////////////////////////////
  365.  
  366.  // translateODLtoTLB
  367.  //    Convert .odl to .tlb files.
  368.  if ( !ts->ToolFind( ::translateODLtoTLB ) )
  369.      {
  370.       ToolInfo toolInfo;
  371.  
  372.       toolInfo.toolType    = Translator;
  373.       toolInfo.name        = ::translateODLtoTLB;
  374.       toolInfo.path        = 0;
  375.       toolInfo.flags       = OnLocalMenu;
  376.       toolInfo.menuName    = "OLE Compile to .TLB";
  377.       toolInfo.helpHint    = "Translate an ODL script to automation type library";
  378.       toolInfo.defCmdLine  = 0;
  379.       toolInfo.translateFrom = ".odl";
  380.       toolInfo.defaultFor  = ".odl";
  381.       toolInfo.translateTo = ".tlb";
  382.       toolInfo.launchId    = CALLBACK_LAUNCH_ID;
  383.  
  384.       ts->ToolAdd( &toolInfo );
  385.      }
  386.  
  387.  // msMKTypLib
  388.  //    Internal (to example) tool used for converting from ODL to TLB files.
  389.  if (!ts->ToolFind( ::msMkTypLib ) )
  390.      {
  391.       ToolInfo toolInfo;
  392.  
  393.       toolInfo.toolType    = Transfer;
  394.       toolInfo.name        = ::msMkTypLib;
  395.       toolInfo.path        = "mktyplib.exe";
  396.       toolInfo.flags       = ToolFlags(0);
  397.       toolInfo.menuName    = 0;
  398.       toolInfo.helpHint    = 0;
  399.       toolInfo.defCmdLine  = "/W0 /nocpp /nologo /tlb $OUTNAME tlbt@@@.tm~ ";
  400.       toolInfo.translateFrom = 0;
  401.       toolInfo.defaultFor  = 0;
  402.       toolInfo.translateTo = 0;
  403.       toolInfo.launchId    = DEFAULT_LAUNCH_ID;
  404.  
  405.       ts->ToolAdd( &toolInfo );
  406.      }
  407.  
  408.  // oleRegister
  409.  //    Internal (to example) tool used to invoke register.exe
  410.  if ( !ts->ToolFind( oleRegister ) )
  411.      {
  412.       ToolInfo toolInfo;
  413.  
  414.       toolInfo.toolType    = Transfer;
  415.       toolInfo.name        = ::oleRegister;
  416.       toolInfo.path        = "register.exe";
  417.       toolInfo.flags       = ToolFlags(0);
  418.       toolInfo.menuName    = 0;
  419.       toolInfo.helpHint    = 0;
  420.       toolInfo.defCmdLine  = 0;
  421.       toolInfo.translateFrom = 0;
  422.       toolInfo.defaultFor  = 0;
  423.       toolInfo.translateTo = 0;
  424.       toolInfo.launchId    = DEFAULT_LAUNCH_ID;
  425.  
  426.       ts->ToolAdd( &toolInfo );
  427.      }
  428.  
  429.  // extractAndBindTLB
  430.  //    Create .tlb from .exe/.dll bind .tlb back into .dll/.exe
  431.  if ( !ts->ToolFind( ::extractAndBindTLB ) )
  432.      {
  433.       ToolInfo toolInfo;
  434.  
  435.       toolInfo.toolType    = Translator;
  436.       toolInfo.name        = ::extractAndBindTLB;
  437.       toolInfo.path        = 0;
  438.       toolInfo.flags       = TargetTranslator | OnLocalMenu;
  439.       toolInfo.menuName    = "OLE Bind TypeLib";
  440.       toolInfo.helpHint    = "Extract Typelibrary and re-link target with .tlb";
  441.       toolInfo.defCmdLine  = "$TARGET";
  442.       toolInfo.translateFrom = ".dll;.exe;AppExpert;AppExpertDLL;";
  443.       toolInfo.defaultFor  = 0;
  444.       toolInfo.translateTo = 0;
  445.       toolInfo.launchId    = CALLBACK_LAUNCH_ID;
  446.       
  447.       ts->ToolAdd( &toolInfo );
  448.      }
  449.      
  450.  // oleExtractTLB
  451.  //    Extract TypeLib Information
  452.  if ( !ts->ToolFind( ::oleExtractTLB) )
  453.      {
  454.       ToolInfo toolInfo;
  455.  
  456.       toolInfo.toolType    = Translator;
  457.       toolInfo.name        = ::oleExtractTLB;
  458.       toolInfo.path        = "register.exe";
  459.       toolInfo.flags       = OnLocalMenu;
  460.       toolInfo.menuName    = "OLE Extract TypeLib";
  461.       toolInfo.helpHint    = "Extract automation type library from module";
  462.       toolInfo.defCmdLine  = "$TARGET -TypeLib=$NAME($TARGET).olb";
  463.       toolInfo.translateFrom = ".exe;.dll;AppExpert;AppExpertDLL;";
  464.       toolInfo.defaultFor  = 0;
  465.       toolInfo.translateTo = ".olb";
  466.       toolInfo.launchId    = DEFAULT_LAUNCH_ID;
  467.  
  468.       ts->ToolAdd( &toolInfo );
  469.      }
  470.  
  471.  // oleExtractReg
  472.  //    Create a .reg file from .exe/.dll
  473.  if ( !ts->ToolFind( ::oleExtractReg) )
  474.      {
  475.       ToolInfo toolInfo;
  476.  
  477.       toolInfo.toolType    = Translator;
  478.       toolInfo.name        = ::oleExtractReg;
  479.       toolInfo.path        = "register.exe";
  480.       toolInfo.flags       = OnLocalMenu;
  481.       toolInfo.menuName    = "OLE Extract Register";
  482.       toolInfo.helpHint    = "Extract Registry database script from module";
  483.       toolInfo.defCmdLine  = "$TARGET -RegServer=$NAME($TARGET).reg";
  484.       toolInfo.translateFrom = ".exe;.dll;AppExpert;AppExpertDLL;";
  485.       toolInfo.defaultFor  = 0;
  486.       toolInfo.translateTo = ".reg";
  487.       toolInfo.launchId    = DEFAULT_LAUNCH_ID;
  488.  
  489.       ts->ToolAdd( &toolInfo );
  490.      }
  491.  
  492.  // oleRegEditAdvanced
  493.  //    Tools Menu option to invoke regedit with /v parameter.
  494.  if ( !ts->ToolFind(::oleRegEditAdvanced))
  495.      {
  496.       ToolInfo toolInfo;
  497.  
  498.       toolInfo.toolType    = Transfer;
  499.       toolInfo.name        = ::oleRegEditAdvanced;
  500.       toolInfo.path        = "RegEdit.exe";
  501.       toolInfo.flags       = OnToolsMenu | OnLocalMenu;
  502.       toolInfo.menuName    = "OLE RegEdit Advanced";
  503.       toolInfo.helpHint    = "Invoke RegEdit using advanced display";
  504.       toolInfo.defCmdLine  = "/v";
  505.       toolInfo.translateFrom = 0;
  506.       toolInfo.defaultFor  = 0;
  507.       toolInfo.translateTo = 0;
  508.       toolInfo.launchId    = DEFAULT_LAUNCH_ID;
  509.  
  510.       ts->ToolAdd( &toolInfo );
  511.      }
  512.  
  513.  // generateAndAddSource
  514.  //    Create nodes (.cxx [.cpp] /.hxx [.h] ) in your target from .exe/.dll
  515.  if ( !ts->ToolFind(::generateAndAddSource))
  516.      {
  517.       ToolInfo toolInfo;
  518.  
  519.       toolInfo.toolType    = Translator;
  520.       toolInfo.name        = ::generateAndAddSource;
  521.       toolInfo.path        = 0;
  522.       toolInfo.flags       = OnLocalMenu;
  523.       toolInfo.menuName    = "OLE Generate Source";
  524.       toolInfo.helpHint    = "Generate class interface source";
  525.       toolInfo.defCmdLine  = 0;
  526.       toolInfo.translateFrom = ".exe;.dll;AppExpert;AppExpertDLL;";
  527.       toolInfo.defaultFor  = 0;
  528.       toolInfo.translateTo = 0;
  529.       toolInfo.launchId    = CALLBACK_LAUNCH_ID;
  530.  
  531.       ts->ToolAdd( &toolInfo );
  532.      }
  533.  
  534.  // oleAutoGen
  535.  //    Internal (to example) tool used to invoke Autogen.
  536.  if ( !ts->ToolFind( ::oleAutoGen ) )
  537.      {
  538.       ToolInfo toolInfo;
  539.  
  540.       toolInfo.toolType    = Transfer;
  541.       toolInfo.name        = ::oleAutoGen;
  542.       toolInfo.path        = "autogen.exe";
  543.       toolInfo.flags       = ToolFlags(0);
  544.       toolInfo.menuName    = 0;
  545.       toolInfo.helpHint    = 0;
  546.       toolInfo.defCmdLine  = 0;
  547.       toolInfo.translateFrom = 0;
  548.       toolInfo.defaultFor  = 0;
  549.       toolInfo.translateTo = 0;
  550.       toolInfo.launchId    = DEFAULT_LAUNCH_ID;
  551.  
  552.       ts->ToolAdd( &toolInfo );
  553.      }
  554. }
  555.  
  556. ///////////////////////////////////////////////////////////////////////
  557. // LocalProjectClient::CloseNotify, forced pure virtual implementation.
  558. ///////////////////////////////////////////////////////////////////////
  559. void _HOOKEP
  560. LocalProjClient::CloseNotify()
  561. {
  562. }
  563.  
  564. ////////////////////////////////////////////////////////////////////////////
  565. // LocalProjectClient::NodeDeleteNotify, forced pure virtual implementation.
  566. ////////////////////////////////////////////////////////////////////////////
  567. void _HOOKEP
  568. LocalProjClient::NodeDeleteNotify(ProjectNode)
  569. {
  570. }
  571.  
  572. ////////////////////////////////////////////////////////////////////////////////////
  573. // LocalProjectClient::DependencyQueryResponder, forced pure virtual implementation.
  574. ////////////////////////////////////////////////////////////////////////////////////
  575. void _HOOKEP
  576. LocalProjClient::DependencyQueryResponder(ProjectNode ,const char *)
  577. {
  578. }
  579.  
  580. // End of file
  581.