The simplest place to start is to build the new Conversation form, which needs three TextBox controls (textUsername, textMessages, and textMessage) and a Button control (buttonSend), as shown in Figure 34-6.

Figure 34.6. Figure 34-6

This class requires a number of fields and an enumeration. It needs fields to hold the username of the user (which you will default to Evjen), the underlying TcpClient, and the NetworkStream returned by that client. The enumeration indicates the direction of the connection (which will help you when debugging):

Imports System.Net
Imports System.Net.Sockets
Imports System.Text
Imports System.Threading
Imports System.Runtime.Serialization.Formatters.Binary

Public Class Conversation

   Private _username As String = "Evjen"
   Private _client As TcpClient
   Private _stream As NetworkStream

Private _direction As ConversationDirection

   Public Enum ConversationDirection As Integer
      Inbound = 0
      Outbound = 1
   End Enum

At this point, we won't look into the issues surrounding establishing a thread for exchanging messages, but we will look at implementing the ConfigureClient method. This method eventually does more work than this, but for now it sets a couple of fields and calls UpdateCaption:

Public Sub ConfigureClient(ByVal client As TcpClient, _
              ByVal direction As ConversationDirection)
   ' Set it up...
   _client = client
   _direction = direction

   ' Update the window...
   UpdateCaption()
End Sub

Protected Sub UpdateCaption()

   ' Set the text.
   Dim builder As New StringBuilder(_username)
   builder.Append(" - ")
   builder.Append(_direction.ToString())
   builder.Append(" - ")
   builder.Append(Thread.CurrentThread.GetHashCode())
   builder.Append(" - ")

   If Not _client Is Nothing Then
      builder.Append("Connected")
   Else
      builder.Append("Not connected")
   End If

   Text = builder.ToString()
End Sub

Note a debugging issue to deal with: if you are connecting to a conversation on the same machine, then you need a way to change the name of the user sending each message; otherwise, things get confusing. That is what the topmost TextBox control is for. In the constructor, set the text for the textUsername.Text property:

Public Sub New()

   ' This call is required by the Windows Form Designer.
   InitializeComponent()

   ' Add any initialization after the InitializeComponent() call.
   textUsername.Text = _username
End Sub

On the TextChanged event for this control, update the caption and the internal _username field:

Private Sub textUsername_TextChanged(ByVal sender As System.Object, _
                   ByVal e As System.EventArgs) _
                   Handles textUsername.TextChanged

   _username = textUsername.Text
   UpdateCaption()
End Sub

Form1 needs to be able to both initiate connections and receive inbound connections — the application is both a client and a server. You have already created some of the server portion by creating Listener; now you will look at the client side.

The general rule when working with sockets is that any time you send anything over the wire, you must perform the actual communication in a separate thread. Virtually all calls to send and receive do so in a blocking manner; that is, they block until data is received, block until all data is sent, and so on.

If threads are used well, then the UI will keep running as normal, irrespective of the problems that may occur during transmitting and receiving. This is why in the InitiateConnection method on Form1, you defer processing to another method called InitiateConnectionThreadEntryPoint, which is called from a new thread:

Public Sub InitiateConnection()
   InitiateConnection(textConnectTo.Text)
End Sub

Public Sub InitiateConnection(ByVal hostName As String)

   ' Give it to the threadpool to do...
   ThreadPool.QueueUserWorkItem(AddressOf _
   Me.InitiateConnectionThreadEntryPoint, hostName)
End Sub

Private Sub buttonConnect_Click(ByVal sender As System.Object, _
                ByVal e As System.EventArgs) _
                Handles buttonConnect.Click

   InitiateConnection()
End Sub

Inside the thread, you try to convert the host name that you are given into an IP address (localhost is used as the host name in the demonstration, but it could be the name of a machine on the local network or a host name on the Internet). This is done through the shared GetHostEntry method on System.Net.Dns, and returns a System.Net.IPHostEntry object. Because a host name can point to multiple IP addresses, you will just use the first one that you are given. You take this address expressed as an IP (for example, 192.168.0.4) and combine it with the port number to get a new System.Net.IPEndPoint. Then, you create a new TcpClient from this IPEndPoint and try to connect.

