softlogger Latest Articles ::VB-NET

Changing The Background Color of a TabControl's Tab

VB & .NET Blogs @ vbCity.com — 2008-01-14T00:00:00

I've noticed a couple of questions in the VB.NET forums recently where someone wants to change the BackColor of the Tab Header on TabPages. As far as I know, in VB2005 and earlier you have to either use OwnerDraw techniques or subclass your own version of a TabControl.

In VB2008, WPF offers a much easier route. The equivalent element to a TabPage in Windows Forms is the TabItem in WPF. The WPF TabItem actually has its own Background and Foreground properties, each of which will be applied to the Header Tab.

Of course you can also set the Background color of the main TabItem page itself via panel type controls with their own Backgrounds set as required. The ListBox in the screenshot demonstrates this.

The following sample is a very basic example of doing this.

Code Copy

   <TabControl Margin="8" Name="TabControl1">
      <TabItem  Header="Members" Background="LightGreen"
       Foreground="Navy">

        <Grid>
          <ListBox Width="150" Background="LightGreen"
                   HorizontalAlignment="Left">
            <ListBoxItem>J Smith</ListBoxItem>
            <ListBoxItem>J Jones</ListBoxItem>
            <ListBoxItem>C B Travis</ListBoxItem>
            <ListBoxItem>L Fourleather</ListBoxItem>
          </ListBox>
        </Grid>
      </TabItem>

      <TabItem Background="Green" Header="Associates"
       Foreground="Navy" >
      </TabItem>

      <TabItem Background="LightBlue">
                <TabItem.Header>
                    <StackPanel Orientation="Horizontal" >
                        <Image Width="20" Source="CLUB.BMP"/>
                        <TextBlock Text="   Sponsors" Foreground="Red"/>
                    </StackPanel>
                </TabItem.Header>

                <Grid>
                    <ListBox>
                        <ListBoxItem>J Smith</ListBoxItem>
                        <ListBoxItem>J Jones</ListBoxItem>
                        <ListBoxItem>C B Travis</ListBoxItem>
                        <ListBoxItem>L Fourleather</ListBoxItem>
                    </ListBox>
                </Grid>
            </TabItem>

    </TabControl>

The result looks like this:

One thing to note is that by default the Header will revert to a White background when it has focus (as shown in the above screenshot). A side effect of this is that you have to be aware that your Foreground will also need to be such that it is visible on both a white background as well as the one you set. To change this behaviour you will probably have to apply a Style or use a ControlTemplate. I haven't fully researched this yet, but plan to write a full article on TabControls and these little tips and tricks in the very near future. But in the meantime if all you need is a more colorful set of headers then WPF supplies the easy answer.

Share Files Over the Internet from Your Computer with HFS [Featured Windows Download]

Lifehacker — 2008-01-10T00:00:00

Windows only: Freeware application HFS (HTTP File Server) makes it dead simple to run a server to share files from your computer over the web. All you have to do is run the application on the computer with files you want to share, then selectively pick files or directories you want to allow access to. In addition, you can even upload files to your HFS server from elsewhere. You'll need to set up port forwarding for port 80 on the computer running HFS and then either remember your public IP address (which may change) or assign a name to your home server (for free) so it's easy to remember. HFS is freeware, Windows only, and weighs in at a svelte 550KB. HFS Advanced mode even supports user accounts.

Box Clever - The WPF ListBox (2)

VB & .NET Blogs @ vbCity.com — 2007-09-20T00:00:00

Moving Beyond Simple Strings

Introduction

In the previous item on Listboxes I looked at some ways of tweaking a WPF ListBox which contained only strings. As the range of what can be included in a ListBox is far greater than simple strings, I want now to move on to more complex displays.

In WPF it is very easy to create listboxes that contain a variety of content types. For example you can list a collection of images one below the other:

Although it's not immediately obvious from the screenshot, the second item - the Motor Caravan - is the currently selected item. This is signified by the blue borders to the left and right of the image. There are ways we can improve on this.

A rather fragile version of the XAML code for this ListBox is as follows :

Code Copy

