VB.NET and VB 2005

Populating a WinForms ListView from a Text File

Ged Mead — Mon, 26 Oct 2009 12:41:00 GMT

The Windows Forms ListView is designed to display data. You can use a simple text file as the data source of a Windows Forms ListView. Let's start with a scenario where you have a txt file that contains the data. Each line of the text file represents one row of data to be displayed in the ListView. The content for each column item (or cell) is delimited by the use of a TAB character.

A simple text file along these lines might contain the following entries:

Ged Mead UK
Serge Baranovsky USA
Larry Blake USA
Scott Waletzko USA
Mark Dryden UK
Dave Jeavons UK
Chris Manning USA

(The uneven layout is caused by the use of the TAB as the delimiter)

Reading data from a file
An easy way of transferring this data from the file to the ListView is to:

Use a StreamReader which accesses the text file and then reads it line by line.
As each new line is read, it is split by means of the TAB character and temporarily stored in a String array.
Next, the first element is pulled out of the String array and used as the item for the first column of the ListView (the ListViewItem).
Then the remaining two elements are pulled out of the String array in turn and assigned as the SubItems of the ListViewItem.

Here's the code that carries out those steps:

  ' Variable for file to hold data
    Dim TextFile As String = "F:\MVPs.txt"
 
    Private Sub btnGet_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btnGet.Click
 
        Try
            ' Declare StreamReader and pass the Path of the text file to be read as a Parameter 
            Dim SR As New StreamReader(TextFile)
            '  Variable to hold data as it is read line by line
            Dim strTemp() As String
 
            Do While SR.Peek <> -1 ' Use Peek to read the file until there are no more lines 
                '  Create a variable for the ListViewItems
                Dim LVItem As New ListViewItem
                '  Read the next line in file and Split it using the TAB. 
                strTemp = SR.ReadLine.Split(Chr(9))
                '  Pull out the first element in the line and assign it as
                '  the data for the first column.
                LVItem.Text = strTemp(0).ToString
                '  Add the item to the ListView
                LVMVPs.Items.Add(LVItem)
                '  Assign elements 2 & 3 as the subitems.
                LVItem.SubItems.Add(strTemp(1).ToString)
                LVItem.SubItems.Add(strTemp(2).ToString)
            Loop
 
            SR.Close() ' Close the StreamReader 
 
        Catch ex As Exception
 
            MsgBox("Error reading file." & ex.Message)
 
        End Try
 
    End Sub

You'll see that I've used a variable to hold the path to the file that contains the data. You will also need to include an Imports statement for System.IO at the top of the Class file.

Although the above code will successfully access the file, read and split the data and then populate the ListView, the result you will see may not be what you expect or want:

The first problem is that the View Property of the ListView needs to be set to Details. By default it is set to LargeIcon, with the result you see in the screenshot. You can make this change via the Properties Window or in code.

        LVMVPs.View = View.Details 

Make that change, run the project, hit the 'Get From File' button and you will see:

Again, definitely not what you want! The problem here is that the ListView won't automatically create columns for you, even though you might expect that it would based on the data you are feeding in. As it is traditional to have some header text at the top of each column, you can create this at the same time as you create the column itself .

        LVMVPs.Columns.Add("First Name", 76)
        LVMVPs.Columns.Add("Surname", 96)
        LVMVPs.Columns.Add("Location", 56) 

Now, when you run the project again you will see the data neatly tabulated in the ListView.

I have also set the width property of each column in the code above, because the default width would result in some of the longer strings being truncated otherwise.

If you don't want to hard code those column headers, you can change the text file structure and have the column headers written to the first line of the file. You would then pull these out first and assign them to the columns, before using the Do While loop to read and display the rest of the file.

Writing data to a file
Although a ListView's key purpose is to display existing data, there may be times when you have edited the content and want to save it back to a text file. The steps involved in doing this are as follows:

Use a FileStream to set up the file you are going to write to.
Use a StreamWriter to access the chosen file.
Loop through each row of the ListView, pull the text data from each column in turn and write it to the text file, adding a TAB character after each item.
Add a new line at the end of each loop.

The code for this process is:

   Private Sub btnSave_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btnSave.Click
        '  Create FileStream and StreamWriter to access and write to file
        Dim FS As New FileStream(TextFile, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.ReadWrite)
        Dim SW As New StreamWriter(FS)
 
        Try
            '  Loop through all rows
            For Index As Integer = 0 To LVMVPs.Items.Count - 1
                '  Internally loop through all columns, gathering items
                For SubIndex As Integer = 0 To LVMVPs.Items(Index).SubItems.Count - 1
                    SW.Write(LVMVPs.Items(Index).SubItems(SubIndex).Text & Chr(9))
                Next
                '  Create new line ready for next row
                SW.Write(Environment.NewLine)
 
            Next
        Catch ex As Exception
 
            MsgBox("Error saving to file." & ex.Message)
 
        Finally
 
            SW.Close()
            FS.Close()
 
        End Try
 
    End Sub

