Visual Basic 2008

How To Animate a TextBox in Windows Forms

Ged Mead — Fri, 03 Jul 2009 15:34:00 GMT

Starting Point
In my earlier post, the HiliteTextBox, I created a simple WPF UserControl which is hosted in an ElementHost in a Windows Form. If the user tries to continue without entering text in the TextBox, a bright colored Border would appear around it and stay there until the user does enter something.

If we are going to go to the trouble of harnessing WPF's graphics power, we may as well go a step further and add some animation to the control. One simple thing we can do is to animate the Border Thickness.

This is the XAML for the UserControl I created previously. The only thing I have changed is the class name. It was originally HiliteTextBox, but for this version it will be named AnimatedTextBox :

<UserControl x:Class="AnimatedTextBox"
   xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
   xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" Width="300" Height="300">
  <UserControl.Resources>
    <LinearGradientBrush x:Key="BrightGradient" EndPoint="0.056,0.993" StartPoint="0.634,0.342" SpreadMethod="Repeat">
      <GradientStop Color="#FFB50D0D"/>
      <GradientStop Color="#FFE80C2C" Offset="1"/>
      <GradientStop Color="#FFF4DF5A" Offset="0.17399999499320984"/>
      <GradientStop Color="#FFCA0C1F" Offset="0.357"/>
      <GradientStop Color="#FFDCD762" Offset="0.522"/>
      <GradientStop Color="#FFB70D36" Offset="0.716"/>
      <GradientStop Color="#FFDDEE49" Offset="0.823"/>
    </LinearGradientBrush>
  </UserControl.Resources>
 
  <Border x:Name="GradBorder"
           BorderBrush="LightGray"
           BorderThickness="5" 
           CornerRadius="4,4,4,4">
 
    <TextBox x:Name="InputTextBox" 
            TextWrapping="Wrap" 
         TextChanged="InputTextBox_TextChanged" >
    </TextBox>
  </Border>
</UserControl>

And this is the code-behind in the UserControl:

    Private Sub InputTextBox_TextChanged(ByVal sender As System.Object, ByVal e As System.Windows.Controls.TextChangedEventArgs)
        HighlightEmpty()
    End Sub
 
    Public Sub HighlightEmpty()
        If InputTextBox.Text.Length > 0 Then
            GradBorder.BorderBrush = New SolidColorBrush(Colors.Black)
            GradBorder.BorderThickness = New Thickness(1)
        Else
            GradBorder.BorderBrush = FindResource("BrightGradient")
            GradBorder.BorderThickness = New Thickness(4)
        End If
    End Sub
 
    Public Function IsTBEmpty() As Boolean
        If InputTextBox.Text.Length = 0 Then
            Return True
        Else
            Return False
        End If
    End Function

Creating the Animation in Code

Generally, you will find XAML to be the best tool for creating animations - and if they are quite complex then Expression Blend is your best bet. However, you can create a simple animation in the UserControl using code. The following code-behind in the UserControl will cause the Border to change in size over a short period of time:

    Public Sub ChangeSize()
        Dim ThickAnim As New ThicknessAnimation
 
        With ThickAnim
            .To = New Thickness(14)
            .AutoReverse = True
            .Duration = New Duration(TimeSpan.FromSeconds(0.6))
        End With
 
        Me.GradBorder.BeginAnimation(Border.BorderThicknessProperty, ThickAnim)
    End Sub

Even if you have no experience of WPF, most of the above code is relatively easy to follow.

ThicknessAnimation is a class that 'does what it says on the tin', as we say here in the UK - it does exactly what you would expect. It animates the Thickness Property of a target element.

To sets the value of the Thickness that has to be reached by the conclusion of the animation.

AutoReverse ensures that the Thickness returns to its starting value by the end of the animation sequence.

Duration assigns the length of time for which the animation will run. Note that in the case of this AutoReversed animation both the increase (The To value) and the decrease (AutoReverse to the start value) in size are completed within the allowed Duration.

The BeginAnimation Method takes parameters of a kind that might be unfamiliar. It takes the WPF DependencyProperty for the Border class as the first argument and it takes the ThicknessAnimation instance as the second argument. The correct element is animated, of course, because the BeginAnimation method is applied to GradBorder, the Border instance we are dealing with.

Me.GradBorder.BeginAnimation(Border.BorderThicknessProperty, ThickAnim)

To get the animation to run, we can incorporate it into the code we used previously that tests if the TextBox is empty. This code is in the Windows Form on which we placed an ElementHost to house the WPF UserControl :

    Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
        If AnimatedTextBox1.IsTBEmpty = True Then
            '  Change to bright gradient border
            AnimatedTextBox1.HighlightEmpty()
 
            '  Animate
            AnimatedTextBox1.ChangeSize()
 
            ' Return focus
            Me.ElementHost1.Focus()
        Else
            MessageBox.Show("You are clear to continue")
        End If
    End Sub

If you try this code and run the project, click the Continue Button with no text in the TextBox, you will see that the Gradient Border appears and then the Border size is animated.

