GlossContourButton™.

A typical Toggle Group approach uses a common click delegate to iterate the controls of a common parent container and identify Toggle Group members by a common Tag value, setting NonSenderMember.Down to false and sender.Down to true.

The downsides of this approach are,

1. that members must be parented by a common container,
2. that non-member types may require casting or reflection for processing,
3. and that potentially many non-members can be iterated to ultimately identify relatively few members.

Here, a common click delegate processes a tag value of 12345 to provide this style of toggle group behavior:

C# TAG STYLE TOGGLE GROUP BEHAVIOR EXAMPLE

// COMMON CLICK DELEGATE TOGGLES MEMBER STATES public void CommonToggleGroupHandler( object sender, EventArgs e ) { ADVANCEIS.Controls.GlossContourButton s = sender as ADVANCEIS.Controls.GlossContourButton; if ( null != s ) { foreach ( Control c in ParentControl.Controls ) { if ( 12345 == c.Tag ) { ADVANCEIS.Controls.GlossContourButton g = c as ADVANCEIS.Controls.GlossContourButton; if ( null != g ) g.Down = ( ( Control )s == ( Control )g ); } } } }

Even in each iteration, this method requires relatively compute-intensive operations which are redundant to the generic list approach we will look at next. Because we are not using a type safe list genericized to the specific type we need to handle, substantial casting is required:

1. To process the sender argument as our button type, we have to cast the sender to s as the processed type.
2. We next have to test if s is null, because we cannot later process s if s is null. Nor would there be any purpose in performing the iteration if we cannot process the sender (s).
3. Then we iterate the controls of the parent container, having to process each member as ( Control )c because this is the generic type of the Controls array.
4. If c has the tag value we are looking for, then we try to cast c to the class we have to be able to process in the instance g.
5. Again, we have to test for a null result of this cast to g, because we cannot otherwise process g.
6. Finally, we set the Down property of g to the result of a comparison of g to s, which of course tests if the currently processed button member is the sender.

Even if we can eliminate a cast or two for a given implementation, we cannot eliminate all casts unless the list type matches our process type. A matched generic list based approach eliminates the casting issues and makes it possible to write a substantially more compact, efficient CommonToggleGroupHandler( ), as we find in the example below.

A casting-free approach uses a dedicated generic list to which only a specific toggle group's members belong. The advantages of this approach are,

1. Only the members of the toggle group are iterated, which contributes to maximum speed.
2. Members do not have to be parented by the same outer control.
3. The type safe list eliminates any need for reflection or casting, which further contributes to maximum speed and minimizes the processing footprint.

The following example,

1. declares and creates a generic list,
2. dynamically creates toggle group members,
3. dynamically adds the toggle group members to the generic list, and
4. dynamically assigns a common click delegate to the click event of each toggle group member.
5. As in the previous example, a CommonToggleGroupHandler provides the desired toggle group behavior. Here you see however, how the method is streamlined and expedited by using a type safe generic list:

C# GENERIC LIST TOGGLE GROUP BEHAVIOR EXAMPLE