<ListBox Name="lstBox1" Margin="12" Width="99"> 
<Image Source="C:\Tent4A.jpg" Margin="2" />
<Image Source="C:\Motorhome1.jpg" Margin="2" />
<Image Source="C:\caravan.jpg" Margin="2" />
ListBox>

When is a ListBox Item not a ListBoxItem?

You may remember that in my earlier ListBox blog example, I placed each of the strings that I wanted to list inside a separate ListBoxItem. The main reason for doing this was to ensure that each string appeared on a new line. If I had simply listed the strings one after the other (i.e. without enclosing them inside the ListBoxItem tags) then the result would have been a ListBox with one single line which would read: "First Item Second Item Third Item ..." etc. That is, the ListBox would in fact contain only one item.

Another reason for wrapping the strings inside the ListBoxItem tags is to ensure that each item acts in the way we would expect an item in a ListBox to behave. If you don't do this, then the item will behave according to its actual type. So, to come back to our example above where we use a list of images, those images will behave exactly as you would expect images to behave and not as you may wish ListBoxItems to behave. Often it will not be an important distinction, but it's useful to understand that this is the situation.

So the simple answer to the conundrum above "When is a ListBox Item not a ListBoxItem?" is:- "When you don't specifically make an item in a ListBox a ListBoxItem type.

Using Resources to Store Images

As I mentioned above, the XAML code to create the ListBox isn't very robust as it uses hard coded paths for the three images. In reality you would probably do one of two things. Either place the images in your project as Resources (see my blog items here and here for more info on how to do this). Alternatively, very often you will bind some kind of collection of images (or images and text) to the ListBox. In this article I will only deal with the first alternative, but plan to cover the data binding aspects in a later one.

Combining Images and Text in a ListBox

Let's take a look at a basic ListBox layout that combines an image with text. Here is one example:

In this example the third item is currently selected and highlighted in blue.

What you see in the screenshot is a ListBox which contains three ListBoxItems. Each ListBoxItem includes both an image and some text. Now, you may well be tempted to try and code it like so:

Code Copy

<ListBoxItem> 
<Image Source="Images/Tent4A.jpg" Margin="2" />
<TextBlock >Tent - Grassed areas onlyTextBlock>
ListBoxItem>

But if you do that, then all you would get for your effort is a syntax error telling you that the Content property is declared twice. The ListBoxItem can only contain one child. This is a very common theme in XAML and you soon learn that in order to display multi layered elements all you have to do is to place sub-elements and sub-sub-elements and so on inside new container controls - the Russian Doll approach.

To create this first example, all I have done is create a StackPanel - which is obviously a container control by its very nature - and placed the Image as well as the text inside the StackPanel. (If you want an introduction to the basics of the StackPanel, check out my earlier blog item here.)

The StackPanel won't take the text as a plain string in the way that a ListBoxItem will. So the way round this is to place the text inside a TextBlock. (A TextBlock is a control whose sole purpose in life is to display text in a format of your choice - a label with attitude!)

So here is the XAML code so far:

Code Copy

<ListBox Name="lstBox1" Margin="12"
   HorizontalContentAlignment="Center"  > 
<ListBoxItem> 
<StackPanel > 
<Image Source="Images/Tent4A.jpg" Margin="2" />
<TextBlock >Tent - Grassed areas onlyTextBlock>
StackPanel>
ListBoxItem>

<ListBoxItem>

<StackPanel > 
<Image Source="Images/Motorhome1.jpg" Margin="2" />
<TextBlock >Motor home - Hard standing onlyTextBlock>
StackPanel>
ListBoxItem>

<ListBoxItem>
<StackPanel> 
<Image Source="Images/Caravan.jpg" Margin="2" />
<TextBlock >Caravan - Grassed areas or Hard standing
TextBlock>
StackPanel>
ListBoxItem>
ListBox>

For all that it may be a bit verbose, I don't think anyone could argue that this visual tree is hard to follow - in the sense that each step of the creation procedure of each element is laid out and clear to see. I've previously touched on ways of reducing the bloat, such as using Styles. In a future blog I will cover Control Templates, which is another immensely powerful route to reducing repetition, among other benefits.

