Extended Interface for Toolbars

• Download project and source - 16 Kb

Problem

ToolbarButtons in .NET lack the basic capability of performing a task on their own.  It would be very convenient to set up all toolbar events directly inside of the toolbar itself.

The current accepted practice is to override the ButtonClick event and use a case statement to decide what button was pressed and what function should be called.   The scribble example given by Microsoft is displayed below.

private void toolBar1_ButtonClick(object sender,
                       System.Windows.Forms.ToolBarButtonClickEventArgs e) 
{
   if(      e.Button == newButton     ) { New( ); } 
   else if( e.Button == openButton    ) { Open( ); } 
   else if( e.Button == saveButton    ) { Save( ); } 
   else if( e.Button == previewButton ) { PrintPreview( ); } 
   else if( e.Button == printButton   ) { Print( ); } 
   else if( e.Button == helpButton    ) { ShowHelpTopics(); }
 } 

Or you could devise some sort of method for looking at the string text. I've seen one example that was similar to this.

void ToolBarOnClick( object obj, ToolBarButtonClickEventArgs e )
{
   switch( e.Button.Text )
   {
      case "&Open":
         ...
         break;
      case "&Close":

         ...

         break;

   }

}

Another process described by Petzolt will convert the ToolBarButtonClickEventArgs parameter into a MenuItem.

void ToolBarOnClick( object obj, ToolBarButtonClickEventArgs e )
{
ToolBarButton btn = e.Button;
   MenuItem      mnu = (MenuItem) btn.Tag;
  
   mnu.PerformClick( );
}

Hopefully, we can overcome these shortcoming with a quick and simple extended property.  Plus, give you a sample to create your own extended interfaces.

Background

The IExtenderProvider is a tremendously powerful tool when used in conjunction with the interface, yet the syntax is quite simple.  Basically you need to create a Get/Set pairing similar to a standard C# property, but with the full name displayed.

The ProvideProperty tag tells the interface that you are adding a property called "ToolbarFunction" to all of your components in your current development.   The CanExtend function narrows the components that receive this property to only ToolBarButtons.  Each ToolBarButton will receive a new property that will allow each button to be assigned to a specific MenuItem.

[ProvideProperty( "ToolbarFunction", typeof(Component)) ] 
public class ToolbarFunction : Component, IExtenderProvider 
{ 
   public void SetToolbarFunction( Component pComponent, 
                                   MenuItem pMenuItem ) 

       ...
   public MenuItem GetToolbarFunction( Component pComponent ) 

       ...


   public bool CanExtend( object pComponent )
   { 
      return( pComponent is ToolBarButton ); 
   } 
}

The source code for the interface is quite simple, but I'll refrain from discussing the actual coding process to keep this article on a basic level.

1. Add the ToolBarFunction component to .NET

After copying the Extended Interface DLL (ExtendedInterface.DLL) to your desired destination, you will need to add it permanently to your toolbox. 

1. With the toolbox open, right click the list to select 'Customize Toolbox.
2. Select the tab .NET Framework Components
3. Click Browse...
4. Click on ExtendedInterface.DLL
5. Click OK.

The Toolbox should have two new components: StatusMessage and ToolBarFunction.

The other component  StatusMessage was discussed in an earlier article.

2. Optional: Give useful names to your menus

An optional step is to use meaningful names for the (Name) parameter of each MenuItem. Names like MenuItem23 are certainly usable, but when you have to manage functionality based on those names, it can get quite complicated.

3. Add the ToolBarFunction component to your form.

Now it's time to add the ToolBarFunction to your application. Drag one over from your Toolbox and it should appear below the form with the other components.

4. Assign MenuItem functionality to your toolbar.

You will, of course, need to have a ToolBar on your form. Drag one over from your Toolbox if you haven't already.

1. Display the properties of your ToolBar.
2. Click on the 'Buttons' collection and make sure you have at least one button. Call it anything you wish, I used ToolOpen.
3. You will see a 'ToolbarFunction' property that the component has added for you. Use the drop down list to view all of your menu items.
4. Select the MenuItem that you want the button to use when clicked.
5. Click OK to close the collection.

5. Test your application

Once you have a ToolBarButton tied into a MenuItem, clicking on a button will have the same effect as clicking the menu! That was just too easy.

Source Code

[ProvideProperty( "ToolbarFunction", typeof(Component)) ] 
public class ToolbarFunction : Component, IExtenderProvider 
{ 
   ToolBar m_ToolBar = null; 
   Hashtable m_Dictionary = new Hashtable( ); 
 