If at any time an exception is thrown (which can happen because the name could not be resolved or the connection could not be established), you pass the exception to HandleInitiateConnectionException. If it succeeds, then you pass it to ProcessOutboundConnection. Both of these methods will be implemented shortly:

Private Sub InitiateConnectionThreadEntryPoint(ByVal state As Object)

   Try
      ' Get the host name...
      Dim hostName As String = CStr(state)

      ' Resolve...
      Dim hostEntry As IPHostEntry = Dns.GetHostEntry(hostName)
      If Not hostEntry Is Nothing Then

         ' Create an end point for the first address.
         Dim endPoint As New IPEndPoint(hostEntry.AddressList(0), ServicePort)

         ' Create a TCP client...
         Dim client As New TcpClient()
         client.Connect(endPoint)

         ' Create the connection window...
         ProcessOutboundConnection(client)
      Else
         Throw New ApplicationException("Host '" & hostName & _
            "' could not be resolved.")
      End If
   Catch ex As Exception
      HandleInitiateConnectionException(ex)
   End Try
End Sub

When it comes to HandleInitiateConnectionException, you start to see the inter-thread UI problems that were mentioned earlier. When there is a problem with the exception, you need to tell the user, which means you need to move the exception from the thread-pool-managed thread into the main application thread. The principle for this is the same; you need to create a delegate and call that delegate through the form's Invoke method. This method does all the hard work in marshaling the call across to the other thread.

Here is what the delegates look like. They have the same parameters of the calls themselves. As a naming convention, it is a good idea to use the same name as the method and tack the word Delegate on the end:

Public Class Form1

   Private Shared _mainThreadId As Integer
   ' delegates...
   Protected Delegate Sub HandleInitiateConnectionExceptionDelegate( _
                                             ByVal ex As Exception)

In the constructor for Form1, you capture the thread caller's thread ID and store it in _mainThreadId. Here is a method that compares the captured ID with the ID of the current thread:

Public Shared Function IsMainThread() As Boolean
   If Thread.CurrentThread.GetHashCode() = _mainThreadId Then

Return True
   Else
      Return False
   End If
End Function

The first thing you do at the top of HandleInitiateConnectionException is check the thread ID. If it does not match, then you create the delegate and call it. Notice that you set the delegate to call back into the same method because the second time it is called, you would have moved to the main thread; therefore, IsMainThread returns True, and you can process the exception properly:

Protected Sub HandleInitiateConnectionException(ByVal ex As Exception)

   ' main thread?
   If IsMainThread() = False Then

      ' Create and call...
      Dim args(0) As Object
      args(0) = ex
      Invoke(New HandleInitiateConnectionExceptionDelegate(AddressOf _
         HandleInitiateConnectionException), args)

      ' return
      Return
   End If

   ' Show it.
   MessageBox.Show(ex.GetType().ToString() & ":" & ex.Message)
End Sub

The result is that when the call comes in from the thread-pool-managed thread, IsMainThread returns False, and the delegate is created and called. When the method is entered again as a result of the delegate call, IsMainThread returns True, and you see the message box.

When it comes to ProcessOutboundConnection, you have to again jump into the main UI thread. However, the magic behind this method is implemented in a separate method called Process-Connection, which can handle either inbound or outbound connections. Here is the delegate:

Public Class Form1

   Private Shared _mainThreadId As Integer
   Private _listener As Listener

   Protected Delegate Sub ProcessConnectionDelegate(ByVal client As _
      TcpClient, ByVal direction As Conversation.ConversationDirection)
   Protected Delegate Sub HandleInitiateConnectionExceptionDelegate(ByVal _
      ex As Exception)

Here is the method itself, which creates the new Conversation form and calls the ConfigureClient method:

Protected Sub ProcessConnection(ByVal client As TcpClient, _
   ByVal direction As Conversation.ConversationDirection)

' Do you have to move to another thread?
   If IsMainThread() = False Then

      ' Create and call...
      Dim args(1) As Object
      args(0) = client
      args(1) = direction
      Invoke(New ProcessConnectionDelegate(AddressOf ProcessConnection), args)

      Return
   End If


   ' Create the conversation window...
   Dim conversation As New Conversation()
   conversation.Show()
   conversation.ConfigureClient(client, direction)
End Sub

Of course, ProcessOutboundConnection needs to defer to ProcessConnection:

