VB.NET and VB 2005

VB 2005: How To Print With Word Wrapped Lines

Ged Mead — Tue, 08 Apr 2008 17:06:00 GMT

Introduction
Printing can often be a bit of a tricky task in .NET. Some things are more easily resolved than others though.

I saw a post recently that raised a problem that seems to occur fairly regularly: You want to print a large chunk of text to the printer, but VB seems to want to print everything all on one long line - even when this means that a lot of the text will be truncated or "printed" invisibly into thin air!

Fortunately, this is one of the cases where the solution is relatively easy. Essentially, what you do is set a rectangle whose width represents the width of your printed page (or any lesser width you prefer). You then pass this rectangle to the DrawString method and it will obediently print within those boundaries.

Solution
Here's the basic solution:

Code Copy

  Imports System.Drawing.Printing

Public Class frmPrint

    ' The document you will use to print on
    Dim DocPrint As PrintDocument

   ' Set font for printing
        Dim fnt As Font = New Font("Verdana", 12, FontStyle.Regular)

'  The printing is fired with a button click event
    Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
        '  Print the textbox content

        DocPrint = New PrintDocument
        ' A handler for it
        AddHandler DocPrint.PrintPage, AddressOf PrintTheTextBox1

        ' Print the document
        DocPrint.Print()
    End Sub

  '  The procedure that does the printing
  Private Sub PrintTheTextBox1(ByVal sender As Object, ByVal e As PrintPageEventArgs)

        'Set a rectangle to bound the  printing
        Dim PrintRect As New RectangleF
        PrintRect.Width = 800
        PrintRect.Height = 1000

        ' Print the text from the TextBox:
        e.Graphics.DrawString(TextBox1.Text, fnt, Brushes.Black, PrintRect)

    End Sub

Yes, But.....
That's OK as far as it goes, but it does suffer from one flaw. When you check your printed page you'll find that the text is stuffed right up at the top left of the paper and each line extends fully across to the very last few millimetres at the right hand side. Now, it may be that paper saving is high on your agenda, in which case you'll be happy. But generally you will probably want a layout that's a bit more generous with its whitespace.

The trouble is that there isn't an overload that allows you to pass in the Rectangle and the start position for the printing. Is that going to stump us? Nah, of course not!

If we go back to the Rectangle itself, there is a constructor overload that allows you to pass in the x and y values as well as the width and height. The x and y values will of course be used as the left and top points respectively of the rectangle as it is positioned on the printed page. So this variation will get the start position, the text line width and text block height all sorted:

Code Copy

Private Sub PrintTheTextBox2(ByVal sender As Object, ByVal e As PrintPageEventArgs)

        'Set a rectangle to bound the  printing
        Dim PrintRect As New RectangleF(30, 100, 750, 1000)
       '  Assign its Left, Top, Width and Height values

        ' Print the text from the TextBox:
        e.Graphics.DrawString(TextBox1.Text, fnt, Brushes.Black, PrintRect)

    End Sub

While I was working on that, I remembered that the Rectangle has a useful little method named Offset (something you would normally use when drawing actual rectangles in a graphics based task). However, by using this method and adjusting the values that are passed so that the top left of the rectangle is shunted down and to the right, we can get nearer to the layout we desire. If you chose to use this alternative route, it would look like this:

Code Copy

Dim PrintRect As New RectangleF
        PrintRect.Width = 800
        PrintRect.Height = 1000
        PrintRect.Offset(25, 60)

Show Me The Width
It probably won't have escaped your notice that I very conveniently just happened to know what width and height I needed for the text to span across the page. Many times you will have this information to hand, but if you don't, what do you do then? Answer: You calculate it by querying the PrintDocument's PageSettings, find the width, height and margins and use those. Here's the code:

Code Copy

   Private Sub PrintTheTextBox3(ByVal sender As Object, ByVal e As PrintPageEventArgs)

        'Set a rectangle to bound the  printing
        Dim PrintRect As New RectangleF

        With DocPrint.DefaultPageSettings
            PrintRect.Width = .PaperSize.Width - (.Margins.Left + .Margins.Right)

            PrintRect.Height = .PaperSize.Height

            PrintRect.Offset(.Margins.Left, .Margins.Top)
        End With


        ' Print the text from the TextBox:
        e.Graphics.DrawString(TextBox1.Text, fnt, Brushes.Black, PrintRect)

    End Sub

