home *** CD-ROM | disk | FTP | other *** search
/ QBasic & Borland Pascal & C / Delphi5.iso / C / BC_502 / ADDON.PAK / MENUTEST.CPP < prev    next >
Encoding:
C/C++ Source or Header  |  1997-05-06  |  14.3 KB  |  448 lines
  1. /*:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
  2.  
  3.   menutest.cpp
  4.   Created: 10/24/95
  5.   Copyright (c) 1995, Borland International
  6.   $Revision:   1.15  $
  7.    
  8. :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::*/  
  9. #ifndef __AOEXPCH_H
  10.   #include "aoexpch.h"
  11. #endif
  12. #pragma hdrstop
  13.  
  14. #include "menutest.h"
  15.  
  16. static BOOL gCommandsEnabled = TRUE;
  17.  
  18. /*============================================================================
  19.  
  20.       MenuTestA
  21.             
  22. ============================================================================*/            
  23.  
  24. BOOL PASCAL globalCommandEnabler() {
  25.   return gCommandsEnabled;
  26. } 
  27.  
  28. //.............................................................................
  29. MenuTestA::MenuTestA() 
  30.   {
  31.   _startInitFailed = FALSE;
  32.   _menuServer = NULL;
  33.   _windowCmd = NULL;
  34.   _openFileCmd = NULL;
  35.   _pWindowMenuItem = NULL;
  36.   _pOpenFileMenu1 = NULL;
  37.   _pOpenFileMenu2 = NULL;
  38.   _pEditorMenu = NULL;
  39.   _pWindowRestoreMenu = NULL;
  40.   _myMenuClient = new myMenuClient;
  41.  
  42.   _cmdServer  = GET_INTERFACE(ICommandServer);
  43.   if ( !_cmdServer )
  44.     {     
  45.     _startInitFailed = TRUE;
  46.     return;
  47.     }
  48.  
  49.   _menuServer = GET_INTERFACE(IMenuServer);
  50.   if ( !_menuServer )
  51.     {     
  52.     _startInitFailed = TRUE;
  53.     return;
  54.     }
  55.  
  56.   // add a cmd and a menu to the windows menu
  57.   _windowCmd = _cmdServer->CreateCommand();
  58.   if ( _windowCmd )
  59.     {
  60.     // Fill in the cmd
  61.     _windowCmd->SetName( ::MakePolyString ("MinimizeAllExceptMessageView") );
  62.     _windowCmd->SetDescription( ::MakePolyString ("Mininimize all except the message view.") );
  63.     _windowCmd->SetScriptCommand( ::MakePolyString ("IDE.WindowMinimizeAll();IDE.ViewMessage();") );
  64.     _windowCmd->SetToolTip( ::MakePolyString ("Mininimize all except the message view.") );
  65.     _windowCmd->SetHelpHint( ::MakePolyString ("Mininimize all except the message view.")  );
  66.     _windowCmd->SetEnableFunction( globalCommandEnabler );
  67.     _windowCmd->AddRef();
  68.     _cmdServer->AddCommand( _windowCmd );
  69.     _pWindowMenuItem = _menuServer->CreateItem();
  70.     if ( _pWindowMenuItem )
  71.       {
  72.       _windowCmd->AddRef();
  73.       _pWindowMenuItem->SetCommand( _windowCmd );
  74.       _pWindowMenuItem->SetMenuText( ::MakePolyString ("&Window|AddOn Minimize All and Show Message View") );
  75.       _pWindowMenuItem->SetMenuType( MT_IDE );
  76.       //
  77.       // We've done everything except register this menu item, which won't
  78.       // work properly unless we defer it until after the IDE has had a 
  79.       // chance to assign a unique command ID for this command. It
  80.       // is safe to register the menu item when scripts are loading (your
  81.       // script could call back to your dll), when the first project open
  82.       // event arrives (by registering a project client with the project
  83.       // server) or in the case of this example, by waiting for some user 
  84.       // driven event - here it is the init of this test. (See 
  85.       // MenuTestA::Init() below)
  86.       //
  87.       }
  88.     }
  89.  
  90.   // add a file open cmd
  91.   _openFileCmd = _cmdServer->CreateCommand();
  92.   if ( _openFileCmd )
  93.     {
  94.     // Fill in the cmd
  95.     _openFileCmd->SetName( ::MakePolyString ("AnotherFileOpen") );
  96.     _openFileCmd->SetDescription( ::MakePolyString ("Another File Open") );
  97.     _openFileCmd->SetScriptCommand( ::MakePolyString ("IDE.FileOpen();") );
  98.     _openFileCmd->SetToolTip( ::MakePolyString ("A test of the command interface") );
  99.     _openFileCmd->SetHelpHint( ::MakePolyString ("A test of the command interface")  );
  100.     _openFileCmd->SetEnableFunction( globalCommandEnabler );
  101.     _openFileCmd->AddRef();
  102.     _cmdServer->AddCommand( _openFileCmd );
  103.     }
  104.   }
  105.  
  106. //.............................................................................
  107. MenuTestA::~MenuTestA() 
  108.   {
  109.   UnInit();
  110.  
  111.   // Remove the 2 commands we added
  112.   if ( _windowCmd )
  113.     {
  114.     _cmdServer->RemoveCommand( _windowCmd );
  115.     _windowCmd = NULL;
  116.     }
  117.   if ( _openFileCmd )
  118.     {
  119.     _cmdServer->RemoveCommand( _openFileCmd );
  120.     _openFileCmd = NULL;
  121.     }
  122.  
  123.   // Remove the menus we added
  124.   if ( _pWindowMenuItem )
  125.     {
  126.     _menuServer->UnRegisterItem( _pWindowMenuItem );
  127.     _pWindowMenuItem = NULL;
  128.     }
  129.   if ( _pOpenFileMenu1 )
  130.     {
  131.     _menuServer->UnRegisterItem( _pOpenFileMenu1 );
  132.     _pOpenFileMenu1 = NULL;
  133.     }
  134.   if ( _pOpenFileMenu2 )
  135.     {
  136.     _menuServer->UnRegisterItem( _pOpenFileMenu2 );
  137.     _pOpenFileMenu2 = NULL;
  138.     }
  139.   if ( _pWindowRestoreMenu )
  140.     {
  141.     _menuServer->UnRegisterItem( _pWindowRestoreMenu );
  142.     _pWindowRestoreMenu = NULL;
  143.     }
  144.   if ( _pEditorMenu )
  145.     {
  146.     _menuServer->UnRegisterItem( _pEditorMenu );
  147.     _pEditorMenu = NULL;
  148.     }
  149.  
  150.   // Release the 2 servers
  151.   if ( _cmdServer ) 
  152.     {
  153.     _cmdServer->Release();
  154.     _cmdServer = NULL;
  155.     }
  156.   if ( _menuServer ) 
  157.     {
  158.     _menuServer->Release();
  159.     _menuServer = NULL;
  160.     }
  161.   if ( _myMenuClient ) 
  162.     {
  163.     _myMenuClient->Release();
  164.     }
  165.   }
  166. //.............................................................................
  167. BOOL MenuTestA::Init() 
  168.   {
  169.   if ( _startInitFailed )
  170.     {
  171.     OutStr( "MenuTestA was inited at startup but it faiuled" );
  172.     }
  173.   else
  174.     {
  175.     _pWindowMenuItem->AddRef();
  176.     _menuServer->RegisterItem( _pWindowMenuItem, NULL );
  177.     OutStr( "MenuTestA Init()" );
  178.     }
  179.   return TRUE;
  180. }
  181. //.............................................................................
  182. void MenuTestA::UnInit() 
  183.   {
  184.   OutStr( "MenuTestA::UnInit()" );
  185.   }
  186. //.............................................................................
  187. const char * MenuTestA::GetName() 
  188.   {
  189.   return "MenuTestA";
  190.   }
  191. //.............................................................................
  192. const char * MenuTestA::GetTestDescription( int testNum ) 
  193.   {
  194.   switch ( testNum )
  195.     {
  196.     case 1:
  197.       return "Add Addon menus to frame, Window|Restore all, and editor popup menus.";
  198.     case 2:
  199.       return "Toggle command enabler for all addon menu items.";
  200.     case 3:
  201.       return "Toggle editor popup Addon item availability.";
  202.     case 4:
  203.       return "Remove all menus added";
  204.     }
  205.   return "This test not implemented.";
  206.   }  
  207. //.............................................................................
  208. void MenuTestA::DoTest( int testNum ) 
  209.   {
  210.   if ( !_menuServer ) 
  211.     {
  212.     OutStr( "Menu Server not initialized!" );
  213.     return;
  214.     }
  215.   switch ( testNum ) 
  216.     {
  217.     case 1:
  218.       if ( _openFileCmd )
  219.         {
  220.         _pOpenFileMenu1 = _menuServer->CreateItem();
  221.         if ( _pOpenFileMenu1 )
  222.           {
  223.           _openFileCmd->AddRef();
  224.           _pOpenFileMenu1->SetCommand( _openFileCmd );
  225.           _pOpenFileMenu1->SetMenuText( ::MakePolyString ("&Addon|AddOnOpenFile...") );
  226.           _pOpenFileMenu1->SetMenuType( MT_IDE );
  227.           _pOpenFileMenu1->AddRef();
  228.           _menuServer->RegisterItem( _pOpenFileMenu1, NULL );
  229.           }
  230.         _pOpenFileMenu2 = _menuServer->CreateItem();
  231.         if ( _pOpenFileMenu2 )
  232.           {
  233.           _openFileCmd->AddRef();
  234.           _pOpenFileMenu2->SetCommand( _openFileCmd );
  235.           _pOpenFileMenu2->SetMenuText( ::MakePolyString ("&Addon|Another|AddOnOpenFile...") );
  236.           _pOpenFileMenu2->SetMenuType( MT_IDE );
  237.           _pOpenFileMenu2->AddRef();
  238.           _menuServer->RegisterItem( _pOpenFileMenu2, NULL );
  239.           }
  240.         _pWindowRestoreMenu = _menuServer->CreateItem();
  241.         if ( _pWindowRestoreMenu )
  242.           {
  243.           _openFileCmd->AddRef();
  244.           _pWindowRestoreMenu->SetCommand( _openFileCmd );
  245.           _pWindowRestoreMenu->SetMenuText( ::MakePolyString ("&Window|&Restore all|AddOnOpenFile...") );
  246.           _pWindowRestoreMenu->SetMenuType( MT_IDE );
  247.           _pWindowRestoreMenu->AddRef();
  248.           _menuServer->RegisterItem( _pWindowRestoreMenu, NULL );
  249.           }
  250.         _pEditorMenu = _menuServer->CreateItem();
  251.         if ( _pEditorMenu )
  252.           {
  253.           _openFileCmd->AddRef();
  254.           _pEditorMenu->SetCommand( _openFileCmd );
  255.           _pEditorMenu->SetMenuText( ::MakePolyString ("AddOnOpenFile...") );
  256.           _pEditorMenu->SetMenuType( MT_Editor );
  257.           _pEditorMenu->AddRef();
  258.           _menuServer->RegisterItem( _pEditorMenu, _myMenuClient );
  259.           }
  260.         }
  261.       break;
  262.     case 2:
  263.       gCommandsEnabled = !gCommandsEnabled;
  264.       OutStr( FormatStr( "Addon menu commands %s", gCommandsEnabled? "Enabled" : "Disabled" ) );
  265.       break;      
  266.       
  267.     case 3:
  268.       _myMenuClient->MenuAvailable( !_myMenuClient->MenuAvailable() );
  269.       OutStr( FormatStr( "Edit menu AddOn item is %s", 
  270.             _myMenuClient->MenuAvailable()? "Available" : "Unavailable" ) );
  271.       break;
  272.     case 4:
  273.       {
  274.       OutStr( "Removing all AddOn menu items." );
  275.       if ( _pOpenFileMenu1 )
  276.         {
  277.         _menuServer->UnRegisterItem( _pOpenFileMenu1 );
  278.         _pOpenFileMenu1 = NULL;
  279.         }
  280.       if ( _pOpenFileMenu2 )
  281.         {
  282.         _menuServer->UnRegisterItem( _pOpenFileMenu2 );
  283.         _pOpenFileMenu2 = NULL;
  284.         }
  285.       if ( _pWindowRestoreMenu )
  286.         {
  287.         _menuServer->UnRegisterItem( _pWindowRestoreMenu );
  288.         _pWindowRestoreMenu = NULL;
  289.         }
  290.       if ( _pEditorMenu )
  291.         {
  292.         _menuServer->UnRegisterItem( _pEditorMenu );
  293.         _pEditorMenu = NULL;
  294.         }
  295.       }
  296.       break;
  297.  
  298.     default: 
  299.       {
  300.       OutStr( FormatStr( "Test #%d Not Implemented!", testNum ) );
  301.       }
  302.     }
  303.   }
  304.  
  305. /*============================================================================
  306.  
  307.   MenuTestB
  308.   
  309. =============================================================================*/ 
  310.  
  311. //.......... command enablers ---------------
  312. static BOOL cmd1Enabled = FALSE;
  313. static BOOL cmd2Enabled = TRUE;
  314. static BOOL cmd3Enabled = FALSE;
  315. static BOOL cmd4Enabled = TRUE;
  316.  
  317.  
  318. BOOL PASCAL cmd1Enabler() {
  319.   return cmd1Enabled;
  320. } 
  321. BOOL PASCAL cmd2Enabler() {
  322.   return cmd2Enabled;
  323. } 
  324. BOOL PASCAL cmd3Enabler() {
  325.   return cmd3Enabled;
  326. } 
  327. BOOL PASCAL cmd4Enabler() {
  328.   return cmd4Enabled;
  329. } 
  330.  
  331.  
  332. //.............................................................................
  333. MenuTestB::MenuTestB() {
  334.   _cmdServer  = GET_INTERFACE(ICommandServer);
  335.   _menuServer = GET_INTERFACE(IMenuServer);
  336.   _cmd1 = _cmdServer->CreateCommand();
  337.   _cmd2 = _cmdServer->CreateCommand();
  338.   _cmd3 = _cmdServer->CreateCommand();
  339.   _cmd4 = _cmdServer->CreateCommand();
  340.   _cmd1->SetName( MakePolyString( "AddonCommand1" ) );
  341.   _cmd2->SetName( MakePolyString( "AddonCommand2" ) );
  342.   _cmd3->SetName( MakePolyString( "AddonCommand3" ) );
  343.   _cmd4->SetName( MakePolyString( "AddonCommand4" ) );
  344.   _cmd1->SetScriptCommand( MakePolyString( "AddonTestCommand1();" ) );
  345.   _cmd2->SetScriptCommand( MakePolyString( "AddonTestCommand2();" ) );
  346.   _cmd3->SetScriptCommand( MakePolyString( "AddonTestCommand3();" ) );
  347.   _cmd4->SetScriptCommand( MakePolyString( "AddonTestCommand4();" ) );
  348.   _cmd1->SetEnableFunction( cmd1Enabler );
  349.   _cmd2->SetEnableFunction( cmd2Enabler );
  350.   _cmd3->SetEnableFunction( cmd3Enabler );
  351.   _cmd4->SetEnableFunction( cmd4Enabler );
  352.   _cmd1->SetHelpHint( MakePolyString( "Help for addon command #1" ) );
  353.   _cmd2->SetHelpHint( MakePolyString( "Help for addon command #2" ) );
  354.   _cmd3->SetHelpHint( MakePolyString( "Help for addon command #3" ) );
  355.   _cmd4->SetHelpHint( MakePolyString( "Help for addon command #4" ) );
  356.   _menu1 = _menuServer->CreateItem();
  357.   _menu2 = _menuServer->CreateItem();
  358.   _menu3 = _menuServer->CreateItem();
  359.   _menu4 = _menuServer->CreateItem();
  360.   _cmd1->AddRef();
  361.   _cmd2->AddRef();
  362.   _cmd3->AddRef();
  363.   _cmd4->AddRef();
  364.   _cmdServer->AddCommand( _cmd1 );
  365.   _cmdServer->AddCommand( _cmd2 );
  366.   _cmdServer->AddCommand( _cmd3 );
  367.   _cmdServer->AddCommand( _cmd4 );
  368.   _cmd1->AddRef();
  369.   _cmd2->AddRef();
  370.   _cmd3->AddRef();
  371.   _cmd4->AddRef();
  372.   _menu1->SetCommand( _cmd1 );
  373.   _menu2->SetCommand( _cmd2 );
  374.   _menu3->SetCommand( _cmd3 );
  375.   _menu4->SetCommand( _cmd4 );
  376.   _menu1->SetMenuText( MakePolyString( "&AddOn Test|Command &1" ) );
  377.   _menu2->SetMenuText( MakePolyString( "&AddOn Test|Command &2" ) );
  378.   _menu3->SetMenuText( MakePolyString( "&AddOn Test|Command &3" ) );
  379.   _menu4->SetMenuText( MakePolyString( "&AddOn Test|Command &4" ) );
  380.   _menu1->SetMenuType( MT_IDE );
  381.   _menu2->SetMenuType( MT_IDE );
  382.   _menu3->SetMenuType( MT_IDE );
  383.   _menu4->SetMenuType( MT_IDE );
  384. }
  385.  
  386. //.............................................................................
  387. MenuTestB::~MenuTestB() {
  388.   UnInit();
  389.   _menuServer->UnRegisterItem( _menu1 );
  390.   _menuServer->UnRegisterItem( _menu2 );
  391.   _menuServer->UnRegisterItem( _menu3 );
  392.   _menuServer->UnRegisterItem( _menu4 );
  393.   _cmdServer->RemoveCommand( _cmd1 ); 
  394.   _cmdServer->RemoveCommand( _cmd2 ); 
  395.   _cmdServer->RemoveCommand( _cmd3 ); 
  396.   _cmdServer->RemoveCommand( _cmd4 ); 
  397.   _menuServer->Release();
  398.   _cmdServer->Release();
  399. }
  400. //.............................................................................
  401. BOOL MenuTestB::Init()  {
  402.   OutStr( "MenuTestB::Init()" );
  403.   return TRUE;
  404. }
  405. //.............................................................................
  406. void MenuTestB::UnInit() {
  407.   OutStr( "MenuTestB::UnInit()" );
  408. }
  409. //.............................................................................
  410. const char * MenuTestB::GetName() {
  411.   return "MenuTestB";
  412. }
  413. //.............................................................................
  414. const char * MenuTestB::GetTestDescription( int testNum ) {
  415.   switch ( testNum ) {
  416.     case 1:
  417.       return "Add menu Items.";
  418.     case 2:
  419.       return "Toggle enablers.";
  420.   }
  421.   return "This test not implemented.";
  422. }  
  423. //.............................................................................
  424. void MenuTestB::DoTest( int testNum ) {
  425.   switch ( testNum ) {
  426.     case 1:
  427.       OutStr( "Adding menu items." );
  428.       _menu1->AddRef(); 
  429.       _menu2->AddRef(); 
  430.       _menu3->AddRef(); 
  431.       _menu4->AddRef(); 
  432.       _menuServer->RegisterItem( _menu1, NULL );
  433.       _menuServer->RegisterItem( _menu2, NULL );
  434.       _menuServer->RegisterItem( _menu3, NULL );
  435.       _menuServer->RegisterItem( _menu4, NULL );
  436.       break;        
  437.     case 2:
  438.       OutStr( "Toggling enablers." );
  439.       cmd1Enabled = !cmd1Enabled;
  440.       cmd2Enabled = !cmd2Enabled;
  441.       cmd3Enabled = !cmd3Enabled;
  442.       cmd4Enabled = !cmd4Enabled;
  443.       break;            
  444.     default: 
  445.       OutStr( FormatStr( "Test #%d Not Implemented!", testNum ) );
  446.   }
  447. }
  448.