If you click with the mouse on any part of a ListBoxItem or its contents then you are able to use that event in whatever way you choose by means of the code behind. The VB.NET code will work in just the same way as you are familiar with in Windows Forms. There are several differences in the syntax, but the general thrust is the same. So in the VB.NET partial class behind your window you might have something like:

Code Copy

Private Sub lstBox1_SelectionChanged(ByVal sender As Object, ByVal e As System.Windows.Controls.SelectionChangedEventArgs) Handles lstBox1.SelectionChanged

       Console.WriteLine("You selected item # " &   lstBox1.SelectedIndex.ToString)

    End Sub

Or maybe something slightly more realistic, such as displaying the locations of grass pitches so that one can be allocated:-

Code Copy

  Private Sub lstBox1_SelectionChanged(ByVal sender As Object, ByVal e As System.Windows.Controls.SelectionChangedEventArgs) Handles lstBox1.SelectionChanged

  Select Case lstBox1.SelectedIndex
       Case 0
          Dim gpl As New GrassPitchesLayout
          gpl.ShowDialog()
  End Select

  End Sub

One important feature to note here is that in WPF it is possible to identify and isolate exactly which sub-element was selected. So in the XAML example above, the clicking of any part of the ListBoxItem will fire the SelectionChanged event, exactly as you would expect. However, if for some reason you also wanted to know if the user had clicked on the tent image within that ListBoxItem (i.e not on the text or any of the white space areas), then this information is very easily obtainable, so long as you assign a Name to the Image element.

In the following example, the Image in the first ListBoxItem is assigned the Name "Tent" :-

Code Copy

<ListBox Name="lstBox1" Margin="12"
   HorizontalContentAlignment="Center"  > 
<ListBoxItem> 
<StackPanel >
  <Image Source="Images/Tent4A.jpg" Margin="2" Name="Tent"/>
  <TextBlock >Tent - Grassed areas onlyTextBlock>
StackPanel>
ListBoxItem>

ListBox>

That Image is now accessible in the code behind by its name. The following code snippet uses the MouseDown event of the Image to display some information:

Code Copy

Private Sub Tent_MouseDown(ByVal sender As Object, ByVal e As System.Windows.Input.MouseButtonEventArgs) Handles Tent.MouseDown

    Console.WriteLine("You clicked on the tent image")

End Sub

At this point you might be wondering if the Image MouseDown event somehow cancels out the ListBox SelectionChanged event. The answer is that it doesn't. Both events fire; my experiments show that the Image MouseDown fires first.

If you're really inquisitive, you might also wonder what happens if the user traverses the ListBox using the keyboard and not the mouse. Somewhat confusingly (to me anyway), the MouseDown event of the Image fires whenever that first item is selected via the keyboard arrow keys.

Anyway, this ability to access elements with the mouse is something that you may be glad you knew about at some point in your future coding.

Other Layout Combinations

It is probably more traditional in cases where you have an image and some text to see the image at the left and the text placed to the right. So let's fix that now:

Code Copy

<ListBox Name="lstBox1" Margin="12"
   HorizontalContentAlignment="Left"  > 
<ListBoxItem> 
<StackPanel Orientation="Horizontal"> 
<Image Source="Images/Tent4A.jpg" Margin="2" /> 
<TextBlock >Tent - Grassed areas onlyTextBlock>
StackPanel>
ListBoxItem>

ListBox>

You will see from the code above that I changed the Orientation of the StackPanels to Horizontal. The default previously was Vertical.

If you're particularly eagle-eyed you may have noticed that I also changed the HorizontalContentAlignment of the ListBox itself from Center to Left. This forces the three items to be neatly lined up at the left side of the ListBox.

The result of the above code is:

But, you know, we can do much better than that. What's the point of having this sophisticated layout tool if we don't use it to move from the bog standard plain text to something a little better?

Or:-

OK, so they won't win any Designer of the Year prizes, but I think you can see that there is huge potential for creating individual user interfaces - and much more easily than you could hope to do with standard Windows Forms.

The XAML code for the above ListBox is:-

Code Copy

<ListBox Name="lstBox1" Margin="12"
   HorizontalContentAlignment="Left"
   FontFamily="Verdana" > 