Summary

Although there are many more tweaks we could add to this approach, I think that the above will cover many common situations. If text trimming at the end of lines is something you need to refine to the nth degree then you should check out the StringFormat class in general and the StringTrimming enumeration in particular. There are several options available there.

Don't forget of course that you may not need to hand code your printing processes at all. There is a free Power Pack available which will print the contents of a form with minimum effort on your part. This will often be all that you need, but if not then at least you now know how to package up a bundle of text and send it to the printer to be laid out in a way that suits your requirements.

VB2005: How To Remove an Item from a ListBox

Ged Mead — Tue, 19 Feb 2008 17:26:00 GMT

This is something that seems to come up fairly often in the Forums. Someone wants to test for a particular value in a ListBox and if the list does (or doesn't) contain the value then that item is to be deleted.

One common way of doing this would be to use the Contains function to test if the target character or substring exists in the ListBox.

This isn't a particular difficult task, but the thing that usually catches most beginners out here is that you have to traverse the ListBox items in reverse order. Well, you do if you actually end up deleting any items, anyway. The reason being that if you start from the top and work down, then as soon as you delete an item the ListBox's indices get out of sync and an ArgumentOutOfRange Exception will be thrown and you will get a message along the lines of the one shown below:

In a recent post, a slight variation on this theme was that the check was to be made in one ListBox and if the required search string wasn't found in that first ListBox then not only was the item in the first ListBox to be deleted but also the corresponding item number in a second ListBox was also to be deleted.

Again this is straightforward and the following code will do the job :

Code Copy

    Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
        For i As Integer = ListBox1.Items.Count - 1 To 0 Step -1
            If Not ListBox1.Items(i).Contains(TextBox1.Text) Then
                ListBox1.Items.RemoveAt(i)
                ListBox2.Items.RemoveAt(i)
            End If
        Next
    End Sub

As I say, it's not rocket science, but that traversing upwards trick is something worth knowing for these kind of situations.

VB 2005: How To List Known Colors

Ged Mead — Fri, 09 Nov 2007 17:04:00 GMT

I saw a couple of unrelated questions on vbCity recently - one was about PropertyInfo and the other was in regard to Colors - and seeing them reminded me about how easy it is to use PropertyInfo to get access to and list all the 141 named Colors. There are of course other ways of doing this, but I just thought it would be a fun approach to use.

The following example is based on a Windows Form that contains a Button and a ListBox for demo purposes.

First create an array to hold the Colors once we've dug them out of the Colors structure:

Code Copy

Dim Colorprops() As Reflection.PropertyInfo

Next, in the button click event:

Code Copy

    Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
        '  To get hold of the  Members of the Color Structure
        '  the GetProperties method returns an array of properties in the Color structure
        '  and we store them in the ColorProps array
        ColorProps = GetType(System.Drawing.Color).GetProperties

        '  For demo purposes, display the contents of the array in a listbox
        '  We use the Name property to return the string assigned to each property in turn
        For x As Integer = 0 To ColorProps.Length - 1
            ListBox1.Items.Add((ColorProps(x).Name))
        Next

    End Sub

As you can see from the code comments, thanks to the magic of Reflection it's very easy to get an array that contains all the Colors, which are stored as properties in the Color structure. This is achieved in the first code line. Then just for demo purposes I've displayed all the names of the Colors in a listbox.

Of course, if you've gone to the trouble of creating this list you have probably done so because you actually want to do something with the colors. For example, you might want to let the user change the BackColor of the current form.

The potential problem here is that the listbox now contains a list of strings. I know we tend to look at a list like that and can visualise them as colors, but the compiler isn't quite that clever and needs a little human help. So what we can do is to instruct it to take the selected string from the listbox (which represents the desired color) and turn that back into an actual Color object - and this can then be assigned as the Form's BackColor.

You might consider using this code to do the job :

Code Copy

    Private Sub ListBox1_SelectedIndexChanged(ByVal sender As Object, ByVal e As System.EventArgs) Handles ListBox1.SelectedIndexChanged
            BackColor = Color.FromName(ListBox1.SelectedItem.ToString)
    End Sub

and it will work ..... up to a point. However, the first item in the list is the Transparent property, which is a valid Color in many situations but sadly not one that a Windows Form will accept as its BackColor.

At the other end of the list you will see other Color properties, such as R, G, B, A, IsKnownColor and so on. Again these more obviously are not going to be valid BackColor properties for the Form.

As always, alternative solutions are available. Perhaps the easiest one would simply be to wrap the code in an Exception Handler which will then gracefully and silently ignore any non-valid choice:

Code Copy

    Private Sub ListBox1_SelectedIndexChanged(ByVal sender As Object, ByVal e As System.EventArgs) Handles ListBox1.SelectedIndexChanged

        Try
            BackColor = Color.FromName(ListBox1.SelectedItem.ToString)
        Catch ex As Exception

        End Try

    End Sub

Is this a good fix? Probably depends on the scenario you're using it in. If you're planning on exposing this Form to a non-tech savvy user then I'd say it's a pretty poor workaround. They might not understand or be happy that the choice they're making is unacceptable and nothing is happening. Of course you could slip a message box into the Catch block, but personally I think it would be better not to show them unusable choices at all in the first place and so avoid the problem.

So let's look at how we might do that.

I suppose you could exclude the first Color (Transparent) and the final nine ("R" to "Name" inclusive) simply by changing the first line of the loop to:

For x As Integer = 1 To 140

but I'm not crazy about that approach, even though it would work just fine.

My preference would be to try and filter in only those Colors that are system defined Public Shared Colors - that is, the named Colors themselves and effectively excluding the final nine entries in the list which are instance members. Once again Reflection makes this a very easy task.

The GetProperties method takes BindingFlags as parameters and you can use these to filter the search. In our case we will use the Public and Static BindingFlags. (You don't have to remember all the available Flags as the full enumeration of them will be displayed as soon as you type an opening bracket after "GetProperties"): -

Code Copy

  ColorProps = GetType(System.Drawing.Color).GetProperties(BindingFlags.Public Or BindingFlags.Static)

If you run the code again you will now only offer the 141 Colors to the user via the ListBox. "Transparent" is of course a valid Color so it's right that it appears in the list of Colors. But because we have refined the task to assign the Colors to the Form's BackColor, we still have to resolve this.

Again, a quick and acceptable fix would be to use a Try Catch Exception Handler.

But what if our scenario really was one where we want to allow the user to change the Form's BackColor to Transparent? Well we quite easily do this by intercepting the user's choice and if it turns out to be a choice of "Transparent" then we can manually make the whole form transparent by changing its Opacity property.

Now, I know this isn't a 100% fix for making the BackColor transparent because the transparency effect is applied to the whole form, not just the client area. Unfortunately the ClientRectangle doesn't have its own Opacity property, so I think that this code will be the nearest we can get:

Code Copy

Dim col As New Color
        col = Color.FromName(ListBox1.SelectedItem.ToString)
        If col.Name = "Transparent" Then
            Me.Opacity = 0.15
        Else
            BackColor = col
        End If

The allowed values for Opacity range from 0 (invisible) to 1 (fully visible). I purposely didn't set the value to 0, because of course this would mean that the user would lose the total form from view and wouldn't even be able to access the title bar to, for example, close the form.

In fact, I'd be inclined to make the whole deal a bit more user friendly by showing the user a one-time message about how to remove the Transparent setting. So the ListBox selection code would now be:

Code Copy

  Dim msgshown As Boolean

    Private Sub ListBox1_SelectedIndexChanged(ByVal sender As Object, ByVal e As System.EventArgs) Handles ListBox1.SelectedIndexChanged

        Dim col As New Color
        col = Color.FromName(ListBox1.SelectedItem.ToString)
        If col.Name = "Transparent" Then
            Me.Opacity = 0.15
            If Me.msgshown = False Then
                MessageBox.Show("Double Click the form to undo the Transparent setting", "Info", MessageBoxButtons.OK)
                msgshown = True
            End If
        Else
            BackColor = col
        End If

    End Sub

and in order to implement that reinstatement of full Opacity, you would just need :-

Code Copy

    Private Sub Form1_DoubleClick(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.DoubleClick
        Me.Opacity = 1
    End Sub

So that's it. Dealing with colors (as color objects and not as names that we visualise in our heads as actual colors) can be a bit tricky until you get used to how it works. I hope that this relatively simple walkthrough has helped clarify things for you.

VB 2005 : How To Move Items Up a ListBox

Ged Mead — Mon, 08 Oct 2007 16:41:00 GMT

I had to revisit this problem recently and so had to recall how I did it. Here's the scenario: You have a ListBox and a Button. User selects an item in the ListBox. If they want to move that item up the list they click the button. They can keep clicking the button until the item reaches the top of the list if they want to, or just stop when they've reached the desired position anywhere up the list.

I don't know of any inbuilt way of doing this, so this was my fix:

1. First set the Button's Enabled property to False in Design View (or on Form Load)

2. When the user first selects a new item, decide if it is possible for this item to go any higher. If it's not already at the top of the list then enable the button.

Code Copy HideScrollFull

Private Sub ListBox1_SelectedIndexChanged(ByVal sender As Object, ByVal e As System.EventArgs) Handles ListBox1.SelectedIndexChanged

If ListBox1.SelectedIndex > 0 Then UpButton.Enabled = True

End Sub

3. Then make a note of the content to be moved and the element number of the next item up.

4. Make sure that the user isn't trying to move the top item up and if they are, then avoid the Exception by exiting the sub, after first disabling the button.

5. Temporarily store the text content in a variable.

6. Delete (Remove) the item you are about to move.

7. You then reinsert the deleted text at the next element higher up the list.

8. Finally, you reselect and automatically highlight the item the user is moving so that the whole action appears seamless to them.

Here's the Button's code:

Code Copy HideScrollFull

    Private Sub UpButton_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles UpButton.Click

        ' Decide where to move item to : Note next position
        Dim NextPosition As Integer = ListBox1.SelectedIndex - 1

        ' If we have reached the top (or user selects first item manually)
        ' don't attempt the move and disable button
        If NextPosition = -1 Then
            UpButton.Enabled = False
            Exit Sub
        End If

        ' Copy the value temporarily
        Dim tempstr As String = ListBox1.SelectedItem.ToString

        ' remove the item and reinsert it one place higher
        ListBox1.Items.Remove(tempstr)
        ListBox1.Items.Insert(NextPosition, tempstr)
        ' Reselect the newly inserted item to assist the user
        ListBox1.SelectedIndex = NextPosition

    End Sub

It's one of those little things that you feel should be easy, but actually needs a bit of thought to make it work.

Windows Forms - Aligning Two Forms

Ged Mead — Sun, 05 Aug 2007 12:15:00 GMT

This tip barely qualifies as a Gotcha! but I have seen some people get stuck with it, so thought it worth a mention.

If you want to control exactly where a second form is placed in relation to another form, you can use code that shifts the second form to either side or above or below the first one.

The key is to ensure that you set the StartPosition of the forms to "Manual". If you do this, each form in the project that i set to Manual will automatically be placed at position 0,0 - i.e top left of the screen. (By default this property is set to "WindowsDefaultLocation").

So, to take a scenario with two forms, you can leave Form1 as-is and set the location of Form2 relative to Form1.

For example to align the two forms horizontally but with Form2 placed immediately to the Right of Form1 you could use:

Code Copy

        Dim F2 As New Form2
        F2.Left = Me.Width + 2
        F2.Top = Me.Top
        F2.Show()

As you can see the calculation is based on the width of the first form, plus a small margin added for appearance's sake. The result is:

It's simple to use the same approach to place the second form anywhere you wish in relation to the first. Below it, for example:

Code Copy

        Dim F2 As New Form2
        F2.Left = Me.Left
        F2.Top = Me.Height + 1
        F2.Show()

So, just use whatever offset suits your needs, and don't forget to change that StartPosition property first.

Try Now, Buy Later - Framework 3.0 Extensions in Visual Studio 2005

Ged Mead — Wed, 01 Aug 2007 11:46:00 GMT

I was discussing Windows Presentation Foundation (WPF) recently with someone on VBCity. Although many people don't have the time or available capacity to download the huge Visual Studio 2008 (previously known as Orcas) Beta on a development machine, it is still possible to get a foretaste of what's to come.

If you go to this link you can download the Framework 3.0 Extensions for Visual Studio 2005. Now, it's getting a bit dated and the VS 2008 Betas already have a much better range of tools and support such as Intellisense, but I think it is still worth a look if you are interested in what is coming down the road.

The .NET Framework 3.0 SDK can be downloaded from here.

You will also need to download and install Framework 3.0 if you are running XP on your system (Vista has it installed by default) .

The extensions include WPF and WCF - Windows Communication Foundation. Even if you don't do anything other than poke around with the new stuff, it's interesting to see how WPF, XAML and VB.NET all work together to create some top class user interfaces. (Or some terrible ones if you get carried away with animation, video and clashing colors!)

Projects available in VS 2005 are:

WPF Windows Apps
XAML Browser Apps
WPF Custom Controls
WCF Service

VB 2005: How To Hide / Show Multiple TabPages in a TabControl

Ged Mead — Wed, 18 Jul 2007 11:19:00 GMT

Introduction
In the previous parts we looked at ways of hiding and showing a single Tab Page in a TabControl. In some situations you may need to hide and show multiple pages.

This is still fairly easy to do, but now you need a collection in which to hold the TabPages you have removed. (Remember from the previous descriptions that you are not really hiding the TabPages, you are in fact completely removing them, but storing a copy in memory that you can later call on to reinstate the page)

A Collection of Saved TabPages
In VB2005 the availability of generic collections makes our life very easy and we can create type safe collections automatically. In this case we will create a List and this list will only allow TabPage objects to be stored in it. Here is the code that does this:

Code Copy

    '  A collection of removed TabPages
    Dim colRemovedTabs As New List(Of TabPage)

Allowing User to Select
For demonstration purposes we need a way of listing all available TabPages. Whether this list is visible to the user and/or how it is displayed will depend on your particular application. For this article I will list all the TabPages in a standard ListBox control.. This list box will be populated when the form is first loaded:

Code Copy

    Private Sub Form1_Load(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Load
        For Each tabpg As TabPage In TabControl1.TabPages
            Me.ListBox1.Items.Add(tabpg.Text)
        Next

        ListBox1.SelectionMode = SelectionMode.MultiSimple
    End Sub

The final line of code inside that procedure is there simply to ensure that the user can select more than one TabPage at a time.

Now the user can simply select multiple items (TabPages) from the listbox.

Removing and Saving
Once they have made their selection, a button click is used to confirm that those pages should be hidden/removed. The click event code is as follows:

Code Copy

    Private Sub Button7_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button7.Click
        ' Hide multiple pages
        For Each tabpg As TabPage In TabControl1.TabPages
            For Each item As String In ListBox1.SelectedItems
                If tabpg.Text = Trim(item) Then
                    colRemovedTabs.Add(tabpg)
                    TabControl1.Controls.Remove(tabpg)
                End If
            Next
        Next

    End Sub

All we have here is a nested loop. Firstly we loop through all of the TabPages in the TabControl. Inside that loop, we also loop through all the selected items in the listbox.
If we find a match between the selected item and the text (the string used on the Tab of a TabPage) then we know this item needs to be hidden..

We store its information in the collection (colRemovedTabs) before removing it from the TabControl. The approach is very similar to that used in the earlier single TabPage examples.

Reinstating Removed TabPages
Reinstating the TabPages is also an easy task. We have them all saved in the collection, so we can simply dip in and grab them all.

Once again I've placed this in a Button Click event for demo purposes:

Code Copy

    Private Sub Button8_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button8.Click
        '  Reinsert all removed pages
        For Each savedTab As TabPage In colRemovedTabs
            TabControl1.Controls.Add(savedTab)
        Next

        ' Clear the collection as it has now done its work
        colRemovedTabs.Clear()

    End Sub

You will see that I have also cleared out the contents of the collection as the last code task. If you don't do this then further clicks of the button will result in duplicate TabPages being added back to the TabControl; probably not what you want in most situations.

Summary

It is also fairly easy to reinstate only certain hidden TabPages. The code for this is included in the demo solution which you can download from here.

The completed project looks like this:

So now you have seen how to "hide" and "show" individual or multiple TabPages. As I said at the start of the first part of these articles, this is one of those simple looking tasks that takes a bit more effort than you first think, but really isn't very difficult once you realise that you can work round the limitations.

Hiding a TabPage (2) - User's Selection

Ged Mead — Fri, 29 Jun 2007 08:33:00 GMT

In the previous part I looked at a very simple scenario where the developer knew in advance which TabPage should be hidden and re-shown. Next we'll look at doing the same thing, except that this time the user gets to choose which TabPage is hidden.

As in the previous example, you're going to need some kind of trigger to kickstart the Hide or Show activity. I've used a button placed outside the TabControl on the form itself, but you could use any other trigger that suits your purpose - e.g. a button or checkbox inside a TabPage.

In fact of course it doesn't even have to be wired up to the clicking on a Windows Forms Control - you could hide the TabPage based on some kind of text input from the user.

Anyway, in this example, the button click code needs to :

Identify which TabPage currently has focus
Then store this TabPage's metadata in the TempTab variable
Before finally Removing the TabPage from the TabControl.

Here is the code I've used:

Code Copy

   Private Sub Button3_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button3.Click
        '  Identify the TabPage to be removed
        For Each tp As TabPage In Me.TabControl1.TabPages
            If tp.Focus = True Then
                TempTab = tp
                TabControl1.TabPages.Remove(tp)
                Exit For
            End If
        Next
    End Sub

I think that code is pretty straightforward. To identify the single Tabpage that currently has focus you have to enumerate through all of them until you find the right one.

For Each tp As TabPage In Me.TabControl1.TabPages
If tp.Focus = True Then

Once you've located it, store it in TempTab;
then remove it:

TempTab = tp
TabControl1.TabPages.Remove(tp)

Finally (and crucially) don't forget to jump out of the loop once you have found your TabPage and taken the appropriate action on it.

Exit For

Why? Because what happens when you remove a Tabpage is that Focus automatically shifts to the first TabPage in the TabControl. Therefore if you don't jump out of the loop, it will keep finding TabPages that have focus, one after the other, and will keep removing them until all are gone. You won't get an Exception, but you won't have any TabPages either! (And only the most recently deleted one will be available for reshowing; you will have permanently lost all the others.)

OK, the code to show the TabPage again is simple:

TabControl1.TabPages.Add(TempTab)

As mentioned earlier, you will get unwanted results if you allow this button to be clicked more than once consecutively, so I advise that you add further code to avoid this happening. I will post up a downloadable sample project that includes this, but for conciseness won't deal with it in this blog.

So that would seem to fix the "Remove user's choice of TabPage" problem easily enough. But what if for some reason it's important to reinstate the saved tabPage back in the TabControl in its original position?

All sorts of ways of doing this spring to mind, but just because I want to keep this part really uncomplicated, I'm simply going to set up a second variable, call it TempTabIndex and make it an Integer Type.
We will save the TabPage to TempTab as before and save the index value to TempTabIndex.

Here's the code:

Code Copy

  '  Identify the Index Number of the selected TabPage
        With TabControl1
            For i As Integer = 0 To .TabPages.Count - 1
                If .TabPages(i).Focus = True Then
                    '  Save the details of this TabPage
                    TempTab = .TabPages(i)
                    '  Save its index number
                    TempTabIndex = i
                    '  Remove it
                    .TabPages.RemoveAt(i)
                    '  Stop looking for Tabpages with Focus
                    Exit For
                End If
            Next
        End With

As you can see, instead of enumerating through the TabPages what we do here is iterate through the TabControl's TabPages collection, an index at a time.
Once we find the TabPage that has focus, we can also easily grab the current index number and store that, as well as storing the tabPage data in the same way as we did previously.

And again as in the earlier example, it's important to ensure that you jump out of that loop as soon as you've completed the work on the one TabPage we're interested in.

Reinserting the TabPage back into its correct original position simply requires us to pass in the Index number and the TabPage name to the TabControl's.TabPages Insert method:

Code Copy

Private Sub Button6_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button6.Click

        '  Reinsert TabPage in correct position
        TabControl1.TabPages.Insert(TempTabIndex, TempTab)

End Sub

The project described in these first two parts now looks something like this:

In the next part I want to look at a more complex situation; one where more than one TabPage is hidden at a time.

VB 2005: How To Hide and Show a TabPage in a TabControl

Ged Mead — Mon, 25 Jun 2007 11:10:00 GMT

AfterNote: There are now three blog items on this topic, each showing a different aspect If you want to view them all as one article, follow this link)

Sometimes you may want to hide a TabPage from the user's view, but you don't want to permanently remove it. Now, if you've checked out the TabPage's methods you will see that it does have a "Hide" method in VB 2005. That's great, but the trouble is if you try using it, it doesn't work! You won't get an Exception, but you won't get a disappearing Tab Page either. (And if you're using an earlier version of VB.NET you have a choice of Hide or the Visible property, but neither will have the effect you want if you try using them.)

Actually, the way to hide a TabPage is to access it through its parent container - the TabControl itself. We'll take a look at how to do this. (and possibly how to sidestep other problems along the way).

Let's start with the situation where you know that you are only going to want to hide and show one specific TabPage in a TabControl which has a set number of TabPages.

First, you need somewhere to store the info about the TabPage. In this scenario a simple variable will do:-

Code Copy

    '  A temp variable to hold a single hidden Page
    Dim TempTab As TabPage

The code goes at the top of the form, outside any procedures.

Next, in the event you are using to trigger the hide action, (maybe a button click - see the "Hide TabPage 2" button in the screenshot below),

you store the chosen TabPage in that TempTab variable.
And finally you use the Remove or RemoveAt method to physically delete the TabPage from within the TabControl.

Code Copy

TempTab = TabControl1.TabPages(1)
TabControl1.TabPages.RemoveAt(1)

Because we knew in advance that we would be hiding and removing the second TabPage (whose Index is 1, of course), we can use the RemoveAt method. This is the most straightforward approach to use in this situation. So the situation currently is that the TabPage no longer exists in the TabControl, but you have squirrelled away a copy in that TempTab variable for later use.

What we need to look at next is reinstating the hidden TabPage when needed. Again this is quite simple. We insert the TabPage back into the TabControl, taking care to insert it in its proper original position.

Code Copy

  Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button2.Click
        TabControl1.TabPages.Insert(1, TempTab)
  End Sub

The parameters of that Insert method are the Index to Insert at (Index 1, in this case, as that's where it came from) and the TabPage itself, as identified by its name. (Don't confuse its name with its Text. In this example they happen to be the same, but in a real world example this is unlikely to be the case).

If you're wondering about the purpose of the TextBox in that screenshot, I put it in so you could really prove to yourself that this does work.

If you create a Form as shown and enter some text into the TextBox at runtime and then Save/Remove the TabPage you want to be sure that any data input by the user really does get saved too. So, run the project, enter your name, hit the first button to hide the TabPage, then hit the second one to show it again. As you will see, even dynamically entered data, such as the text in the textBox, is saved and reinstated.

To re-emphasise the point I made earlier about the Name of the TextBox being used as the key parameter, not the Text that the user sees on the Tab, take a look at the following screenshot:

The same code as used above will work perfectly with these TabPages, because I have only changed the Text and not the Name.

By the way, if you don't need or want to reinsert the TabPage back in the position you took it out from, you can simply have it placed at the end of the current collection by using:

TabControl1.TabPages.Add(TempTab)

instead.

However, one little Gotcha to watch out for (it's obvious when you think about it, but ...) is that if you use the "Show" button more than once then you will get multiple TabPages added; each of which has the same Text and - more importantly - each of which has the same Name.
However, not so obvious, and even worse, is that this multiplicity of Tabpages with the same name gives the compiler such a headache that in fact you will lose all the controls and formatting from all copies of that TabPage. Not something that you would normally want to happen, so you should include code to restrict the Hiding/Showing to single instances.

So far, so good. In the next part we'll look at a slightly more complex scenario.

VB 2005: The "Missing" Sub Main Problem

Ged Mead — Tue, 19 Jun 2007 13:02:00 GMT

As I've said on many occasions in the past, it's those sometimes tiny little Gotchas that will cause you the greatest amount of aggravation. Here's one that I've been meaning to blog for a while now. It's a question/problem that comes up fairly often and it usually goes something like this:-

"In a Windows Forms project, I add a module that has a Sub Main procedure in it. I want to use this Sub Main as the StartUp Object in the application. But when I look in the project properties, I don't see "Sub Main" as a choice. "

"It used to be here in earlier editions - where has it gone to and how can I access it? "

The solution to this particular Gotcha is very easy.

Open up the Project Properties page.
Home in on the "Enable Application Framework" CheckBox.

Uncheck this option (i.e. disable it)

Now if you view the "Startup Form" combo you'll see that it has changed so that it reads "Startup Object".
Click on the combo and all the forms plus the module and the Sub Main inside that module will all be available as Startup objects.

It's one of those "simple when you know" things that'll drive you mad if you don't!