(How)
C^# You Are - 16 September 2007

This week's fucus is on WinForms.

1. In your WinForms application you want to allow your users to either dock or float your toolbars.  How can you do this?  Answer

   You can support docking of toolbars on any side of your form using the ToolStripContainer.  This container control allows you to define the sides where a ToolStrip-derived window can be docked.  Unfortunately this control does not support floating tool strips at all.  To get this functionality you must either implement it yourself or go out to a third-party component.

   Implementing the code yourself is not terribly difficult. You would have to track the dragging operation and if the drop occurs outside any docking region of the container then you would create the tool strip as its own window.  One of the bigger issues, though, is that you will not get the nice docking stickers that are commonly used, such as in Visual Studio.  Without writing a bunch of code your only choice is to use third-party controls.

2. What is the difference between MainMenu and MenuStrip?  Answer

   Both controls serve the same purpose.  The primary difference lies in a MenuStrip being a ToolStrip-derived class, and hence it can be docked, whereas MainMenu is a regular control.  Both are available and it is unlikely that MainMenu will ever be deprecated but MenuStrip is preferred in most cases.

   What is more pronounced is the children of each control.  MenuItems in a MainMenu are primarily controlled by the menu itself.  They can be checked or unchecked, have a name and a shortcut.  ToolStripMenuItems on the other hand support custom coloring, associated images and a host of other features.

   In general you should prefer MenuStrip to MainMenu but, in rare cases, feel free to use MainMenu when it fits the bill.

3. You have written a custom control.  You need to interact with several different properties of the control whenever a certain property is set.  However you find that the designer does not generate property assignments in any reasonable order.  How can you allow the designer to set the properties in any order yet still allow your control to enforce certain business rules between property values?  Answer
   public class MyCustomList
   {
      private m_itemSelected;
      private Collection<MyListItem> m_Items;
   
      public MyListItem SelectedItem
      { 
         get { return m_itemSelected; }
         set
         {
            if (m_itemSelected != value)
            {
               VerifyInList(value);
               m_itemSelected = value;
            };
         }
      }
   }

   There are two ways to solve this.  The first way is to implement ISupportInitialize.  This interface is designed to allow code, such as the designer, to notify your control that it is going to be setting several properties and that the control should defer any complex processing until the process is complete.  When the designer creates an instance of a control that implements this interface it makes a call to BeginInit.  When this method is called your control knows that it should defer any complex processing until after all property values have been set.  How do you know when this occurs?  The EndInit method.  This method is called after all initialization is complete.  At this point you can do any cross-property validation or complex processing.

   public class MyCustomList : ISupportInitialize
   {
      private m_itemSelected;
      private Collection<MyListItem> m_Items;
   
      public MyListItem SelectedItem
      { 
         get { return m_itemSelected; }
         set
         {
            if (m_itemSelected != value)
            {
               if (!m_bDelayValidate)
                  VerifyInList(value);
               m_itemSelected = value;
            };
         }
      }
   
      private bool m_bDelayValidate;
      public void BeginInit ( )
      {
         m_bDelayValidate = true;
      }
   
      public void EndInit ( )
      {
         m_bDelayValidate = false;
         
         //Force validation
         if (m_itemSelected != null)
             VerifyInList(m_itemSelected);
      }
   }
   

   The alternative, and slightly easier, approach is to simply check the state of your object.  The designer generated code is called before the underlying Windows control is actually created.  In most cases you can defer processing until the actual control is created.  In this case use the IsHandleCreated property to determine if the real control has been created yet.  If not then skip processing.  Controls like TreeView use this approach for validating the selection of a node.  This does, however, mean you generally have to override the OnHandleCreated method in order to do the cross property validation.

   public class MyCustomList
   {
      private m_itemSelected;
      private Collection<MyListItem> m_Items;
   
      public MyListItem SelectedItem
      { 
         get { return m_itemSelected; }
         set
         {
            if (m_itemSelected != value)
            {
                     if (IsHandleCreated)
                       VerifyInList(value);
               m_itemSelected = value;
            };
         }
      }
   
      protected override OnHandleCreated ( EventArgs e )
      {
         //Validate properties
         if (m_itemSelected != null)
            VerifyInList(m_itemSelected);
      }
   }

4. You have a list view that displays items in detail mode.  The view has several columns and you want to make the last column resize so that it fills any remaining space in the view.  How can you do this?  Answer

   Surprisingly the standard list view does not support this exact functionality.  ListView (or more correctly ColumnHeader) does support some autosizing.  In fact you can have it sized to fit either the header text or the longest item in the column.  This is a one-time thing.  Each time the contents (or header) changes you would have to resize.  Not particularly useful in my opinion.

   To get a truly resizing column you really need to set the initial size of the column and then again whenever the view is resized.  This is pretty easy to do by hooking into the resize event of the control.  To resize the last column start with the initial width of the client area of the view.  Enumerate through all but the last column.  After enumerating the columns whatever width is left is the last column's width.  A vertical scrollbar will take up some of this width.  You can either code for it or simply ignore it.

   The following code will get you started.  Note that, in this case, a derived class is used so the control can be easily integrated into an existing application. 

   class ResizingListView : ListView
   {
      protected override void OnHandleCreated ( EventArgs e )
      {
         base.OnHandleCreated(e);
       
         AdjustColumns(); 
      } 
   
      protected override void OnResize ( EventArgs e )
      {
         base.OnResize(e);
   
         AdjustColumns();
      }
   
      private int nMinWidth;
      private void AdjustColumns ()
      {
         int lastColumn = this.Columns.Count - 1;
         int width = this.ClientRectangle.Width;
     
         for (int nIdx = 0; nIdx < lastColumn; ++nIdx)
         {
             width -= (this.Columns[nIdx].Width);
   
             //No reason to continue since the user won't see it
             if (width < 0)
                break;
         };
   
         //Set the new width size
         if (width < 0)
            this.Columns[lastColumn].Width = width;
      }
   }

   There are a few problems with the above code.  The first problem is that if the control is resized smaller than the size of the available columns then the last column will disappear.  You might or might not want this.  In general you should probably not allow the column to get any smaller than its header.  To do that you would want to trap the width of the column header during initialization (by using AutoResize).  An alternative is to use the initial width of the column (determined during design). 

   Another problem with the above code is the number of times the resize event is raised.  This event will be raised several times as a user resizes a form.  To avoid the continual recalculation and repainting you can either defer the painting until the resize is complete or use a timer to call the AdjustColumns after a small delay.  Each time the resize event is raised the timer resets.  After the resize is complete the adjustment occurs.  Trial and error will determine the smallest delay to use that will allow the UI to look correct while keeping the number of resize adjustments to a minimal.