   public void SetToolbarFunction( Component pComponent, MenuItem pMenuItem ) 
   { 
      if( ! m_Dictionary.Contains( pComponent )) 
      {  
         m_Dictionary.Add( pComponent, pMenuItem ); 
 
         if( m_ToolBar == null ) 
         {
            ToolBarButton pToolBarButton = pComponent as ToolBarButton; 
 
            if( pToolBarButton != null ) 
            { 
               m_ToolBar = pToolBarButton.Parent as ToolBar; 
 
               if( m_ToolBar != null ) 
                  m_ToolBar.ButtonClick += 
                     new ToolBarButtonClickEventHandler( Handle_ToolbarButtonClick );
            }
         }
      }
      else 
      { 
         m_Dictionary[ pComponent ] = pMenuItem;
      }
   } 
 
   public MenuItem GetToolbarFunction( Component pComponent ) 
   { 
      if( m_Dictionary.Contains( pComponent )) 
         return (MenuItem) m_Dictionary[ pComponent ]; 
 
      return null;
   }
 
   public bool CanExtend( object pComponent )
   { 
      return( pComponent is ToolBarButton ); 
   } 
 
   private void Handle_ToolbarButtonClick( object pComponent, 
                                           ToolBarButtonClickEventArgs e ) 
   { 
      if( m_Dictionary.Contains( e.Button )) 
      { 
         MenuItem pMenuItem = (MenuItem) m_Dictionary[ e.Button ]; 
 
         if( pMenuItem != null ) 
            pMenuItem.PerformClick( ); 
      }
   } 
}

You must Sign In to use this message board.

FAQ    Noise Tolerance Very HighHighMediumLowVery Low   Layout Expand Posts & RepliesThread ViewNo JavascriptNo JS + Preview   Per page 102550

Msgs 1 to 14 of 14 (Total in Forum: 14) (Refresh) FirstPrevNext