Public Sub ProcessOutboundConnection(ByVal client As TcpClient)
   ProcessConnection(client, Conversation.ConversationDirection.Outbound)
End Sub

Now that you can connect to something on the client side, let's look at how to receive connections (on the server side).

You have already built Listener, but you have not created an instance of it or spun up its thread to wait for incoming connections. To do that, you need a field in Form1 to hold an instance of the object. You also need to tweak the constructor. Here is the field:

Public Class Form1

   Private _mainThreadId As Integer
   Private _listener As Listener

Here is the new code that needs to be added to the constructor:

Public Sub New()

   ' This call is required by the Windows Form Designer.
   InitializeComponent()

   ' Add any initialization after the InitializeComponent() call.
   _mainThreadId = System.Threading.Thread.CurrentThread.GetHashCode()

   Text &= "-" & _mainThreadId.ToString()

   ' listener...
   _listener = New Listener(Me)
   _listener.SpinUp()
End Sub

When inbound connections are received, you get a new TcpClient object. This is passed back to Form1 through the ReceiveInboundConnection method. This method, like ProcessOutboundConnection, defers to ProcessConnection. Because ProcessConnection already handles the issue of moving the call to the main application thread, ReceiveInboundConnection looks like this:

Public Sub ReceiveInboundConnection(ByVal client As TcpClient)
   ProcessConnection(client, Conversation.ConversationDirection.Inbound)
End Sub

If you run the project now, you should be able to click the Connect button and see two windows — Inbound and Outbound (see Figure 34-7).

Figure 34.7. Figure 34-7

If you close all three windows, the application keeps running because you have not written code to close down the listener thread, and having an open thread like this keeps the application open. Select Debug

By clicking the Connect button, you are calling InitiateConnection. This spins up a new thread in the pool that resolves the given host name (localhost) into an IP address. This IP address, in combination with a port number, is then used in the creation of a TcpClient object. If the connection can be made, then ProcessOutboundConnection is called, which results in the first of the conversation windows being created and marked as "outbound."

This example is somewhat artificial, as the two instances of Wrox Messenger should be running on separate computers. On the remote computer (if you are connecting to localhost, this will be the same computer), a connection is received through the AcceptTcpClient method of TcpListener. This results in a call to ReceiveInboundConnection, which in turn results in the creation of the second conversation window, this time marked as "inbound."

The Message class contains two fields, _username and _message, which form the entirety of the data that you want to transmit. The code for this class follows; note how the Serializable attribute is applied to it so that BinaryFormatter can change it into a wire-ready form. You are also providing a new implementation of ToString:

Imports System.Text

<Serializable()> Public Class Message

Private _username As String
   Private _message As String

   Public Sub New(ByVal name As String)
      _username = name
   End Sub

   Public Sub New(ByVal name As String, ByVal message As String)
      _username = name
      _message = message
   End Sub

   Public Overrides Function ToString() As String
      Dim builder As New StringBuilder(_username)
      builder.Append(" says:")
      builder.Append(ControlChars.CrLf)
      builder.Append(_message)
      builder.Append(ControlChars.CrLf)

      Return builder.ToString()
   End Function

End Class

Now all you have to do is spin up two threads, one for transmission and one for reception, updating the display. You need two threads per conversation, so if you have 10 conversations open, you need 20 threads plus the main UI thread, plus the thread running TcpListener.

Receiving messages is easy. When calling Deserialize on BinaryFormatter, you give it the stream returned to you from TcpClient. If there is no data, then this blocks. If there is data, then it is decoded into a Message object that you can display. If you have multiple messages coming down the pipe, then BinaryFormatter keeps processing them until the pipe is empty. Here is the method for this, which should be added to Conversation. Remember that you haven't implemented ShowMessage yet:

Protected Sub ReceiveThreadEntryPoint()

   ' Create a formatter...
   Dim formatter As New BinaryFormatter()

   ' Loop
   Do While True
      ' Receive...
      Dim message As Message = formatter.Deserialize(_stream)

      If message Is Nothing Then
         Exit Do
      End If

      ' Show it...
      ShowMessage(message)
   Loop
End Sub