<ListBoxItem Margin="0,3,0,3">
<Border BorderBrush="DeepSkyBlue" BorderThickness="2" CornerRadius="2" Width="258"> 
<StackPanel Orientation="Horizontal" Margin="3">
<Image Source="Images/Tent4A.jpg" Margin="2" /> 
<StackPanel> 
<TextBlock Margin="5" Padding="2" FontSize="13" 
FontWeight="Bold" Foreground="Navy"> Tent
TextBlock>
<TextBlock Margin="8" Padding="8,2,2,2" FontSize="11" 
FontWeight="Normal" Foreground="Green">Grassed areas only
TextBlock>
StackPanel>
StackPanel>
Border>
ListBoxItem>
ListBox>

If you want to see the ListBox pushed to the limits, then check out a couple of demos from Josh Smith and Bea Costa which go way beyond the standard image+text layout that I have covered so far.

First there is Josh's Sliding ListBox:

More details on the code here.

And taking the ListBox to extremes (literally) is Bea Costa's Planet ListBox:

Yep - that really is a ListBox and clicking on a planet makes that planet the selected item! More details can be found here.

I plan to write a future blog item that takes the caravan example a step further and uses data binding to automatically populate the listbox items. In the meantime I hope you've found this description of the basics to be useful.

Windows Forms - Aligning Two Forms

VB & .NET Blogs @ vbCity.com — 2007-08-05T00:00:00

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.

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

VB & .NET Blogs @ vbCity.com — 2007-07-18T00:00:00

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

VB & .NET Blogs @ vbCity.com — 2007-06-29T00:00:00

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

VB & .NET Blogs @ vbCity.com — 2007-06-25T00:00:00

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.

How To Print A Form To Printer in VB 2005

VB & .NET Blogs @ vbCity.com — 2007-06-19T00:00:00

a.k.a. The Power of the PrintForm Power Pack!

Introduction
Let's face it, ease of printing in VB.NET has never been its main selling point. In fact, because you literally have to draw most of what you want transferred to paper (or save some kind of screen capture to an image file and then print that), it really can be a bit of a pain.

I knew that the Microsoft VB Team had created an additional Power Pack which prints Windows Forms directly to the printed page but hadn't got round to trying it until today. I have to say that I'm impressed with its ease of use, the comprehensive help that comes with it and, in fact, the range of options available.

Downloading and Installing
The Pack is available as a free download from here. Once you download, run and install the pack you are then able to add the PrintForm component to your ToolBox. I used the VB 2005 Express Edition to trial this, as the Pro and higher editions come with Crystal Reports bundled. That said, this component is so easy to use that you may well prefer it over CR for anything but the most complex displays.

If all goes well, you will automatically be presented with a comprehensive HTML based help page. If you don't see it, or you want to refer to it again later, it is saved by default to C:\Program Files\Microsoft Visual Basic 2005 Power Packs\Printing\PrintForm Component 1.0\Documentation\PrintFormHelp.htm
There is also a demo solution included in that PrintForm Component 1.0 folder.

Adding the Component to the Toolbox
Once installed on your system, adding the item to your Toolbox follows standard procedure.

   Right Click your mouse in the Toolbox.
   Select "Choose Items" from the context menu that appears.
   In the Choose Toolbox Items dialog box, navigate to the .NET Framework Components list.
   Select the PrintForm item from this list and check its checkbox.
   Click OK to add it to the Toolbox.

Trying It Out
Before I spotted that demo solution, I'd given it a run out myself to see if it worked as advertised. The form I created had some standard controls - PictureBox, RichTextBox, Label, TextBox and Button.
I also used GDI+ to draw some circles on the form using the OnPaint event. I thought it might be useful to see how the component would handle those :

As you can see, the RichTextBox content contains coloured text as well as a block of text that is highlighted.

I wanted the form to be printed WYSIWYG - well, almost. I decided that it would be better if the button wasn't printed to paper.

So that was my requirement: print everything on the form except the button.
How easy was it? Simple!
How successful was it? Totally!