5. You have a main form.  You want to display another form to get input from the user while preventing them from accessing the main form.  How can you do this?  Answer

   Experts in the group might find this question to be really easy and, therefore, assume a trick question.  It isn't one.  This question comes up enough that I thought I would throw it in for clarifty.  Forms can be displayed in one of two modes: modeless and modal.  Modeless forms are normal windows display on the screen.  The main window of most forms is a modeless form.  The user can open multiple modeless forms and interact with each of them.  Each one has its own message loop.  The lifetime of a modeless form is controlled by the user (by clicking the close button) or programmatically.  You display a form modeless by using the Show method.  When the method returns the form is displayed and available for the user.  The main (calling) form can continue to do more work.  Here is some sample code that will open five modeless windows whenever a user clicks a button.

   private void OnClicked ( object sender, EventArgs e )
   {
      for (int nIdx = 0; nIdx < 5; ++nIdx)
         new Form().Show(this);
   }

   A modal form is similar to a modeless form but, once displayed, prevents the user from interacting with the main (calling) form until the child form is dismissed.  The most common example is a dialog box (such as the open dialog).  The modal form has a special message loop that effectively prevents messages from reaching the main form.  When the user cancels the modal form control returns to the parent.  You display a form modal using ShowDialog.  The code will block at the method call until the modal form is closed.    Here is the same code that was given earlier.  In this case though you have to dismiss the form each time before the next one will appear.

   private void OnClicked ( object sender, EventArgs e )
   {
      for (int nIdx = 0; nIdx < 5; ++nIdx)
         new Form().ShowDialog(this);
   }

   Whether a form is modeless or modal impacts how you interact with it.  A modeless form can be closed at any time.  Therefore if you are interested in getting information out of the form you will have to hook into the form's events (such as the close event).  You can set properties on the form just like you would for any other class but to get values back you'll have to use events.  A modal form, on the other hand, exists only for the lifetime of the block that creates it.  Therefore you can initialize the form's properties, display the form and then get information back from the form without using events. 

   In general use modeless forms to display useful information or allow the user continual access to information.  The Visual Studio Solution Explorer, Output window and Document windows would be examples of modeless forms.  Use modal forms when you need information from the user before continuing execution.  Opening a file or saving a document would be an example.

6. How do you append a new line of text to a TextBox?  Answer

   The AppendText method of the TextBox control can be used.  The difficulty comes in the new line.  In Windows there are several different ways to represent newlines: \n, \r, \r\n.  The TextBox works with either \n or \r\n.  \r is ignored.  If you are reading data from a stream, say a file, then you might need to convert newline characters to \n before inserting them into the control.

7. You add a TextBox to a form and set some initial text.  When the form loads the text is selected.  How can you prevent this?  Answer

   This is a quirk with the control.  If you are going to initialize the control's text then you'll have to clear the selection when the control is loaded.  This code won't work.

   public Form1 ( )
   {
      initializeComponent();
   
      textBox1.SelectionLength = 0;
   }

   Nor will placing the code in OnLoad.  The problem is that the control feels that it should select all the text when you explicitly set Text.  This is unfortunately as it doesn't make a lot of sense.  Internally the control uses a field to determine if it should auto-select the text when the control gets focus.  It only does this the first time the control gets focus after you've set the Text property.  You can test this by dropping a text box and a button on the screen.  Whenever the button is clicked reset the text box to the current date and time.  Now run the form.  Every time you click on the button and then tab to the form the text is selected.

   You can work around this by creating a derived class from TextBox and overriding the OnGotFocus method.  That's right the focus method.  It is this method that will auto-select the text after Text changes.  In the override first check to see if any text is already selected (by the user).  Then call the base implementation to handle the focus change.  Finally, if no text was original selected, clear the selection.  Here's the code.

   class TextBoxEx : TextBox
   {
      protected override void OnGotFocus ( EventArgs e )
      {
         //Determine if anything was selected
         bool bHadSelection = (this.SelectionLength > 0);
   
         base.OnGotFocus(e);
         if (!bHadSelection)
            SelectionLength = 0;
      }
   } 

8. Your users have requested that you remember the size and position of your form when it is closed.  How can you do this?  Answer

   The beta versions of v2 had some support for this (from what I recall) but it was pulled from the final release.  Fortunately the code is straightforward and, once written, can be used to save the settings for any form.  Ultimately it doesn't matter where you decide to store the settings provided you do it consistently.  Options include the registry, isolated storage or a user's configuration file.  Each has its own strengths and weaknesses.  The key is to save the settings just before the form closes (FormClosing is a good place) and load the settings just before the form is displayed (OnLoad ).

   The code is a little longer than I can post here.  Refer to the article Persisting Form Settings for the full code.