Transmitting messages is a bit more complex. You want a queue (managed by a System.Collections.Queue) of outgoing messages. Every second, you will examine the state of the queue. If you find any messages, then you use BinaryFormatter to transmit them. Because you will be accessing this queue from multiple threads, you use a System.Threading.ReaderWriterLock to control access. To minimize the amount of time you spend inside locked code, you quickly transfer the contents of the shared queue into a private queue that you can process at your leisure. This enables the client to continue to add messages to the queue through the UI, even though existing messages are being sent by the transmit thread.

First, add the following members to Conversation:

Public Class Conversation

   Private _username As String = "Evjen"
   Private _client As TcpClient
   Private _stream As NetworkStream
   Private _direction As ConversationDirection
   Private _receiveThread As Thread
   Private _transmitThread As Thread
   Private _transmitQueue As New Queue()
   Private _transmitLock As New ReaderWriterLock()

Now, add this method again to Conversation:

Protected Sub TransmitThreadEntryPoint()

   ' Create a formatter...
   Dim formatter As New BinaryFormatter()
   Dim workQueue As New Queue()

   ' Loop
   Do While True

      ' Wait for the signal...
      Thread.Sleep(1000)

      ' Go through the queue...
      _transmitLock.AcquireWriterLock(-1)
      Dim message As Message
      workQueue.Clear()

      For Each message In _transmitQueue
         workQueue.Enqueue(message)
      Next

      _transmitQueue.Clear()
      _transmitLock.ReleaseWriterLock()

      ' Loop the outbound messages...
      For Each message In workQueue

         ' Send it...
         formatter.Serialize(_stream, message)

Next

   Loop

End Sub

When you want to send a message, you call one version of the SendMessage method. Here are all of the implementations, and the Click handler for buttonSend:

Private Sub buttonSend_Click(ByVal sender As System.Object, _
   ByVal e As System.EventArgs) Handles buttonSend.Click

   SendMessage(textMessage.Text)
End Sub

Public Sub SendMessage(ByVal message As String)
   SendMessage(_username, message)
End Sub

Public Sub SendMessage(ByVal username As String, ByVal message As String)
   SendMessage(New Message(username, message))
End Sub

Public Sub SendMessage(ByVal message As Message)
   ' Queue it
   _transmitLock.AcquireWriterLock(-1)
   _transmitQueue.Enqueue(message)
   _transmitLock.ReleaseWriterLock()

   ' Show it...
   ShowMessage(message)
End Sub

ShowMessage is responsible for updating textMessages so that the conversation remains up to date (notice how you add the message both when you send it and when you receive it so that both parties have an up-to-date thread). This is a UI feature, so it is good practice to pass it over to the main application thread for processing. Although the call in response to the button click comes off the main application thread, the one from inside ReceiveThreadEntryPoint does not. Here is what the delegate looks like:

Public Class Conversation

   ' members...
   Private _username As String = "Evjen"
   Private _client As TcpClient
   Private _stream As NetworkStream
   Private _direction As ConversationDirection
   Private _receiveThread As Thread
   Private _transmitThread As Thread
   Private _transmitQueue As New Queue()
   Private _transmitLock As New ReaderWriterLock()

   Public Delegate Sub ShowMessageDelegate(ByVal message As Message)

Here is the method implementation:

Public Sub ShowMessage(ByVal message As Message)
   ' Thread?
   If Form1.IsMainThread() = False Then

      ' Run...
      Dim args(0) As Object
      args(0) = message
      Invoke(New ShowMessageDelegate(AddressOf ShowMessage), args)

      ' Return...
      Return
   End If

   ' Show it...
   textMessages.Text &= message.ToString()
End Sub

All that remains now is to spin up the threads. This should be done from within ConfigureClient. Before the threads are spun up, you need to obtain the stream and store it in the private _stream field. After that, you create new Thread objects as normal:

Public Sub ConfigureClient(ByVal client As TcpClient, _
      ByVal direction As ConversationDirection)

   ' Set it up...
   _client = client
   _direction = direction

   ' Update the window...
   UpdateCaption()
   ' Get the stream...
   _stream = _client.GetStream()

   ' Spin up the threads...
   _transmitThread = New Thread(AddressOf TransmitThreadEntryPoint)
   _transmitThread.Start()
   _receiveThread = New Thread(AddressOf ReceiveThreadEntryPoint)
   _receiveThread.Start()
End Sub

