Simplifying GUI development with Actions

Introduction

Are you a Delphi developer? If so, then you probably miss the useful ActionList component. I decided to code some component that mimics the Delphi component behavior. What's ActionList? It is a collection of actions, which could customize the look and behavior of some GUI elements. For example, an action can define the text shown on a button and the action which this button fires. The advantage of action is that you can use the same action with several components e.g. Print toolbar button and menu item, and you need to define the action (event) only once. You can also centrally enable or disable all the GUI components associated with the action.

How I implemented it?

The ActionList is implemented as an IExtenderProvider (ActionListProvider), which adds to ButtonBase and ToolStripItem successors a new Action property to define the actions. The Action has two properties Enabled and Text. Both will set the same properties of the linked control. There is an event Execute which is fired through the Click event of the control.

Using the ActionListProvider

Using the ActionListProvider is very easy. Follow these steps:

Install the ActionListProvider into VS.NET.
Add an ActionListProvider on the form.
Add some new actions, through ActionListProvider's Action property.
Define the Action's Execute event handler.
Add some Buttons.
Link them with Actions.
Now you can centrally enable and disable all the controls associated with this Action.

Points of interest

The code is written in .NET 2.0 and can be extended according to your needs.

License

This article has no explicit license attached to it but may contain usage terms in the article text or the download files themselves. If in doubt please contact the author via the discussion board below.

A list of licenses authors might use can be found here

About the Author

Burkovsky

Web Developer

Germany

Member

Article Top

Poor

Excellent

Add a reason or comment to your vote: x
Votes of 3 or less require a comment

Comments and Discussions

You must Sign In to use this message board. (secure sign-in)

Search this forum
	Profile popups Noise Layout Per page

My vote of 5

ambush_2000

15:39 8 Dec '10

It's useful!
Sign In·View Thread·Permalink

Application Settings [modified]

sithiro

5:59 10 Feb '07

I'm somewhat close to finding a similar to TAction behaviour by using ApplicationSettings and PropertyBindings. However I'm new to C# and the problem I have is after setting a property from within the designer (remember the goal is to write as less code as possible) C# adds this to the form's source page:

this.button1.Enabled = global::WindowsApplication1.Properties.Settings.Default.Test;

Now, accessing this would be with something like this:

MessageBox.Show(Properties.Settings.Default.Test.ToString());

The problem is that this is a read-only property. What am I missing? I'm sure there's a way... If not like this, with DataBinding perhapps.

Of course this would only be usefull for some state in controls, still don't have a clue on how to handle the Events.

Why not an Interface ?

M.Genuini

4:51 27 Dec '05

Great work.
Caming from a Delphi experience, where ActionList is a powerful tools, i was trying to reproduce it on .NET too.
In your solution i see that the only controls that can act as an ActionClient are those derived from ButtonBase and ToolStripItem. The solution i was trying to reach is a bit different and i'd like to ask you, what do you think about it: i introduced an Interface (IactionClient) with some methods and properties, and every control that wants to act as an action client should implement such interface (pratically in IActionClient there are the method to update the Client Control when an action property change and a wrapper to associate the Execute event of the action with a choosen event of the client control). I know the the con's of this approach are that for every control i want to transform in an ActionClient i must implement this interface, but, from the other point of view, in this way, every component can became an ActionClient.
If you want i can send you my code (I don't post it here because is far from be complete).

Re: Why not an Interface ?

dmitry44

23:33 1 Apr '06

M.Genuini wrote: I don't post it here because is far from be complete Hi! Interesting. Could you plan to publish your component? ---- Dmitry
Sign In·View Thread·Permalink

Another ActionList on Code Project

Peter Gummer

15:34 21 Nov '05

There's been another ActionList on Code Project for the last three years: http://www.codeproject.com/cs/miscctrl/actionlist.asp Has anyone tried them both?
Sign In·View Thread·Permalink	2.00/5 (1 vote)

Re: Another ActionList on Code Project

Eric Engler

6:48 28 Feb '06

That other one is a more complete implementation, and it works on VS 2002, and includes icons and update events. However, there's some kind of bug in it that causes the VS 2003 form designer to remove Execute event handlers. I think the best solution might be to start with this one, and add some of the missing functionality to it.
Sign In·View Thread·Permalink	1.00/5 (1 vote)

.NET 1.1 Version

TylorDurden

1:15 1 Jul '05

Hi, great Idea, but could you please provide a version for Visual Studio 2003 with the Framework 1.1? It would be great!! Thanks a lot and a nice day
Sign In·View Thread·Permalink

Re: .NET 1.1 Version

Burkovsky

8:32 1 Jul '05

Delete the lines with ToolStripItem. And it should work.
Sign In·View Thread·Permalink

Re: .NET 1.1 Version

Tylerdurden2k5

21:55 3 Jul '05

Hey,

it seems that this is not all that i must do.

The Compiler doesnt understand the syntax
example:

public partial class ActionListProvider : Component, IExtenderProvider, ISupportInitialize
{
private Dictionary ActionDictionary = new Dictionary();

the "<" chars....

Sorry im not using .net 2.0 so i dont know what i must do to implement this to the
1.1 framework.

I hope you can help me one more time.

Thanks and a nice day.

cheers denis

Re: .NET 1.1 Version

Burkovsky

23:14 3 Jul '05

I use generics. So you cannot so simple compile it under 1.1. You must use HashTable instead of Dictionary and cast the elements. I have only 2.0 Beta and no VS.NET 2003 Ladislav
Sign In·View Thread·Permalink

something like this can already be done?

SeveredCross

15:29 30 Jun '05

Can't this be done by decalring an event handler and then assigning several events to be handled by it? At least the multiple event part that you mentioned. e.g.: `// in InitializeComponents() printButton.Clicked += new EventHandler(PrintClicked); printMenuItem.Clicked += new EventHandler(PrintClicked); //elsewhere private void PrintClicked(object sender, System.EventArgs e) { Print(myData); }`
Sign In·View Thread·Permalink

Re: something like this can already be done?

Burkovsky

19:43 30 Jun '05

Of course you make it manualy. The benefit is that you can change your event handling for all your buttons in the action instead of on each button. The second benefit is that you can enable and disable the buttons with 1 line code.
Sign In·View Thread·Permalink	2.00/5 (1 vote)

Re: something like this can already be done?

ambush_2000

15:42 8 Dec '10

It's right!
Sign In·View Thread·Permalink

Re: something like this can already be done?

tonyt

1:47 26 Jul '05

Actions and ActionLists are more than just a centralized event handler.

For example, in most conventional RAD, menu items and toolbar buttons have properties for a glyph (or listview imageindex), a checked/pushed state, enabled/disabled state, and so on.

Actions are a way to encapsulate a logical UI item's visual appearance, image/glyph; caption text; and other states like checked/unchecked, enabled/disabled etc., in a single place.

So, rather than associating glyphs, captions, enabled/disabled state, pushed state, and other things directly with toolbar buttons and menu items, we associate those things with actions, and then reference the action from a toolbar button or menu item.

Hence, if I set a given UI action to disabled, the associated toolbar button and pull down menu item are both disabled.

In other words, Actions eliminate a mountain of code. They can also be useful in runtime UI customization too. A user can drag an action out of a listbox, drop it onto a toolbar or a pulldown menu, and you just create the button or menu item, associate it with the action, and you're done.