One thing you may have noticed is that the target in the Button Click event is an object named AnimatedTextBox1. If you scour through the small amount of code I have written so far, you won't find where I created this object. The reason being that I didn't. When you use the Smart Tag in the ElementHost and select the content, it will automatically create an instance for you and name it.

In the next part, I will create a different animation using what on the face of it seems to be a very complex block of XAML. When we take a closer look, you will see that it is not as complicated as it first appears.

WPF-WinForms Interop: A Highlighted TextBox

Ged Mead — Wed, 01 Jul 2009 16:49:00 GMT

Introduction
A recent forum post on VBCity asked for a way to highlight an important TextBox in a Windows Form. Assuming that the plan is to highlight the TextBox if the user is about to leave the Form without entering any text into it, there are of course several ways this can be done using Windows Forms techniques. But I thought it might be interesting to try something different and see how easy it would be to create a WPF UserControl that incorporated a TextBox, a smack-you-in-the-eye gradient and a border with rounded corners*. I picked those last two features because they are not particularly easy to create in Windows Forms. The WPF UserControl would then have to be integrated seamlessly into the Windows Forms environment.

(*If this isn't cutting-edge enough for you, I will be looking at adding animation to the control in a follow up blog post).

So here's our demo Windows Form that will contain two TextBoxes. The WinForms TextBox is already in place. We will create the WPF one shortly.

The WPF UserControl
The first step is to add a WPF UserControl to the Windows Forms project. This is as simple as hitting Ctrl+Shift+A and selecting "WPF" from the Add New Item menu which appears. The only choice you will then see is "User Control (WPF)", so select this and change the default name to 'HiliteTextBox.xaml'. Then click the Add button.

The WPF UserControl will be added to your Windows Forms project and behind the scenes all the required References will be added also. The UserControl will be on display as the selected item in Visual Studio and you will see that all the WPF tools are in the Toolbox, not the WinForms ones.

Delete the default Grid from the UserControl and then drag a Border element from the Toolbox and drop it on the XAML pane, on one of the empty lines where the Grid used to be. You might think it strange that you drag a visual element and drop it into the markup area. There's nothing to stop you from dropping it in the Design pane instead. If you do this, you will find that several properties are automatically added for you and, as it happens, we don't want those particular properties set and you would therefore have to delete them.

Assign the Name 'GradBorder' to the Border. Create an empty line between the opening and closing tags of the Border. Drag a TextBox from the Toolbox and drop it on the empty line. Name the TextBox 'InputTextBox'.

Here's the Markup as at this point:

<UserControl x:Class="HiliteTextBox"
   xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
   xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" Width="300" Height="300">
  <Border x:Name="GradBorder">
    <TextBox x:Name="InputTextBox"></TextBox>
  </Border>
</UserControl>

Don't worry that nothing seems to be happening in the Design pane. We'll soon change that. With the Border selected in the XAML pane, move over to the Properties window and change the BorderBrush to LightGray, the BorderThickness and CornerRadius properties to 4. (Still no change in the Design pane; no worries).

The plan is to have a plain gray border round the TextBox by default and have this change to a bright gradient if the user tries to continue without entering any text in the TextBox. To set this up, first create a new empty line between the opening tag of the Window and the opening tag of the Border. Copy and paste the following markup, which creates a LinearGradientBrush that will be stored as a Resource.

  <UserControl.Resources>
    <LinearGradientBrush x:Key="BrightGradient" EndPoint="0.056,0.993" StartPoint="0.634,0.342" SpreadMethod="Repeat">
      <GradientStop Color="#FFB50D0D"/>
      <GradientStop Color="#FFE80C2C" Offset="1"/>
      <GradientStop Color="#FFF4DF5A" Offset="0.17399999499320984"/>
      <GradientStop Color="#FFCA0C1F" Offset="0.357"/>
      <GradientStop Color="#FFDCD762" Offset="0.522"/>
      <GradientStop Color="#FFB70D36" Offset="0.716"/>
      <GradientStop Color="#FFDDEE49" Offset="0.823"/>
    </LinearGradientBrush>
  </UserControl.Resources>

There is a very good reason for storing the gradient brush separately and naming it with the 'BrightGradient' Key, as you will see soon.

We will set a few properties on the TextBox. Select the TextBox in the XAML pane and then move to the Properties Window and set the TextWrapping property to 'Wrap'.

In the XAML pane, create a new empty line inside the opening tag of the TextBox. Then type in: 'TextChanged='. As soon as you do this, an Intellisense popup will appear, inviting you to create a new event handler for the TextChanged event.

Press the TAB key and the rest of the line will be completed for you. It will be assigned a default name and this event handler will have been added to the code-behind for you.

Your markup for the Border and TextBox should now look like this:

  <Border x:Name="GradBorder"
           BorderBrush="LightGray"
           BorderThickness="1" 
           CornerRadius="4,4,4,4">
 
    <TextBox x:Name="InputTextBox" 
            TextWrapping="Wrap" 
            TextChanged="InputTextBox_TextChanged">
    </TextBox>
  </Border>

Open up the vb file for the UserControl - HiliteTextBox.xaml.vb - in the project files in Solution Explorer. The InputTextBox_TextChanged event handler will be there for you.
Before we code the event handler though, first create a Sub that will check if the TextBox contains any Text. If it does, the Border will be set to the non-highlighted LightGray; if it doesn't, the Border will be the bright gradient. Enter the following code:

Imports System.Windows
Imports System.Windows.Media

    Public Sub HighlightEmpty()
        If InputTextBox.Text.Length > 0 Then
            GradBorder.BorderBrush = New SolidColorBrush(Colors.Black)
            GradBorder.BorderThickness = New Thickness(1)
        Else
            GradBorder.BorderBrush = FindResource("BrightGradient")
            GradBorder.BorderThickness = New Thickness(4)
        End If
    End Sub

The only code that may be new to you might be the FindResource method. This is a really useful feature in WPF, which allows you to ferret through the project and pull out any specific resource that you want to use. The 'BrightGradient', you will recall, is the Key that I assigned to the LinearGradientBrush that I stored as a UserControl Resource earlier.

The Imports statements at the top of the file ensure that you are accessing elements in the System.Windows namespace.

Hosting the UserControl
Now the UserControl is built, it has to be hosted in the Windows Form. Rebuild the project and then select the Form1.vb file. The control that WinForms uses to host WPF UserControls is the ElementHost. This probably won't be in your Toolbox by default, so if it isn't listed, right-click on the Toolbox and select Choose Items... Select the ElementHost from the .NET Framework Components Tab.

Drag an instance of the ElementHost from the Toolbox on to the surface of the Form. It will be too large by default, but before you change its size, click on small down arrow next to 'Select Hosted Content' and select HiliteTextBox from the list:

The Smart Tag window will close and you can then adjust the size of the ElementHost. As you can see from the screenshot, an error message appears inside the ElementHost. You can safely ignore this as it is only tells you that the Windows Form can't display the visuals of the UserControl at Design time.

Next we need to add code to the Continue button. For our demo purposes, this will be sufficient:

    Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
        HiliteTextBox1.HighlightEmpty()
    End Sub

If you look back at the earlier code, you will know that the HighlightEmpty method checks if the TextBox has Text entered and sets the Border accordingly. Although the Button on the Windows Form can't access the graphical elements of the UserControl directly, the HighlightEmpty procedure allows for this interchange between the two.

Try running the application now. Don't enter any text into the UserControl, then press the Continue button. You should see the highlight gradient border appear around the TextBox.

If you then insert some text and press the Continue button again, the highlight border will be replaced with the gray one.

Adding Some Refinements
That pretty much fulfills the spec, but there are a couple of things I would definitely add. The first feature is that if the user is warned about not entering text, then I would like to give some positive feedback as soon as they do so. That is, before they press the Continue button for a second time. This is easily achieved by adding a line of code to the TextChanged event handler of the InputTextBox.

Go back to the WPF UserControl code-behind file and add a call to the HighlightEmpty procedure:

    Private Sub InputTextBox_TextChanged(ByVal sender As System.Object, ByVal e As System.Windows.Controls.TextChangedEventArgs)
        HighlightEmpty()
    End Sub

When you run the application again and press the Continue button with no text in the TextBox, the highlight border appears as before. Now though, when you enter a character, the highlight Border disappears. As a small bonus, if the user then deletes all the text in the TextBox, the highlight will reappear, just to make certain they know about it.

The second thing I would like to add is a way of giving the developer a choice of actions on the Continue Button Click event. What I mean by this is that at the moment, the call goes to the HighlightEmpty procedure of the UserControl. This approach makes it difficult to build choices into the Button Click event, along the lines of "Depending whether the TextBox is empty, do something here in the Form's logic".

There are several easy ways of doing this, including adding a Boolean Property to the UserControl or creating a simple Function. This tests if the InputTextBox is empty and if it is, it Returns True. Based on the returned value, the Button event handler can follow one course of action or another.

Here's a Function that can be added to the UserControl:

    Public Function IsTBEmpty() As Boolean
        If InputTextBox.Text.Length = 0 Then
            Return True
        Else
            Return False
        End If
    End Function

You can then put whatever code you want in the Button Click event handler. Maybe something like:

    Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
        If HiliteTextBox1.IsTBEmpty = True Then
            HiliteTextBox1.HighlightEmpty()
            Me.ElementHost1.Focus()
        Else
            MessageBox.Show("You are clear to continue")
        End If
    End Sub

You can apply this approach of using a WPF UserControl in a Windows Form to get access to lots of those enhanced visual goodies that WPF offers, including Animation. As you have seen, creating a WPF UserControl hosted in an ElementHost is a very easy process. As an alternative to fiddling with individual controls on a Windows Form, you can of course include complete WPF Windows in Windows Forms projects.

Copying An Item Between ListViews

Ged Mead — Tue, 09 Jun 2009 09:44:00 GMT

I've always found ListViews quite fascinating. Slightly confusing sometimes, but fascinating nevertheless.

As I have often been heard to say, it's the little Gotchas that'll get ya. Take, for instance, the subject of this blog - copying an item between ListViews. The scenario is that you let the user click on an item in ListView1 and if they want this item copied to ListView2, they hit a button.

Now, you would probably think that all you need to do is identify the currently selected item and add it straight to the second ListView. Something like:

Code Copy

ListView2.Items.Add(ListView1.SelectedItems(0))

But if you do try this, you will get an error.

The text of the error message pretty much says it all. What you have to do (assuming that you aren't prepared to remove the item from the original ListView) is to clone it. You will then be allowed to add the clone to the second ListView.

Although the cloning isn't difficult, you do have to be aware of the need to cast the selected item to ListViewItem if you have Option Strict On. To be honest, I found this a bit strange at first. If I lift a ListViewItem from a ListView, I didn't expect to have to cast it to what it is - i.e a ListViewItem.

I'm not entirely sure why this occurs and wonder if the underlying reason for this is that the ListViewItem is stored in the SelectedItems collection of the ListView as a generic object. Anyway, Casting it back to a ListViewItem at the point where the cloning takes place, fixes this without any problem.

This code works well:

Code Copy

If ListView1.SelectedItems.Count > 0 Then
    Dim lvi As New ListViewItem
    lvi = ListView1.SelectedItems(0)
    Dim lvi2 As New ListViewItem
    lvi2 = CType(lvi.Clone, ListViewItem)
    ListView2.Items.Add(lvi2)
End If

You'll have noticed that I built in a test to ensure that an item is currently selected. It's an easy thing to forget and is sure to bring your app to a grinding halt before long if you don't build this in.

You can see where I have cast the selected item (aka lvi) to ListViewItem in Line 5. Intriguingly, casting to ListViewItem in the third line of code, e.g.

Code Copy

lvi = CType(ListView1.SelectedItems(0), ListViewItem)

doesn't cut it.

Removing Double Quotes from a Text File

Ged Mead — Tue, 09 Jun 2009 09:35:00 GMT

Sometimes you don't have control over how the data is saved to a text file. For instance, some items might be saved with quotation marks around words or phrases. If you want to read the file but not show these marks then you'll need a way to remove them.

Like a lot of things, it's actually very easy when you know how. You can use the built-in Replace function of the String class, replacing the marks as you find them. The trick though (and to my mind, the less than totally intuitive bit) is knowing how many quotation marks to use in the first argument of the Replace method's parameters. This is the 'OldChar' parameter, i.e the one you want to replace.

You would think, wouldn't you, that you could put a Quotation Mark inside a pair of Quotation Marks like this:-

Code Copy

MyString.Replace(""", "")

But if you try that, you will find that it doesn't work. What you actually have to do is include a second Quotation Mark inside the outside ones. In other words, you need four Quotation Marks in a row.

Code Copy

MyString.Replace("""", "")

It's only a tiny change, but it will move your mental state from annoyed confusion to enlightened contentment. Or something like that, anyway.

So putting this together with code that reads from a file and displays the result (minus Quotation Marks) in a ListBox, you have:

Code Copy

Private Sub RemoveQuotes(ByVal filename As String, ByVal target As ListBox)
        '  A StreamReader to fetch the data
        Dim sr As New IO.StreamReader(filename)
        '  A string to hold each line as it is read
        Dim line As String = String.Empty

        ' Read from the file
        ' As long as there is something left to read
        Do While sr.Peek <> -1
            ' Replace the Quotation Marks with Nothing
            line = sr.ReadLine.Replace("""", "")

            ' Add edited text to a ListBox
            target.Items.Add(line)
        Loop

        '  Tidy up when finished
        sr.Close()
        sr = Nothing
End Sub

If you prefer your code to be broken down into clearer steps, you could do this instead:

Code Copy

    Private Sub RemoveQuotes(ByVal filename As String, ByVal target As ListBox)
        '  A StreamReader to fetch the data
        Dim sr As New IO.StreamReader(filename)
        '  A string to hold each line as it is read
        Dim line As String = String.Empty

        ' Read from the file
        ' As long as there is something left to read
        Do While sr.Peek <> -1
            '  Read the next line
            line = sr.ReadLine

            ' Replace the Quotation Marks with Nothing
        line = line.Replace("""", "")

            ' Add edited text to a ListBox
            target.Items.Add(line)
        Loop

        '  Tidy up when finished
        sr.Close()
        sr = Nothing
    End Sub

Either way, your quotation marks will be history.

Restricting TextBox Input

Ged Mead — Tue, 09 Jun 2009 09:28:00 GMT

This is a question that seems to come up a lot in the forums:- How can I restrict the TextBox input to numerals, or only a single occurrence of a decimal point, or some other restriction?

As ever, there are several approaches. If the restriction is something basic, such as numerals only then the easy approach is to use the KeyPress event. What you can do is stop the character from appearing in the TextBox, test to see if it is allowable and, if it is, then allow it to continue.

Letters Only
To take an example which only allows letters of the alphabet, it would look like this:

    Private Sub TextBox1_KeyPress(ByVal sender As Object, ByVal e As System.Windows.Forms.KeyPressEventArgs) Handles TextBox1.KeyPress
        e.Handled = True
 
        If e.KeyChar Like "[A-z]" Then e.Handled = False
 
    End Sub

In this snippet, it is the e.Handled = True which blocks the input temporarily. The next line assesses whether the key press is a letter of the alphabet*, either lower or upper case, and if it is then the handled setting is reversed. This allows the key press to be passed to the TextBox display. If it fails the test, the block on this key press remains.

* Depending on your locale and keyboard, some other keys are allowed. These include symbols that are used in combination with characters in some languages, such as accents. In most cases this is the behaviour you will want.

Specific Keys
Sometimes you may want to allow certain keys. A common situation is where you will let the user use the Backspace to correct an error when inputting:

    Private Sub TextBox2_KeyPress(ByVal sender As Object, ByVal e As System.Windows.Forms.KeyPressEventArgs) Handles TextBox2.KeyPress
        e.Handled = True
 
        If e.KeyChar Like "[A-z]" _
        Or e.KeyChar = Chr(&H8) Then
            e.Handled = False
        End If
 
    End Sub

In this case, it is the Chr(&H8) which identifies and allows the Backspace.

Numbers Only
Another common requirement is to restrict input to numerals. Of the several possible approaches, using IsNumeric is one of the most straightforward:

    Private Sub TextBox3_KeyPress(ByVal sender As Object, ByVal e As System.Windows.Forms.KeyPressEventArgs) Handles TextBox3.KeyPress
        e.Handled = True
        If IsNumeric(e.KeyChar) Then e.Handled = False
    End Sub

Sometimes that is too restrictive though. What happens if you want to allow the user to enter decimal points or (depending on their locale) commas to break up large numbers? Allowing these individual characters is simple, but there is another potential catch as we will see in a moment:

    Private Sub TextBox4_KeyPress(ByVal sender As Object, ByVal e As System.Windows.Forms.KeyPressEventArgs) Handles TextBox4.KeyPress
        e.Handled = True
        If IsNumeric(e.KeyChar) _
        Or e.KeyChar = "." _
        Or e.KeyChar = "," Then
            e.Handled = False
        End If
    End Sub

Only One Decimal Point
In most cases where users are inputting numeric values you will want to restrict them to a single decimal point. The code above will allow multiple entries. Again, there are several solutions, but the following one will usually do the job:

    Private Sub TextBox5_KeyPress(ByVal sender As Object, ByVal e As System.Windows.Forms.KeyPressEventArgs) Handles TextBox5.KeyPress
        e.Handled = True
        If e.KeyChar <> "." Then
            If IsNumeric(e.KeyChar) Then e.Handled = False ' 
        ElseIf TextBox5.Text.Contains(".") Then
            MessageBox.Show("Only one decimal point allowed")
        Else
            e.Handled = False
        End If
    End Sub

Command Keys
If you use any of the previous methods, you will be able to control the standard input keys. But there is another group of keys - Command keys - which won't be excluded by the use of the e.Handled approach. These include such keys as Home, End, Tab, and so on. You may risk alienating your users by excluding these, but there may be times when it is reasonable to do so, in which case you'll need to know how.

A good way is to intercept the message at the window level and you can do this by overriding the ProcessCmdKey function. Here's how:

Create a new class which inherits from the basic TextBox. Override the ProcessCmdKey function and test for the currently pressed key in a similar way to that used in the earlier examples. If the key is one you want to suppress then you return True and the Windows message pump will ignore it.

The following code will be all you need:

Public Class CustomTextBox
 
    Inherits System.Windows.Forms.TextBox
 
    Sub New()
        Me.BackColor = Color.Azure
    End Sub
 
    Protected Overrides Function ProcessCmdKey(ByRef msg As System.Windows.Forms.Message, ByVal keyData As System.Windows.Forms.Keys) As Boolean
 
        ' Declare a variable of type Keys enumeration 
        ' named keyPressed. 
        ' Cast the msg's WParam as a KeyEnum value 
        ' and assign it to the keyPressed variable. 
 
        Dim keyPressed As Keys = CType(msg.WParam.ToInt32(), Keys)
 
        ' Process the key that is pressed. 
        '  If keyPressed = Keys.Home Or keyPressed = Keys.End Then Return True
        If keyPressed = Keys.Tab Then Return True
 
        ' Return the Command key message
        Return MyBase.ProcessCmdKey(msg, keyData)
 
    End Function
 
End Class

The light blue back color is simply to make this sub-classed TextBox look slightly different from the default one for demo purposes, but of course is not a key part of the key checking functionality. As you can see, my example blocks the Tab key. You can add or replace other keys, such as Home and End.

Multiple Options
Handling the KeyPress is fine if you only have a few TextBoxes for which you are controlling input. If there are going to be a lot of them throughout your application, or if you have different input rules for several TextBoxes, then again it may be worth your while to create your own inherited version.

The following example deals with some of the previous scenarios, but allows the input rule to be selected from an enumeration of choices. The choices used here remain basic, but of course you can expand this idea much further.

Here is the code:

Public Class RestrictedTextBox
    Inherits System.Windows.Forms.TextBox
 
    Enum RestrictionCategory
 
        NoRestriction
        NumeralsOnly
        LettersOnly
        AlphanumericOnly
 
    End Enum
 
    Private _allowedKeys As RestrictionCategory
 
 
    Property AllowedKeys() As RestrictionCategory
 
        Get
            Return _allowedKeys
        End Get
 
        Set(ByVal Value As RestrictionCategory)
            Select Case Value
                Case 1 To 3 ' One of the enum choices 
                    _allowedKeys = Value
                Case Else ' No restriction
                    _allowedKeys = 0
            End Select
 
        End Set
 
    End Property
 
 
    Protected Overrides Sub OnKeyPress(ByVal e As KeyPressEventArgs)
 
        MyBase.OnKeyPress(e)
 
        '  Test whether key is allowed, based on the current choice
        '  from the enum
 
        Select Case _allowedKeys
 
            Case 1 'Numerals only 
 
                If IsNumeric(e.KeyChar) Then
                    Exit Sub
                Else
                    e.Handled = True
                End If
 
            Case 2  ' Letters Only
 
                If e.KeyChar Like "[A-z]" Then
                    Exit Sub
                Else
                    e.Handled = True
                End If
 
            Case 3  ' Alphanumeric
                If e.KeyChar Like "[A-z]" _
                Or IsNumeric(e.KeyChar) Then
                    Exit Sub
                Else
                    e.Handled = True
                End If
 
        End Select
 
    End Sub
 
End Class

The key areas are the enumeration which is called RestrictionCategory. These are automatically assigned values from 0 to 3. The Property AllowedKeys and its backing Field carry out the standard roles of a Property, the user being able to set the AllowedKeys property in code. (You could improve this by having the property appear in the Properties Window).

The core of this class is the overridden OnKeyPress method. This checks for the chosen enumeration and then either allows or applies the blocking filter to the currently pressed key. This works in a very similar way to the individual KeyPress approach used in the earlier examples.

By default, all keys will be allowed and to set the enumeration of your choice, you simply include code similar to the following somewhere appropriate in your form (I've used the Form Load event for my example):

  Private Sub Form1_Load(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Load
        Me.RestrictedTextBox1.AllowedKeys = RestrictedTextBox.RestrictionCategory.NumeralsOnly
 
    End Sub

Summary
I think that a combination or extension of any of the above approaches will enable you to control exactly what you will allow the user to input into a TextBox.

My Blogs Are Moving to New Site

Ged Mead — Mon, 08 Dec 2008 16:13:00 GMT

VBCity will be looking very different soon, as we change to the new Community Server based model. In advance of that change, our blogs are moving to a new area.

From now on, you can view my latest blogs both here and at the new site here. Once the new site is fully up and running, all new blog items will be posted on the new area only.

All previous blogs from VBCity Bloggers will still be available and hopefully will continue to rank highly in search engine results.

How To Get the Icon from an Application

Ged Mead — Thu, 27 Nov 2008 18:00:00 GMT

This question comes up every so often in the forums and it's one of those things that you'd think should be easy, but actually isn't. Well, it isn't until you know how - like most things in developer land. The question is usually something along the lines of "How can I grab the icon from an MS Word file?" The application may not necessarily be MS Word, but the that's the general thrust of it.

The only approach I have successfully used in this kind of scenario is the SHGetFileInfo API*. This API will grab the icon from an application.

Here's the way I do it: First, Import Runtime.InteropServices into your Windows Form.

Code Copy

Imports System.Runtime.InteropServices

Next, the API code, which goes at the top of the form, outside of any procedures:

Code Copy

    Private Structure SHFILEINFO
        Public hIcon As IntPtr
        Public iIcon As Integer
        Public dwAttributes As Integer
        <MarshalAs(UnmanagedType.ByValTStr, SizeConst:=260)> _
        Public szDisplayName As String
        <MarshalAs(UnmanagedType.ByValTStr, SizeConst:=80)> _
        Public szTypeName As String
    End Structure

    Private Declare Auto Function SHGetFileInfo Lib "shell32.dll" _
            (ByVal pszPath As String, _
             ByVal dwFileAttributes As Integer, _
             ByRef psfi As SHFILEINFO, _
             ByVal cbFileInfo As Integer, _
             ByVal uFlags As Integer) As IntPtr
    Dim hImgSmall As IntPtr 'The handle to the system image list.
    Private Const SHGFI_ICON As Long = &H100
    Private Const SHGFI_SMALLICON As Long = &H1

Note the two Constants at the end there being declared as Long. You'll usually find you have to tweak old API code to fix these kind of lines if you have Option Strict On.

To demonstrate this API in action, here is how I've structured it:

I have added a button (btnSelectFile) to the Form.
When this button is clicked, an OpenFileDialog is created to allow the user to select a file.
Once a file has been selected, the file name is passed to a function that will dig out the icon for that file type and pass it back.
For demo purposes, the Form's default icon will be replaced with this selected one.

Here is the code in the function that grabs the icon:

Code Copy

Function GetIcon(ByVal filename As String) As Icon
        Dim shinfo As SHFILEINFO
        shinfo = New SHFILEINFO

        'Get the small icon.
        hImgSmall = SHGetFileInfo(filename, 0, shinfo, _
          Marshal.SizeOf(shinfo), _
          SHGFI_ICON Or SHGFI_SMALLICON)

        Return System.Drawing.Icon.FromHandle(shinfo.hIcon)

End Function

And here is that function being called from a Button Click, the icon then being shown as the Form's icon:

Code Copy

  Private Sub btnSelectFile_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btnSelectFile.Click
        Dim ofd As New OpenFileDialog

        If ofd.ShowDialog = Windows.Forms.DialogResult.OK Then Me.Icon = GetIcon(ofd.FileName)

End Sub

That's pretty much all there is to it, if you are happy to plonk the icon on the form like that. But in most cases you'll probably want something a bit more reusable. One easy way to store the grabbed icon is to put it in an ImageList.

Assuming that you are only going to deal with one icon at a time, you can do something like this:

Code Copy

Dim myIcons As New ImageList
myIcons.Images.Add(System.Drawing.Icon.FromHandle(shinfo.hIcon))

Now that you have that icon safely stored in the ImageList, you can access the ImageList in the usual way if you want to place the icon image elsewhere. And of course you can change the above code slightly to allow for more than one icon to be added to the ImageList and used as required.

Finally, if you need to switch the icon into Bitmap format you can use the handy ToBitmap method:

Code Copy

Dim bmp As Bitmap = System.Drawing.Icon.FromHandle(shinfo.hIcon).ToBitmap

It is possible then to save the Bitmap by using the Bitmap's Save method. However, I have found this to be a bit hit-and-miss, with it sometimes throwing a generic GDI+ error when I tried to recall it for use by means of the Image.FromFile method.

I hope that if you need to grab an image from an application that you find this article useful.

----------------------------------------------------------------------

* There is the much more hopeful sounding ExtractIcon API which I have used to extract the icon of a currently running VB application, but haven't managed to port the logic over to the kind of file selection scenario described here.

WPF: How To Hide the Minimize and Maximize Buttons

Ged Mead — Wed, 22 Oct 2008 09:17:00 GMT

For some time now, I've been promising myself that one day I will create a list of what I like to think of as "WPF MIA" - those basic elements that I am totally familiar with in WindowsForms, but which somehow seem to have disappeared into thin air in WPF.

In many cases of course the tools are still there; it's just that the name has changed. Here's an example:

In Windows Forms, you can hide the Minimize and Maximize buttons by setting the MinimizeBox or MaximizeBox to False I guess that this is most people's favourite way of doing this. If you dig deeper into the Properties Window though, there is also the FormBorderStyle property.

I used to think that this property was only good for things like changing the border style, say, from 3D to single line. But actually if you choose FixedToolWindow or SizableToolWindow then you automatically get a Form that only has the close button - no Min or Max.

So what about WPF then? Does it have the same properties available?

If you've spent any time on WPF, you'll know that that's really a rhetorical question because you can almost guarantee that things will have changed. Now though you have a WindowStyle property which you can use to set the Window's border style, including showing or hiding the Max and Min buttons. To have those buttons hidden, you need to choose the ToolWindow option.

As far as I know, there isn't a property setting that will hide the individual buttons in in WPF. At first I found this a bit surprising. However, as I've become more familiar with WPF and its ability to morph its Windows into almost any conceivable style and shape, I can see that creating your own Window style is so easy that maybe those properties would have been almost redundant anyway.

Object Initializers - A New Perspective

Ged Mead — Thu, 28 Aug 2008 07:09:00 GMT

There's something that's always bothered me a little bit about creating classes. We go to the trouble of creating backing Private fields and Public properties in order to implement data hiding - right? And when we want to include data validation, we usually use properties for that task, don't we?

But then what do we do? We go and create a parameterized constructor that lets client code push invalid data straight into a field. At least that's what I see in most of the class building examples I've come across - both in books as well as in real world code. It's quite rare to see values passed into properties in a parameterized constructor; fields seem to be the most popular recipients of initialization data.

I'm surprised at how many times I've seen this done. Of course it's possible to include validation in the constructor too (but the examples I've seen that use fields rarely seem to do this; leaving the door to bad data wide open)

Luckily, we now have a very easy solution - Object Initializers.

In fact, you could claim that with the arrival of Object Initializers the parameterized constructor has just about become redundant.

Parameterized constructors were devised to make it easy to pass arguments in to a constructor and to avoid having to add several lines of code for property values when initializing a new object. You know the sort of thing:-

Code Copy

Dim sr As New SalesRecord
      sr.CustomerName = "Joe Soap"
      sr.Total = 2399.65
       '  etc  etc

which was short-circuited with :-

Code Copy

Dim sr As New SalesRecord("Joe Soap", 2399.65)

However, as I said, in most cases people code this so that it assigns the CustomerName and Total values directly to the fields.

Object Initializers step round this issue while still enabling client code to be fairly concise. How it works is that when you initialize an instance of a class object you are allowed to use the 'With' keyword as a way of assigning values to properties, all in one line of code.

Let's knock up a quick class to demo this.

Code Copy

Public Class Product

    Private _itemcode As String
    Public Property ItemCode() As String
        Get
            Return _itemcode
        End Get
        Set(ByVal value As String)
            _itemcode = value
        End Set
    End Property


    Private _cost As Decimal
    Public Property Cost() As Decimal
        Get
            Return _cost
        End Get
        Set(ByVal value As Decimal)
            If value > 0 Then
                _cost = value
            Else
                _cost = 0
            End If
        End Set
    End Property


    Private _itemname As String
    Public Property ItemName() As String
        Get
            Return _itemname
        End Get
        Set(ByVal value As String)
            _itemname = value
        End Set
    End Property


End Class

So, three fields, three properties (one of which includes some validation) and just the default constructor. To create a new instance of the Product class and assign values to any of the properties that interest us, this is what we can now do:

Code Copy

Dim P1 As New Product With {.ItemName = "Widget", .Cost = 0.99}

That's it! A Product instance with those values for the ItemName and Cost properties now exists. And of course the validation is applied effectively at the time of instantiation to avoid any unacceptable values being passed.

Note that the property assignments are contained inside curly braces and not standard parentheses.

  There are several advantages to this approach. Not only does it get around the validation problem I mentioned at the start, but it also allows you to pick'n'mix the properties you want to assign values to when you instantiate the object. As you saw in my example above, I chose only to assign values to two of the properties.

   And if that's not enough to get you interested, there's more. You even have the further advantage that you can pass the values in any order you like (unlike the standard parameter arguments which have to be passed in a strict order).

   Finally, if there is a parameterized constructor available that contains some, but not all, the arguments you want to pass in, then you can simply combine the two approaches and use the constructor's parameters, as well as the object initializers, all in one chunk of initialization code.

  So if you had this parameterized constructor in the class:-

Code Copy

  Sub New(ByVal code As String)
        Me.ItemCode = code
  End Sub

you could use the following code to assign values to all three properties:-

Code Copy

Dim P2 As New Product("TOOL12") With {.ItemName = "Spade", _
    .Cost = "12.99"}

How cool is that?

To be honest, I'm not sure how often I'd want to do that - given that I can do the same thing using three object initializers - but it's an option to consider.

So there it is. A new feature that you may have heard about but weren't sure if it was going to be of use to you. Personally, I think it's great and plan on implementing this approach whenever I can from now on.

How To Navigate Around Your Code in Visual Studio

Ged Mead — Tue, 08 Jul 2008 15:48:00 GMT

One of the things that I've always found a bit frustrating as a project grows larger and larger is that it gets more difficult to navigate backwards and forwards between chunks of code that you've recently accessed.

Now I know that Visual Studio has some built in navigation hot keys:

Ctrl and Minus to go back to the last point,
Ctrl-Shift-Minus to go forward again are the most useful,

but it can still be a bit laborious when you're trying to flit between several sets of code blocks and you don't particularly want to move in a linear or consecutive way.

Step forward that very clever little Add-In (well, not so little really!) CodeSMART. For some reason I'd stopped using it when I upgraded Visual Studios a while back, but when I was looking around for an answer to this problem I remembered that amongst its many little tools is the Code Explorer.

One of the elements included in the Code Explorer window is a history of the last 20 procedures you've visited. So not only can you move backwards and forwards one step at a time, you can of course jump to any of the saved locations just by double clicking on a choice in the list.

It has some smart features (well, it is CodeSmart after all!), one of which is that it greys out any history items from other files - which helps you to very quickly identify those in your current file that you may be looking for.

And best of all? It persists your history list for each individual Visual Studio Solution, so that the next time you access a particular project Code Explorer will be repopulated with the relevant history for that project. How cool is that?

The Code Explorer does have additional features, such as a fast and neat search tool to take you to procedures that match search criteria, together with what's effectively a Favorites store, the Workbench, where you can keep tabs on items you're particularly interested in.

Of course, CodeSMART has a ton of other features and tools, so if you want to check it out you can download a trial version from their website here.