At this point, you should be able to connect and exchange messages, as shown in Figure 34-8.

Note that the screenshots show the username of the inbound connection as Tuija. This was done with the textUsername text box so that you can follow which half of the conversation comes from where.

The first step is to create a new Windows Forms application called MiniBrowser. On the default form, place a single TextBox control and the WebBrowser control, as shown in Figure 34-10.

Figure 34.10. Figure 34-10

The idea is that when the end user presses the Enter key (Return key), the URL entered in the text box will be the HTML page that is retrieved and displayed in the WebBrowser control. To accomplish this task, use the following code for your form:

Public Class Form1

    Private Sub TextBox1_KeyPress(ByVal sender As Object, _
       ByVal e As System.Windows.Forms.KeyPressEventArgs) Handles TextBox1.KeyPress

        If e.KeyChar = Chr(13) Then
            WebBrowser1.Navigate(TextBox1.Text)
        End If

    End Sub

End Class

For this simple example, you check the key presses that are made in the TextBox1 control, and if the key press is a specific one — the Enter key — then you use the WebBrowser control's Navigate method to navigate to the requested page. The Navigate method can take a single String value, which represents the location of the Web page to retrieve. The example shown in Figure 34-11 shows the Wrox website.

Sometimes, the goal is not to host a browser inside the application but instead to allow the user to find the website in a typical Web browser. For an example of this task, create a Windows Form that has a LinkLabel control on it. For instance, you can have a form that has a LinkLabel control on it that simply states "Visit your company website!"

Figure 34.11. Figure 34-11

Once this control is in place, use the following code to launch the company's website in an independent browser, as opposed to directly in the form of your application:

Public Class Form1

    Private Sub LinkLabel1_LinkClicked(ByVal sender As System.Object, _
       ByVal e As System.Windows.Forms.LinkLabelLinkClickedEventArgs) Handles _
       LinkLabel1.LinkClicked

        Dim wb As New WebBrowser
        wb.Navigate("http://www.wrox.com", True)

    End Sub

End Class

In this example, when the LinkLabel control is clicked by the user, a new instance of the WebBrowser class is created. Then, using the WebBrowser's Navigate method, the code specifies the location of the Web page as well as a Boolean value that specifies whether this endpoint should be opened within the Windows Form application (a False value) or from within an independent browser (a True value). By default, this is set to False. With the preceding construct, when the end user clicks the link found in the Windows application, a browser instance is instantiated and the Wrox website is immediately launched.

Note that when working with the MiniBrowser example in which the WebBrowser control is directly in the form, when you click the links, the text in the TextBox1 control is not updated. You can fix this by listening for events coming off the WebBrowser control and adding handlers to the control.

It is easy to update the form's title with the HTML page's title. Create a DocumentTitleChanged event and update the form's Text property:

Private Sub WebBrowser1_DocumentTitleChanged(ByVal sender As Object, _
   ByVal e As System.EventArgs) Handles WebBrowser1.DocumentTitleChanged

    Me.Text = WebBrowser1.DocumentTitle.ToString()

End Sub

In this case, when the WebBrowser control notices that the page title has changed (due to changing the page viewed), the DocumentTitleChanged event will fire. In this case, you change the form's Text property (its title) to the title of the page being viewed using the DocumentTitle property of the WebBrowser control.

Next, update the text string that appears in the form's text box, based on the complete URL of the page being viewed. To do this, you can use the WebBrowser control's Navigated event:

Private Sub WebBrowser1_Navigated(ByVal sender As Object, _
   ByVal e As System.Windows.Forms.WebBrowserNavigatedEventArgs) Handles _
   WebBrowser1.Navigated

    TextBox1.Text = WebBrowser1.Url.ToString()

End Sub

In this case, when the requested page is finished being downloaded in the WebBrowser control, the Navigated event is fired. You simply update the Text value of the TextBox1 control to be the URL of the page. This means that once a page is loaded in the WebBrowser control's HTML container, if the URL changes in this process, then the new URL will be shown in the text box. For example, if you employ these steps and navigate to the Wrox website (www.wrox.com), the page's URL will immediately change to http://www.wrox.com/WileyCDA/. This process also means that if the end user clicks one of the links contained within the HTML view, then the URL of the newly requested page will also be shown in the text box.