want to add CasussesValidation Property to each Button of the Toolbar Tariq Rahim 10:54 14 Apr '05   Hi I want to add the CasusesValidation Property to each Button of the Toolbar so that i can validate the other controls. how i will do please tell me in deatil TAriq Sign In·View Thread·PermaLink An alternative approach from msdn Willem_G 5:36 26 Aug '04   Hi, The pattern described in "Use Design Patterns to Simplify the Relationship Between Menus and Form Elements in .NET" (http://msdn.microsoft.com/library/default.asp?url=/msdnmag/issues/02/10/commandmanagement/TOC.ASP) gives a nice alternative. Basically, it allows you to couple User Interface elements to Commands. You have e.g. a "Delete" command, and you can couple it to your [toolbar] buttons and menu-items. You can also define an update handler that will enable/disable the UI Item as needed. (Just as MFC has ....). Regards, Willem Sign In·View Thread·PermaLink 5.00/5 (1 vote) Text on Toolbar button not shown Boogie 19:20 3 Nov '03   I am still using VS.Net ver 2002. I'm also .Net newbie. I don't understand why the text won't show on my toolbar. It showed on a test project which I didn't rename anything. And... how can I add images to the toolbar buttons? Thanks for any help. Sign In·View Thread·PermaLink 5.00/5 (1 vote) .Net 2003 made the code unusable... psdavis 4:35 28 Oct '03   Unfortunately, an undocumented change made the 'pushed' event into a boolean property. Hence, I can no longer watch for when a toolbar button was pushed. My apologies. Sign In·View Thread·PermaLink 1.00/5 (1 vote) order in InitializeComponent Anonymous 1:01 23 Sep '02   Hello, I've done some testing with ToolbarFunction and encountered to the following problem: After changing a property (e.g backcolor) of the mainform in IDE-Designer the code in InitializeComponent is rearranged to a wrong order. // // mTBBFileNew // this.mTBBFileNew.Text = "TheFileNew"; this.mToolbarFunction.SetToolbarFunction(this.mTBBFileNew, this.mMIFileNew); // // mToolBar // this.mToolBar.Buttons.AddRange(new System.Windows.Forms.ToolBarButton[] { this.mTBBFileNew}); this.mToolBar.DropDownArrows = true; ... In this case mTBBFileNew.Parent is null an no ClickHandler is added. Is there any remedy? Franz Sign In·View Thread·PermaLink Re: order in InitializeComponent Frank Hileman 9:57 31 Oct '02   A solution is to add a property to ToolbarFunction, ToolBar, which is intialized when placed on the form, has both get and set. Then code will be serialized to set this in IntializeComponents(), before any functions called on the component. Unfortunately, now it will not work with multiple toolbars:(. But at least the order will not matter in InitializeComponent(). Regards, Frank Hileman Sign In·View Thread·PermaLink Re: order in InitializeComponent Heath Stewart 3:42 23 Jan '03   Actually, a better way that won't break anything is for the component to support ISupportInitialize. Things like the StatusBar and AxHost use this and you'll notice in the "Component Designer generated code" region that these classes use BeginInitEndInit when done. This would allow Phillip (I hope he gets this, too) to set a flag in his code, batch the components that need to be added to the internal dictionary and hooked-up to event handlers, and do them all at once. He could just check a flag, add these things to a hashtable, then, in EndInit, enumerate through the hashtable and setup the event handlers. This is what the ISupportInitialize interface was designed for. Nice, huh? "Well, I wouldn't say I've been missing it, Bob." - Peter Gibbons Sign In·View Thread·PermaLink Re: order in InitializeComponent roelang@hotmail.com 21:29 25 Sep '03   Heath, Can you post your sample using ISupportInitialize? Thanks Roel Sign In·View Thread·PermaLink Re: order in InitializeComponent Heath Stewart 2:18 26 Sep '03   I don't have anything available that I can post anymore. What don't you understand about it? When ISupportInitialize.BeginInit() is called, you signal your control to wait to do something. When ISupportInitialize.EndInit() is called, you do what you were before. Your Windows Forms will typically do this for layout. In BeginInit, it basically sets a flag that disables layout while properties are being set and controls added (in InitializeComponent). When that's all done, the call to EndInit invokes the layout functionality. This saves time while initializing a form that you can't even see yet (not until Load). Look at the documentation (always important) for the "about" page of ISupportInitialize. There is a list of a lot of classes that use it. Take a look at them for more examples. Take a look at the IL using ildasm.exe for implementation details, or use a decompiler like .NET Reflector[^] to see source.   -----BEGIN GEEK CODE BLOCK----- Version: 3.21 GCS/G/MU d- s: a- C++++ UL@ P++(+++) L+(--) E--- W+++ N++ o+ K? w++++ O- M(+) V? PS-- PE Y++ PGP++ t++@ 5 X+++ R+@ tv+ b(-)>b++ DI++++ D+ G e++>+++ h---* r+++ y+++ -----END GEEK CODE BLOCK----- Sign In·View Thread·PermaLink Multiple Toolbars psdavis 4:54 23 Jul '02   If you need to have multiple toolbars, I have updated the code to handle them. using System; using System.Collections; using System.ComponentModel; using System.Windows.Forms; namespace ExtendedInterface { /// /// Extended Interface that can assign a ToolBarButton to act like a MenuItem was selected /// [ProvideProperty( "ToolBarFunction", typeof(Component)) ] public class ToolBarFunction : Component, IExtenderProvider { ArrayList m_ToolBar = new ArrayList( ); Hashtable m_Dictionary = new Hashtable( ); /// /// Set each ToolBarButton to a specific MenuItem /// public void SetToolBarFunction( Component pComponent, MenuItem pMenuItem ) { if( ! m_Dictionary.Contains( pComponent )) { ToolBarButton pToolBarButton = pComponent as ToolBarButton; if( pToolBarButton == null || pMenuItem == null ) return; m_Dictionary.Add( pToolBarButton, pMenuItem ); // Now we need to make sure that the toolbar that we have set has it's 'click' overridden ToolBar pToolBar = pToolBarButton.Parent as ToolBar; if( pToolBar == null ) return; foreach( object pCurrToolBar in m_ToolBar ) { if( pCurrToolBar == pToolBar ) return; } pToolBar.ButtonClick += new ToolBarButtonClickEventHandler( Handle_ToolbarButtonClick ); pToolBarButton.Pushed += new ToolBarButtonClickEventHandler( Handle_ToolbarButtonPushed ); m_ToolBar.Add( pToolBar ); } else { m_Dictionary[ pComponent ] = pMenuItem; } } /// /// Return the MenuItem that is assigned to each ToolBarButton /// public MenuItem GetToolBarFunction( Component pComponent ) { if( m_Dictionary.Contains( pComponent )) return (MenuItem) m_Dictionary[ pComponent ]; return null; } /// /// Definition of the components that will be extended /// public bool CanExtend( object pComponent ) { return( pComponent is ToolBarButton ); } private void Handle_ToolbarButtonClick( object pComponent, ToolBarButtonClickEventArgs e ) { if( m_Dictionary.Contains( e.Button )) { MenuItem pMenuItem = (MenuItem) m_Dictionary[ e.Button ]; if( pMenuItem != null ) pMenuItem.PerformClick( ); } } private void Handle_ToolbarButtonPushed( object pComponent, ToolBarButtonClickEventArgs e ) { if( m_Dictionary.Contains( e.Button )) { MenuItem pMenuItem = (MenuItem) m_Dictionary[ e.Button ]; if( pMenuItem != null ) pMenuItem.PerformClick( ); } } } /// /// Extended Interface that can assign a ToolBarButton into a group /// [ProvideProperty( "ToolBarGroup", typeof(Component)) ] [DefaultValue( "0" )] public class ToolBarGroup : Component, IExtenderProvider { ArrayList m_ToolBar = new ArrayList( ); Hashtable m_Dictionary = new Hashtable( ); /// /// Group multiple ToolBarButtons into a single group /// public void SetToolBarGroup( Component pComponent, int iGroup ) { if( ! m_Dictionary.Contains( pComponent )) { ToolBarButton pToolBarButton = pComponent as ToolBarButton; if( pToolBarButton == null || iGroup <= 0 ) return; m_Dictionary.Add( pToolBarButton, iGroup ); // Now we need to make sure that the toolbar that we have set has it's 'click' overridden ToolBar pToolBar = pToolBarButton.Parent as ToolBar; if( pToolBar == null ) return; foreach( object pCurrToolBar in m_ToolBar ) { if( pCurrToolBar == pToolBar ) return; } pToolBar.ButtonClick += new ToolBarButtonClickEventHandler( Handle_ToolBarGroupClick ); m_ToolBar.Add( pToolBar ); } else { m_Dictionary[ pComponent ] = iGroup; } } /// /// Return the MenuItem that is assigned to each ToolBarButton /// public int GetToolBarGroup( Component pComponent ) { if( m_Dictionary.Contains( pComponent )) return (int) m_Dictionary[ pComponent ]; return 0; } /// /// Definition of the components that will be extended /// public bool CanExtend( object pComponent ) { return( pComponent is ToolBarButton ); } private void Handle_ToolBarGroupClick( object pComponent, ToolBarButtonClickEventArgs e ) { if( m_Dictionary.Contains( e.Button )) { int iGroup = (int) m_Dictionary[ e.Button ]; IDictionaryEnumerator pEnumerator = m_Dictionary.GetEnumerator( ); while( pEnumerator.MoveNext( )) { if( (int) pEnumerator.Value != iGroup ) continue; ToolBarButton pButton = pEnumerator.Key as ToolBarButton; if( e.Button == pButton ) pButton.Pushed = true; else pButton.Pushed = false; } } } } } Sign In·View Thread·PermaLink Great! dolphinegd 5:40 19 Sep '03   Thanks Sign In·View Thread·PermaLink Re: Multiple Toolbars svkoli 6:17 28 Sep '03   Great stuff, but could you please tell me what you ment with the following part of code, where you tried to assign a ToolBarButtonClickEventHandler to a bool? psdavis wrote: pToolBarButton.Pushed += new ToolBarButtonclickEventHandler( Handle_ToolbarButtonPushed ); I dont't see what to change in your code to achieve what you intended. Should it be another handler for the ButtonClick-Event? thx in advance, svkoli Sign In·View Thread·PermaLink Re: Multiple Toolbars psdavis 3:26 29 Sep '03   Unfortunately 2003 broke the code and it no longer works. I'm trying to find a work around or the reason .net changed Pushed from an event to a boolean, and what the work around is. Pushed went from 'I pushed the button' to a boolean 'Is the button pushed'. Sign In·View Thread·PermaLink 2.00/5 (1 vote) Re: Multiple Toolbars Le_MuLoT 5:03 26 Sep '05   Yeh right, VS2003 "broke" the code, but matter or not you should modify the InitializeComponent() method in Designer generated code and close your eyes at the "do not modify the contents of this method with the code editor." Note : this is the begining of a fight between you and VS2003 generated code automation... but this way, you can compile and everything work fine. Take that VS2003 !!! Sign In·View Thread·PermaLink

Last Visit: 7:15 23 Nov '09     Last Update: 7:15 23 Nov '09 1