Step By Step
Obviously, the first thing to do is to drag an instance of the PrintForm component on to your form. (Although I say "obviously", in reality you don't need to do so; you can always programmatically create an instance in your code if you wish). Anyhow, assuming you've gone the Toolbox instance route you will see that a PrintForm component named PrintForm1 now sits in the component tray at the base of your Design Window. You can now code against this component using the various methods and properties available.

First though, here's the code I used to populate the RichTextBox:

Code Copy

   Private Sub Form1_Load(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Load
        RichTextBox1.LoadFile("C:\readme.rtf", RichTextBoxStreamType.RichText)
    End Sub

And the following code in the OnPaint event draws those two circles round the PictureBox:

Code Copy

Protected Overrides Sub OnPaint(ByVal e As System.Windows.Forms.PaintEventArgs)
        MyBase.OnPaint(e)
        Dim p As Pen = New Pen(Color.Coral, 3)
        e.Graphics.DrawEllipse(p, New Rectangle(70, 35, 140, 140))
        p = New Pen(Color.Aquamarine, 3)
        e.Graphics.DrawEllipse(p, New Rectangle(65, 30, 150, 150))
    End Sub

And so to the code that will do the hard work for us and print the form to a printer:

Code Copy

  Private Sub PrintButton_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btnPrint.Click
        ' Hide the button
        btnPrint.Visible = False
        '  Assign this form as the form to be printed
        PrintForm1.Form = Me

        '  Optional - Remove highlight from textbox
        '  (Otherwise it will be printed)
        TextBox1.SelectionStart = 0
        TextBox1.SelectionLength = 0

        '  Do the printing
        PrintForm1.Print()
        '  Redisplay Button
        btnPrint.Visible = True

    End Sub

I think you'll agree that it is very simple and the commenting in the code needs no further explanation.

Other Options
Although I have seen several good examples where a screenshot has been used to save a displayed form to file and the file is then printed, these all seem to suffer from the same problem - if the form is larger than the screen, only the visible area will be saved.
The PrintForm component handles this problem very effectively with the Scrollable PrintOption.

It is simple to use and if you want to print everything on the form - even if it is off the screen then this code syntax will do the job:

Code Copy

PrintForm1.Print(Me, PowerPacks.Printing.PrintForm.PrintOption.Scrollable)

It really is as simple as that. The PrintOptions also include choices as to whether you print out the Title Bar or just the client area.

Altogether, this is a very useful package - well done the team who put this together to resolve a long running criticism of this particular VB.NET feature.

VB 2005: The "Missing" Sub Main Problem

VB & .NET Blogs @ vbCity.com — 2007-06-19T00:00:00

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!

How to Create Microsoft Access DataSource for Win Forms App Visual Basic 2005

VB & .NET Blogs @ vbCity.com — 2007-05-26T00:00:00

Source Code: How to Create Microsoft Access DataSource for Win Forms App Visual Basic 2005

How to Create Microsoft Access DataSource for Win Forms App Visual Basic 2005

Visual Studio 2005 provides a feature, the 'Data Source Configuration Wizard', for creating a DataSource for a Windows Forms 2.0 application. This article provides step-by-step instructions and a sample Visual Basic 2005 application you can use to learn how make a Microsoft Access database the data source for a Visual Basic Windows Forms application.

The 'Data Source Configuration Wizard' creates a DataSource component that can be used to bind controls on a Windows form to database objects such as tables, stored procedures, and views.

This article will serve as 'step one' for future articles that will explain how to use a DataSource in a Windows Forms application. It is a generic introduction for creating a Windows Forms DataSource using options and practices that are known to work in the majority of development scenarios. Once you understand the basics you should explore the different options you can take during some of the steps, to understand when and why you may want to deviate from the steps presented below.

Data Source Configuration Wizard

Step-By-Step Instructions for Creating a DataSource

1. Create a Visual Basic 2005 Windows Forms application solution.

2. Add a Microsoft Access database file (.mdb), for example the Microsoft Northwind.mdb file, to the solution's 'Bin' folder.

3. From the Visual Studio menu select: Data -> Add New Data Source...

4. The 'Data Source Configuration Wizard' will open. Select 'Database' and then click the 'Next>' button.

5. The 'Choose Your Data Source' step of the wizard will open. Click the 'New Connection..' button.

6. The 'Add Connection' dialog will open.

Make sure the data source box reads: 'Microsoft Access Database File (OLE DB)'. If it does not, use the 'Change...' button to change the data source.

Next, click the 'Browse..'. button. Use the 'Add Connection' dialog that opens to navigate to, and select, the Microsoft Access database you placed in your application's 'Bin' folder.

7. The path to your database should now be shown in the database file name box. Click the 'Test Connection' button to make sure the connection works and then click the 'OK' button.

8. You will be returned to the 'Choose Your Data Source' step of the wizard. Click the 'Next>' button.

9. The 'Microsoft Visual Studio' dialog will open. This dialog asks if you would like to copy the file (database file) to your project. Click the 'Yes' button.

10. The 'Save the Connection String the Application Configuration File' step of the wizard opens. Change the name of the connection string if desired. Click the 'Next>' button.

11. The 'Choose Your Database Objects' step of the wizard will open. Navigate the objects in your database using the tree view. Click checkbox(es) to select the database objects you desire to use in your Windows Forms application. After you have selected all the objects you desire to bind, click the 'Finish' button.

12. The rest of the steps in these instructions are not part of the wizard.

In this step you will set a property to control how Visual Studio uses the Microsoft Access database file each time you build your project.

View the 'Solution Explorer' panel in your solution. Right-click the Microsoft Access database you added to the project and select: Properties

The example below shows how to select the database properties for a database named 'Northwind'.

13. The 'Properties' panel will open. In it set the 'Copy to Output Directory' property to: Copy if newer.

Closures in VB Part 3: Scope

jaredpars WebLog — 2007-05-25T00:00:00

For previous articles in this series please see

Thus far in the series we've only lifted variables that are declared in the same block/scope. What happens if we lift variables in different scope? The answer is that one closure class will be created for every unique scope where a lifted variable is declared and all of the variables in that scope that are lifted will be placed in that closure. Once again, examples speak best

    Sub Scope1()
        Dim x = 5
        Dim f1 = Function(ByVal z As Integer) x + z
        Console.WriteLine(f1(5))
        If x > 2 Then
            Dim y = 6
            Dim g = 7
            Dim f2 = Function(ByVal z As Integer) z + y + g
            Console.WriteLine(f2(4))
        End If
    End Sub

The code will end up looking like so ...

    Class Closure1
        Public x As Integer

        Function Lambda_f1(ByVal z As Integer)
            Return x + z
        End Function

    End Class

    Class Closure2
        Public y As Integer
        Public g As Integer

        Function Lambda_f2(ByVal z As Integer)
            Return y + z + g
        End Function
    End Class

    Sub Scope1()
        Dim c1 As New Closure1()
        c1.x = 5
        Console.WriteLine(c1.Lambda_f1(5))
        If c1.x > 2 Then
            Dim c2 As New Closure2()
            c2.y = 6
            c2.g = 7
            Console.WriteLine(c2.Lambda_f2(4))
        End If
    End Sub

There are a couple of items to take away from this example.

Only two closure classes were created even though three variables were lifted. The number of closures only depends on the number of scopes of all of the lifted declared variables.
The closures are created at the begining of the scope they are associated and not at the begining of the method. This will be more important in the next part of the series.
Each lambda instance is attached to the closure associated with the scope the lambda is declared in.

The next twist is what were to happen if the lambda "f2" were to also use the variable "x". As it's currently written there is no association between Closure1 and Closure2 therefore there is no way for it to access the lifted variable. The answer is two fold. Firstly to reduce clutter I pasted the closure classes as if they were separate entries. In fact Closure2 would appear as a nested class of Closure1 in the real generated code.

Secondly if x were used inside of "f2", the real use would be "c1.x". That's (almost) no different than "someOtherVar.x". Therefore the instance of c1 will be lifted into Closure2.

Dim f2 = Function(ByVal z As Integer) z + y + g + x

Woud result in the following definition of Closure2 ...

    Class Closure2
        Public y As Integer
        Public g As Integer
        Public c1 As Closure1

        Function Lambda_f2(ByVal z As Integer)
            Return y + z + g + c1.x
        End Function
    End Class

In deeply nested lambdas and scopes this type of lifting will continue recursively.

That's it for this entry, the next article will talk about looping structures and possibly variable lifetime.