Now if you run the application with the preceding changes put into place, the form's title and address bar will work as they do in Microsoft's Internet Explorer, as demonstrated in Figure 34-12.

For this exercise, you will add to the top of the control a simple toolbar that gives you the usual features you would expect from a Web browser — that is, Back, Forward, Stop, Refresh, and Home.

Rather than use the ToolBar control, you will add a set of button controls at the top of the control where you currently have the address bar. Add five buttons to the top of the control, as illustrated in Figure 34-13.

I have changed the text on the buttons to indicate their function. Of course, you can use a screen capture utility to "borrow" button images from IE and use those. The buttons should be named buttonBack, buttonForward, buttonStop, buttonRefresh, and buttonHome. To get the resizing to work properly, make sure that you set the Anchor property of the three buttons on the right to Top, Right.

Figure 34.12. Figure 34-12

Figure 34.13. Figure 34-13

On startup, buttonBack, buttonForward, and buttonStop should be disabled because there is no point to the buttons if there is no initial page loaded. You will later tell the WebBrowser control when to enable and disable the Back and Forward buttons, depending on where the user is in the page stack. In addition, when a page is being loaded, you need to enable the Stop button, but you also need to disable the Stop button once the page has finished being loaded.

First, though, you will add the functionality behind the buttons. The WebBrowser class itself has all the methods you need, so this is all very straightforward:

Public Class Form1
    Private Sub Form1_Load(ByVal sender As System.Object, _
     ByVal e As System.EventArgs) Handles MyBase.Load
        buttonBack.Enabled = False
        buttonForward.Enabled = False

buttonStop.Enabled = False
    End Sub

    Private Sub buttonBack_Click(ByVal sender As System.Object, _
     ByVal e As System.EventArgs) Handles buttonBack.Click
        WebBrowser1.GoBack()
        TextBox1.Text = WebBrowser1.Url.ToString()
    End Sub

    Private Sub buttonForward_Click(ByVal sender As System.Object, _
     ByVal e As System.EventArgs) Handles buttonForward.Click
        WebBrowser1.GoForward()
        TextBox1.Text = WebBrowser1.Url.ToString()
    End Sub

    Private Sub buttonStop_Click(ByVal sender As System.Object, _
     ByVal e As System.EventArgs) Handles buttonStop.Click
        WebBrowser1.Stop()
    End Sub

    Private Sub buttonRefresh_Click(ByVal sender As System.Object, _
     ByVal e As System.EventArgs) Handles buttonRefresh.Click
        WebBrowser1.Refresh()
    End Sub

    Private Sub buttonHome_Click(ByVal sender As System.Object, _
     ByVal e As System.EventArgs) Handles buttonHome.Click
        WebBrowser1.GoHome()
        TextBox1.Text = WebBrowser1.Url.ToString()
    End Sub

    Private Sub buttonSubmit_Click(ByVal sender As System.Object, _
     ByVal e As System.EventArgs) Handles buttonSubmit.Click
        WebBrowser1.Navigate(TextBox1.Text)
    End Sub

    Private Sub WebBrowser1_CanGoBackChanged(ByVal sender As Object, _
     ByVal e As System.EventArgs) Handles WebBrowser1.CanGoBackChanged
        If WebBrowser1.CanGoBack = True Then
            buttonBack.Enabled = True
        Else
            buttonBack.Enabled = False
        End If
    End Sub

    Private Sub WebBrowser1_CanGoForwardChanged(ByVal sender As Object, _
     ByVal e As System.EventArgs) Handles WebBrowser1.CanGoForwardChanged
        If WebBrowser1.CanGoForward = True Then
            buttonForward.Enabled = True
        Else
            buttonForward.Enabled = False
        End If
    End Sub

Private Sub WebBrowser1_Navigated(ByVal sender As Object, _
     ByVal e As System.Windows.Forms.WebBrowserNavigatedEventArgs) Handles _
     WebBrowser1.Navigated
        TextBox1.Text = WebBrowser1.Url.ToString()
        Me.Text = WebBrowser1.DocumentTitle.ToString()
    End Sub

    Private Sub WebBrowser1_Navigating(ByVal sender As Object, _
     ByVal e As System.Windows.Forms.WebBrowserNavigatingEventArgs) Handles _
     WebBrowser1.Navigating
        buttonStop.Enabled = True
    End Sub

    Private Sub WebBrowser1_DocumentCompleted(ByVal sender As Object, _
     ByVal e As System.Windows.Forms.WebBrowserDocumentCompletedEventArgs) _
     Handles WebBrowser1.DocumentCompleted
        buttonStop.Enabled = False
    End Sub