For many simple scenarios where you want to display tabulated text in a ListView (and optionally save it back to a file), the above approaches will work just fine. There will of course be times when you need something more sophisticated and I will look at some of those in later blogs.

Date and Time: How To Create a 'Time' element

Ged Mead — Sat, 05 Sep 2009 11:18:00 GMT

I've often thought that dealing with dates and times can sometimes be much more difficult than it should be. There is a bewildering range of choices, many of which seem to do pretty much the same thing and you can sometimes wonder which is the 'right' way. One good example of the multiple choices is identifying a time. I don't mean a TimeSpan - which is a period of time - but a single specific moment in time, such as 8 o'clock, that you want to isolate and maybe compare, manipulate or filter in some way.

You can of course take any DateTime instance and display only the time element by using ToShortTimeString or ToLongTimeString.

        TimeCheck = New DateTime
        TimeCheck = Now
        Console.WriteLine("TimeCheck =  " & TimeCheck.ToShortTimeString)

You can also drill down and pull out the hour, minute, second or any combination of those.

        TimeCheck = New DateTime
        TimeCheck = Now
        Console.WriteLine("TimeCheck Hour and Minute = {0}:{1}  ", _
           TimeCheck.Hour, TimeCheck.Minute)

Also available is the TimeOfDay property of the DateTime class, which - as you would expect - will return the time element. However this is a TimeSpan which in some cases can make it very fiddly to manipulate. It is also a ReadOnly property, so you can't use it to set a new time.

And by coincidence, only today I learned of yet another one - the TimeString property, which returns the current time in HH:mm:ss format. But that is fixed to the current time, not some time point of your choice.

The TimeValue function offers a different approach. Although it gives the appearance of being just a time - e.g. 14:22:30 or 3:15 PM and so on - it is basically a full standard DateTime, but the date is always constrained to be 1st January in the year 0001. For most purposes when you use TimeValue it conveniently ignores that date, anyway.

You can extract the time value of any particular date and time by passing in a DateTime instance to the TimeValue function:

       Dim DT As DateTime = TimeValue(Now)

TimeValue returns a String, so there is no need to cast to any of the String formats to read it as text:

Console.WriteLine(DT)

If you run those last two lines of code, you may be surprised/disappointed to see that it still includes a date. However, remember that the original DateTime we passed in was the DateTime value Now. As you will see in the Console printout, the real value of today's date has been dropped and is replaced by the 01/01/0001 date.

TimeValue also allows you to manufacture a time. In the next example, a time of 1400 hours or 2pm is created:

        Dim TVTime As DateTime
        TVTime = TimeValue("14:00")

Note that unlike the overloaded constructors of the DateTime class, you don't have to include year, month and day - for the obvious reason that they would be ignored anyway.

Although I haven't done so, you can also include a value for Seconds to the time you create.

You can add or subtract elements of time from the currently stored time by using AddHours, AddMinutes, AddSeconds, etc

Finally, you can compare times. If you wanted, for example, to check if a particular deadline had passed you can compare the times extracted with TimeValue:

        Dim TVTime As DateTime
        TVTime = TimeValue("14:00")
        If TimeValue(Now) > TVTime Then
            Console.WriteLine("Passed deadline")
        Else
            Console.WriteLine("Not yet reached")
        End If

There is really nothing in TimeValue that can't be achieved by manipulating other properties and methods of the DateTime class, but in many situations it's a neat function that will make for easier, cleaner code.

How To Format a String to Currency

Ged Mead — Fri, 31 Jul 2009 20:47:00 GMT

Here's a useful little tip for if you have a numeric value and you need to convert it into your local currency.

Let's assume you take in a value as a Double and you want the output to be in the format of currency, with two decimal places (in the case of the UK to represent Pence).

Here's the Double:

Code Copy

     Dim TotalCost As Double = 123.4567

To show this formatted, you can use the String.Format method, a placeholder for the variable and the 'c' attribute to ensure the currency format is used:

Code Copy

       Label1.Text = String.Format("Total Cost = {0:c}", TotalCost)

The result would look like this:

Notice that it automatically rounds up for you, changing '4567' to '46'.

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.

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.