public partial class Form1 : Form { ADVANCEIS.Controls_N.GlossContourButton_UnInit B1, B2, B3, B4; // DYNAMICALLY CREATED TOGGLE GROUP MEMBERS List<GlossContourButton_UnInit> ToggleGroupList = new List<GlossContourButton_UnInit>( ); // INSTANTIATE LIST. public Form1( ) { InitializeComponent( ); //-------------------------START DYNAMICALLY CREATED CONTROLS S1 = new GlossContourSurface_UnInit( ); S1.Paint_SuspendAll( ); // ASSIGNMENTS S1.SetBounds( 0, 32, this.ClientSize.Width, this.ClientSize.Height - 32 - 32 ); // 32 36 this.Controls.Add( S1 ); B1 = new GlossContourButton_UnInit( ); B1.ContourServer = S1; B1.Down = true; // SET ORIGINAL STATE (SOMEWHERE). // ASSIGNMENTS B1.SetBounds( 0, 0, 26, 26 ); S1.Controls.Add( B1 ); B2 = new GlossContourButton_UnInit( ); B2.ContourServer = S1; // ASSIGNMENTS B2.SetBounds( 26, 0, 26, 26 ); S1.Controls.Add( B2 ); B3 = new GlossContourButton_UnInit( ); B3.ContourServer = S1; // ASSIGNMENTS B3.SetBounds( 52, 0, 26, 26 ); S1.Controls.Add( B3 ); B4 = new GlossContourButton_UnInit( ); B4.ContourServer = S1; // ASSIGNMENTS B4.SetBounds( 78, 0, 26, 26 ); S1.Controls.Add( B4 ); S1.Paint_ResumeAll( ); //-------------------------END DYNAMICALLY CREATED CONTROLS // ADD TOGGLE GROUP MEMBERS TO ToggleGroupList ToggleGroupList.Add( B1 ); ToggleGroupList.Add( B2 ); ToggleGroupList.Add( B3 ); ToggleGroupList.Add( B4 ); // DYNAMICALLY ASSIGN COMMON HANDLER (OR MANUALLY ASSIGNED IN IDE) B1.Click += CommonToggleGroupHandler; B2.Click += CommonToggleGroupHandler; B3.Click += CommonToggleGroupHandler; B4.Click += CommonToggleGroupHandler; } // COMMON CLICK DELEGATE TOGGLES MEMBER STATES public void CommonToggleGroupHandler( object sender, EventArgs e ) { foreach ( GlossContourButton_UnInit g in ToggleGroupList ) g.Down = ( sender == g ); }

As we can easily see by comparing the CommonToggleGroupHandlers, the casting-free, genericized approach is substantially more efficient. As visually created examples require that you manually perform the creation and assignment aspects, this example can be considered to provide coded instructions for the equivalent visual steps.

As a matter of proper streamlining, these examples purposely exclude other possible forking. In other words, to eliminate branching logic in each iteration, and to make use of existent delegate handling processes to accomplish the same purpose, if a button's click event must invoke further processes, further delegates are attached directly to the button to do so.

The usual object of toggle groups is to represent application states to further processes. Branching is usually performed with nested if statements, because multiple state values are not a matter for switches.

C# EXAMPLE

if ( B1.Down ) { } else if ( B2.Down ) { } else if ( B3.Down ) { } else if ( B4.Down ) { }

Gloss Contour Suite™ for .NET DOCUMENTATION

Introductory material and complete GCS technical documentation.

HOW TO — ARTICLES AND EXAMPLE SOURCE

GlossContour Suite™ INSTALLATION

HOW TO IMPLEMENT EFFICIENT TOGGLE GROUP BEHAVIOR

Writing efficient, type safe code to implement toggle group behavior.

WALKTHROUGH 1 — DESIGNING GlossContourSurfaces™, DEPLOYING AS ContourServers™

Basic configuration of GlossContourSurfaces™ in preparation for Walkthrough 2.

WALKTHROUGH 2 — DESIGNING GlossContourButtons™, DEPLOYING AS ContourServers™ OR ContourClients™

How to configure color, color offsets, gloss, glare, and 3D effects. ContourServer™/ContourClient™ implementation.

NET TECHNICAL

VITAL TECHNIQUES FOR USING OBJECTS AS .NET PROPERTIES

Our experience with Visual Studio 2005™ demonstrates that function calls are not fired in outer set accessors of properties subject to TypeConverters. This article first revisits how to deploy TypeConverters so that your class properties will be displayed from a nested node in Properties View. It then demonstrates the necessary pattern for declaring DefaultValueAttributes, and for writing set accessors that will successfully fire vital accessor functions.

• DOWNLOAD OR BUY Gloss Contour Suite™