End Class

Several different activities are occurring in this example, as there are many options for the end user when using this MiniBrowser application. First, for each of the button Click events, there is a specific WebBrowser class method assigned as the action to initiate. For instance, for the Back button on the form, you simply use the Web Browser control's GoBack method. The same is true for the other buttons — for the Forward button you have the GoForward method, and for the other buttons you have methods such as Stop, Refresh, and GoHome. This makes it simple and straightforward to create a toolbar that provides actions similar to those of Microsoft's Internet Explorer.

When the form is first loaded, the Form1_Load event disables the appropriate buttons. From there, users can enter a URL in the text box and click the Submit button to have the application retrieve the desired page.

To manage the enabling and disabling of the buttons, you have to key in a couple of events. As mentioned before, whenever downloading begins you need to enable Stop. For this, you simply add an event handler for the Navigating event to enable the Stop button:

Private Sub WebBrowser1_Navigating(ByVal sender As Object, _
 ByVal e As System.Windows.Forms.WebBrowserNavigatingEventArgs) Handles _
 WebBrowser1.Navigating
    buttonStop.Enabled = True
End Sub

Next, the Stop button is again disabled when the document has finished loading:

Private Sub WebBrowser1_DocumentCompleted(ByVal sender As Object, _
 ByVal e As System.Windows.Forms.WebBrowserDocumentCompletedEventArgs) _
 Handles WebBrowser1.DocumentCompleted
    buttonStop.Enabled = False
End Sub

Enabling and disabling the appropriate Back and Forward buttons depends on the ability to go backward or forward in the page stack. This is achieved by using both the CanGoForwardChanged and the CanGoBackChanged events:

Private Sub WebBrowser1_CanGoBackChanged(ByVal sender As Object, _
     ByVal e As System.EventArgs) Handles WebBrowser1.CanGoBackChanged
        If WebBrowser1.CanGoBack = True Then
            buttonBack.Enabled = True
        Else
            buttonBack.Enabled = False
        End If
    End Sub

    Private Sub WebBrowser1_CanGoForwardChanged(ByVal sender As Object, _
     ByVal e As System.EventArgs) Handles WebBrowser1.CanGoForwardChanged
        If WebBrowser1.CanGoForward = True Then
            buttonForward.Enabled = True
        Else
            buttonForward.Enabled = False
        End If
    End Sub

Run the project now, visit a Web page, and click through a few links. You should also be able to use the toolbar to enhance your browsing experience. The end product is shown in Figure 34-14.

Figure 34.14. Figure 34-14

You are not limited to using just Web pages within the WebBrowser control. In fact, you can enable end users to view many different types of documents. So far, you have seen how to use the WebBrowser control to access documents that have been purely accessible by defining a URL, but the WebBrowser control also enables you to use an absolute path and define endpoints to files such as Word documents, Excel documents, PDFs, and more.

For instance, suppose you are using the following code snippet:

WebBrowser1.Navigate("C:Financial Report.doc")

This would open the Word document in your application. Not only would the document appear in the WebBrowser control, but the Word toolbar would also be present, as shown in Figure 34-15.

In Figure 34-16, the WebBrowser control shows an Adobe PDF file.

Figure 34.15. Figure 34-15

Figure 34.16. Figure 34-16

In addition to simply opening specific documents in the control, users can also drag and drop documents onto the WebBrowser control's surface, and the document dropped will automatically be opened within the control. To turn off this capability (which is enabled by default), set the WebBrowser control's AllowWebBrowserDrop property to False.

Not only can users use the WebBrowser control to view pages and documents, they can also use the control to send these pages and documents to the printer for printing. To print the page or document being viewed in the control, simply use the following construct:

WebBrowser1.Print()

As before, it is possible to print the page or document without viewing it by using the WebBrowser class to load an HTML document and print it without even displaying the loaded document, as shown here:

Dim wb As new WebBrowser
wb.Navigate("http://www.wrox.com")
wb.Print()