VB Feeds

Linking Zune media items with LinQ, Part 1 (Matt Gertz)

The Visual Basic Team - VBTeam — Fri, 06 Nov 2009 22:17:00 PST

Channel: The Visual Basic Team

Way back in October 2007, I wrote up a few posts (here and here) on my experiments with the Windows Media Player object model. The problem I was trying to solve was that, when I had a playlist set to “shuffle,” WMP would break up songs that should always play together (for example, Jackson Browne’s “The Load-Out” and “Stay”, or Pink Floyd’s “Brain Damage” and “Total Eclipse”). In those posts, I worked around this by building my own shuffler which would emit a new randomized playlist which preserved those links, and then playing that playlist. A few months later, after I bought my Zune 80, I updated the program to copy the playlist to a ZPL format, since the format was essentially identical to WPL.

Although this was a good investigation into the WMP object model, I’ve never been happy with the program. First of all, for the program to work, I had to add metadata to the actual music tracks, and anything could come along and blow that metadata away. Second, the tracks had to already be adjacent in the parent playlist for it to work at all. Third, I had to bring up the WMP just to shuffle a playlist, which is pretty heavyweight. Finally, since I mostly care about Zune playlists these days and not WMP at all, it seemed the height of hackery to bring up the WMP to generate something for Zune (since the Zune object model is not public).

So, last week, after seeing my metadata blown away again when I carelessly updated my tracks after upgrading to Windows 7, I decided to work on a more permanent solution. Why bring up the WMP at all (or Zune, for that matter), when the playlists themselves are just XML, and the track just entries into those?

After some experiments with parsing the XML by following the parent/child chain, which seemed kludge to me, I came across a post by Avner in which he discusses porting iTunes playlists to Zune, leveraging LinQ to help with the data parsing. I realized right away that I could do something very similar in this case, and came up with what I think is a pretty elegant solution.

So here’s the plan: the application will:

(1) Load in a playlist that the user chooses

(2) Allow the user to rearrange the playlist

(3) Allow the user to link certain tracks together (and unlink them)

(4) Shuffle the playlist on command, preserving the linkages

(5) Allow the user to change the title of the playlist

(6) Allow the user to cave the playlist (or a copy of it)

(7) And, most important, persist the linkage data between sessions in such a way that the information won’t get blown away.

Let’s get started!

The form

Create a Windows Form Application (about 430 x 300) containing the following:

(1) A ListBox, about 290 x 180 and positioned on the left side, with the SelectionMode property set to “MultiExtended” and the DrawMode set to “OwnerDrawFixed.”

(2) Above that, a Label and EditBox, with the Label text set to “&Title”.

(3) To the right of those, five Buttons going down the right side, labeled “Link”, “Unlink”, “Move Up”, “Move Down”, and “Shuffle”.

(4) A MenuStrip. Select it, and on the right side of the strip, click the tiny right-pointing triangle icon and choose “Insert Standard Items” from the resulting popup. Now, go back and remove all of the items except File (Open, Close, Save, Save As, Exit) and Help (About). The Edit and Tools menu can be completely removed; we won’t be using those.

(5) An OpenFileDialog and a SaveFileDialog. The Filter property of both should be set to “Zune playlists|*.zpl” (without the quotes).

In my example, I also disabled the Maximize box in the form, added an icon and title to the form and application, etc., but those aren’t strictly necessary for the exercise.

The Zune playlist

The format of a Zune playlist (version 2.0) looks like this (memorize this, it will be useful later):

<smil>

<head>

<title> (some title) </title>

</head>

<body>

<seq>

<media … /> (etc… one for each track)

</seq>

</body>

</smil>

Code for the controls

The rest of this post will be organized based on the controls, starting from the top.

The Form

The only code associated with the form itself is the event handler for Load, a few member variables, and a helper class. Let’s take those in reverse order:

The helper class, xmlMediaEntry

We’ll be reading the Zune playlist using the XDocument class, and then we’ll be using LinQ to retrieve individual <media>…</media> tag pairs representing each track. These will be handed to us as XElements, and as we will want to add each of the tracks to the listbox, we’ll want to wrap these in an object that will expose the proper information to the ListBox – namely, a human-readable string. We will also want to have a way to link a track to another track, and we’ll be using a doubly-linked list to do this. So:

Class xmlMediaEntry

Public xmlElem As XElement

Public PrevLinkedElement As xmlMediaEntry = Nothing

Public NextLinkedElement As xmlMediaEntry = Nothing

That code allows us to cache the XElement and also point to other elements of this class backwards and forward. The header node for a chain of linked songs will have PrevLinkedElement remaining as Nothing; the tail node will have NextLinkedElement remain as Nothing; songs in the middle of the chain will have both of those set to some other node.

The following constructor allows us to initialize the object with the XElement to be cached.

Sub New(ByVal xelem As XElement)

xmlElem = xelem

End Sub

This code, exposed publically as a shared method, allows us to create a canonical (and readable) way to refer to a track in an XElement. To use one of my previous examples, the resulting value might be “The Load-Out (Jackson Browne)”:

Public Shared Function CreateMediaString(ByVal elem As XElement) As String

Return elem.Attribute("trackTitle").Value & _

" (" & elem.Attribute("trackArtist").Value & ")"

End Function

I can then leverage that function to override the ToString for the xmlMediaEntry:

Public Overrides Function ToString() As String

Return CreateMediaString(xmlElem)

End Function

End Class

And that’s all I need in that class. Once I add an instance of it to the ListBox, it will show up with nice readable text, and I’ll be able to navigate between it and any other linked songs (if any).

Member Variables

I’ll need a few variables to keep track of the state of the file, and these should all be self-explanatory:

Private FileLoaded As Boolean = False ' Do we have a file loaded into the listbox?

Private FileChanged As Boolean = False ' Has the playlist changed since it was last loaded/saved?

Private FilePath As String ' Where was the file last loaded from/saved to?

Private FileDirectory As String ' What directory was the file last loaded from/saved to?

We’ll also need to keep track of some of the playlist’s metadata. Each playlist has a GUID associated with it (if you don’t know what a GUID is, don’t worry about it – think of it as a unique identifier); if we do a “Save As” to a different file, we’ll want a different GUID. The user might also change the title of the playlist, and we should cache our creatorId format since it might be unique to the user’s situation:

Private playlistGuid As String ' What is the GUID of this playlist?

Private playlistTitle As String ' What is the title of this playlist?

Imports System.Data

Imports System.Linq

Imports System.Reflection

Public Class LinqUtilities

    Friend Shared Function LINQToDataTable(Of T)(ByVal iEnumerableList As IEnumerable(Of T)) As DataTable

        Dim newDataTable As New DataTable()

        Dim thePropertyInfo As PropertyInfo() = Nothing

        If iEnumerableList Is Nothing Then

            Return newDataTable

        End If

        For Each item As T In iEnumerableList

            If thePropertyInfo Is Nothing Then

                thePropertyInfo = (DirectCast(item.[GetType](), Type)).GetProperties()

                For Each propInfo As PropertyInfo In thePropertyInfo

                    Dim columnDataType As Type = propInfo.PropertyType

                    If (columnDataType.IsGenericType) AndAlso (columnDataType.GetGenericTypeDefinition() Is GetType(Nullable(Of ))) Then

                        columnDataType = columnDataType.GetGenericArguments()(0)

                    End If

                    newDataTable.Columns.Add(New DataColumn(propInfo.Name, columnDataType))

                Next

            End If

            Dim dr As DataRow = newDataTable.NewRow()

            For Each pi As PropertyInfo In thePropertyInfo

                dr(pi.Name) = If(pi.GetValue(item, Nothing) Is Nothing, DBNull.Value, pi.GetValue(item, Nothing))

            Next

            newDataTable.Rows.Add(dr)

        Next

        Return newDataTable

    End Function

End Class

Below is example code that uses Linq to query for all the buttons on a Windows Forms form and calls the LINQToDataTable method to put the query results into a DataTable.

Dim newDataTable As DataTable = _

        LinqUtilities.LINQToDataTable(From btn In Me.Controls _

            Where TypeOf (btn) Is Button Select btn)

Mike McIntyre's .Net Journal

getdotnetcode.com

Spot the Bug! – Much ado about Nothing… Part 2! (Jonathan Aneja)

The Visual Basic Team - VBTeam — Fri, 06 Nov 2009 07:46:00 PST

Channel: The Visual Basic Team

In yesterday’s post we saw that the use of the wrong comparison operator with Nothing in an If block can lead to surprising results. Let’s look at a slightly different case today:

Dim x As Integer = Nothing

If x = Nothing Then

MsgBox("A true statement - we land here")

Else

MsgBox("The statement is a lie - we land here")

End If

What gets printed? If the code is intended to print “A true statement…”, is there actually a bug in this code?

Answer: The code is correct according to its “specification” (I’m using the term loosely here J), so from a technical point of view there is no bug here. However, from a code readability and maintenance point of view, I’d argue that there is a bug.

The Nothing literal in VB means “default value for this type”, and for an Integer that would be 0. So the code above is exactly equivalent to this:

Dim x As Integer = 0

If x = 0 Then

MsgBox("A true statement - we land here")

Else

MsgBox("The statement is a lie - we land here")

End If

Now that’s way more readable than the version above, and dramatically reduces the potential for confusion. In general*, if you ever find yourself writing “= Nothing” in a conditional expression, you should either be changing the = to “Is” (as we saw yesterday), or you should change Nothing to the actual default value if possible.

The next post will have a real bug, I promise J

*Yes, there may be cases such as structure/generics/overloaded operators where you actually would want to say “= Nothing” – my point is that if you’re going to do this make sure you know what you’re doing, and insert a comment so that those reading your code also know what you’re doing J.

Controlling TreeView Item Visibility

XTab (Ged Mead) - XTab — Fri, 06 Nov 2009 08:37:00 PST

Channel: XTab (Ged Mead)

An interesting question came up recently, where someone wanted to have a TreeView in which:

Each TreeViewItem consisted of two separate lines of content
but the second line may be hidden, depending on its content.

This was actually a Windows Forms question, but I wondered if this would be a good candidate for harnessing the graphical power of WPF to solve a tough WinForms problem. My idea was to create a WPF UserControl that had the features described above and then host this User Control in an ElementHost in the Windows Form.

It seemed like a reasonable proposition and here's how I went about it.

Data Source
First of all I need some data, so will use a simple Person class.

 
Imports System.ComponentModel
Imports System.Collections.ObjectModel
 
Public Class Person
    Implements INotifyPropertyChanged
 
    Sub New(ByVal personname As String, ByVal personstatus As String, ByVal personcategory As String)
        Me.FullName = personname
        Me.Status = personstatus
        Me.Category = personcategory
    End Sub
 
    Private _name As String
    Public Property FullName() As String
        Get
            Return _name
        End Get
        Set(ByVal value As String)
            _name = value
            OnPropertyChanged(New PropertyChangedEventArgs("FullName"))
        End Set
    End Property
 
 
    Private _status As String
    Public Property Status() As String
        Get
            Return _status
        End Get
        Set(ByVal value As String)
            _status = value
            OnPropertyChanged(New PropertyChangedEventArgs("Status"))
        End Set
    End Property
 
 
    Private _Category As String
    Public Property Category() As String
        Get
            Return _Category
        End Get
        Set(ByVal value As String)
            _Category = value
            OnPropertyChanged(New PropertyChangedEventArgs("Category"))
        End Set
    End Property
 
 
    Public Sub OnPropertyChanged(ByVal e As PropertyChangedEventArgs)
        If Not PropertyChangedEvent Is Nothing Then
            RaiseEvent PropertyChanged(Me, e)
        End If
    End Sub
 
 
    Public Event PropertyChanged(ByVal sender As Object, ByVal e As System.ComponentModel.PropertyChangedEventArgs) Implements System.ComponentModel.INotifyPropertyChanged.PropertyChanged
 
 
    Public Shared Function GetPersons() As List(Of Person)
        Dim GP As New List(Of Person)
        GP.Add(New Person("Ged Mead", "Busy", "VB City"))
        GP.Add(New Person("Joe Brown", "On Site", "Work Colleagues"))
        GP.Add(New Person("Serge Baliansky", "North Office", "VB City"))
        GP.Add(New Person("Fran Pickman", "East Centre", "Family"))
        GP.Add(New Person("Elaine Jones", "Not Available", "Work Colleagues"))
        GP.Add(New Person("Matt Bianca", "South Office", "VB City"))
        Return GP
    End Function
 
End Class

As you see, this class implements INotifyPropertyChanged, so that changes to instance properties can be caught and any appropriate action taken as a result. I also included a basic method to generate some dummy data.

The Basic TreeView
The TreeView will be a WPF UserControl, so it is necessary to create this inside the Windows Forms project. Use the Project > Add New Item menu for this, then select WPF from the selection window that appears and name the WPF UserControl:

In the code-behind, you create a DataContext which will be the source of the data that is used to populate the TreeView:

Partial Public Class TwoLineTreeView
    Dim Contacts As New List(Of Person)
 
 
    Private Sub TwoLineTreeView_Loaded(ByVal sender As Object, ByVal e As System.Windows.RoutedEventArgs) Handles Me.Loaded
        Contacts = Person.GetPersons
        Me.DataContext = Contacts
    End Sub
 
End Class 

An easy way to package up the two line content display is to use two TextBlocks inside a StackPanel. These would all be stored in a DataTemplate that the TreeView will use for its ItemTemplate property. Here's the first pass at the DataTemplate which I have placed in the Resources section of the UserControl named TwoLineTreeView.

  <UserControl.Resources>
     <DataTemplate x:Key="TVVis" >
      <TreeViewItem IsExpanded="True">
 
        <StackPanel>
          <TextBlock Text="{Binding Path=FullName}"
                  Margin="2,0,0,1"></TextBlock>
          <TextBlock Text="{Binding Path=Status}"
                  Margin="8,3,2,2"></TextBlock>
        </StackPanel>
      </TreeViewItem>
    </DataTemplate>
  </UserControl.Resources> 

The first TextBlock binds to the Person's name and the second one binds to their Status.

We can test this early stage by adding a TreeView control to the UserControl:

  <Grid>
    <TreeView ItemsSource="{Binding}" 
         ItemTemplate="{StaticResource TVVis}"   >
    </TreeView>
 
  </Grid> 

The Grid is inserted in the UserControl by default and although we don't really need it in this example there's no great value in deleting it.

If you now move to the Windows Form, you can add an ElementHost and populate it with this data bound user control. You can either find the ElementHost control in the Toolbox and drag an instance of it on to the surface of the form. If it hasn't been added to the Toolbox (and as it is a Windows Forms project it doesn't always appear by default) you can simply find the UserControl itself in the Toolbox and drag this on to the Form.

When you do so, an ElementHost will be created for you on the Form and will automatically offer you the TwoLineTreeView user control as the Child of that ElementHost. Run the project and you will see:

Enabling and Disabling Visibility of the Second TextBlock

The easiest way of hiding or showing the second item of data (the status of the Person) is to use a ValueConverter. I've written several blogs describing the use of these and you can check them out if you need more detail on how they work. An introduction to a simple ValueConverter is covered here and a more complex verion here and here.

Here is the Converter class used in this project:

Imports System.Windows.Data
 
Public Class StatusToVisibilityConverter
    Implements IValueConverter
 
    Public Function Convert(ByVal value As Object, ByVal targetType As System.Type, ByVal parameter As Object, ByVal culture As System.Globalization.CultureInfo) As Object Implements System.Windows.Data.IValueConverter.Convert
        Select Case value.ToString
            Case "Busy", "Not Available", "En Route"
                Return "Collapsed"
           
            Case Else
                Return "Visible"
        End Select
    End Function
 
    Public Function ConvertBack(ByVal value As Object, ByVal targetType As System.Type, ByVal parameter As Object, ByVal culture As System.Globalization.CultureInfo) As Object Implements System.Windows.Data.IValueConverter.ConvertBack
        Throw New NotImplementedException()
    End Function
End Class 

It tests the value of the Status property and if it finds it is set to Busy, Not Available or En Route it will not display the line. It will display it in all other cases.

The UserControl requires a namespace mapping before we can use this class to create and use a converter in the XAML pane.

   xmlns:local="clr-namespace:HostedTreeView"

With that in place, a converter is created inside the UserControl's Resources collection:

    <local:StatusToVisibilityConverter x:Key="StatusConverter" />

The final step is to use the converter in the markup for the second TextBlock, specifically to hide or show it based on the content. Here is the amended TextBlock markup:

         <TextBlock Text="{Binding Path=Status}"
           Visibility="{Binding Path=Status, Converter={StaticResource StatusConverter}}"  
           Margin="8,3,2,2"></TextBlock> 

Now when the project is run, the two Person instances that contain Busy or Not Available as their Status will not display the second line.

You can of course take this basic approach and use alternatives or weave a much more complex set of interconnections - perhaps replacing the Status text with another message altogether or totally hiding a Person and their Status if their Status has a particular value. Or whatever other variation meets your needs. They key task was to create a two line node in which you could control the visibility of the lines.

You can download the project used in this blog from here.

SQL Join Summary Query Example

Mike McIntyre - Mike McIntyre — Thu, 05 Nov 2009 02:57:00 PST

Channel: Mike McIntyre

Heres a short exmaple to get you thinking about how query results can be joined to tables for purposes such as attaching summary data.

The example below shows how a query that sums total sales for a product can be joined to a query that selects product ID and product name from the Products table in Microsoft's Adventure Works sample database.

SELECT
PROD.ProductID,
PROD.[Name],
ISNULL(SALES.ProductSales,0) ProductSales
FROM Production.Product PROD
LEFT JOIN
(
SELECT ProductId,
SUM(LineTotal) ProductSales
FROM Sales.SalesOrderDetail SOD
GROUP BY ProductID
) SALES
ON PROD.ProductID = SALES.ProductID

The SELECT query within the parentheses returns a result with two columns: 1) ProductID and 2) ProductSales.

The query within parentheses is assigned the alias 'SALES' which is used to construct the ON clause that joins SALES to the Product table.

Because the SALES query returns ProductID (SALES.ProductID) it can be joined to PROD.ProductID.

Mike McIntyre's .Net Journal

getdotnetcode.com

IntPtr gets operators !!!

@ Head - Bill McCarthy - VB - bill — Thu, 05 Nov 2009 01:48:00 PST

Channel: @ Head - Bill McCarthy - VB

This seems so incredibly long overdue, but at last as of .NET 4, IntPtr has + and – operators added to it !!

This means you can now easily write code such as :

Dim ptr As IntPtr

. . . .
ptr += 4

this is great when dealing with offsets etc.

The actual implementation is kind of interesting. Here I’m seeing the implementation as :

Public Shared Operator -(ByVal pointer As IntPtr, ByVal offset As Integer) As IntPtr
Return New IntPtr((pointer.ToInt32 - offset))
End Function

I guess this is because it is the 32 bit version of the library. Hopefully in the 64 bit version it calls on IntPtr.ToInt64 ;)

Spot the Bug! – Much Ado about Nothing… (Jonathan Aneja)

The Visual Basic Team - VBTeam — Wed, 04 Nov 2009 02:32:00 PST

Channel: The Visual Basic Team

Microsoft has this neat mailing list called “Spot the Bug” where developers can send interesting snippets of code that look correct but actually have subtle bugs in them. The puzzles are a lot of fun and I’ve always thought it’d be a fun thing to try here on the team blog. Over the past year or so I’ve been keeping a list of interesting bug reports and emails where people have been tripped up by some of VB’s hidden subtleties (though admittedly many of these could apply to C# as well).

The format’s gonna be a bit of an experiment – let me know if you prefer to see the answer in the same post or posted a day later. Alright let’s get started…

Spot the Bug:

The following code is intended to print “Yes” – will it?

Dim x As Integer? = Nothing

If x = Nothing Then

MsgBox("Yes: x contains null")

Else

MsgBox("No: x does not contain null, and has a real value")

End If

Answer: No! We’re using the equality operator to compare a nullable integer with Nothing – this results in null propagation, i.e. the result of the expression is Nothing. An If-statement attempts to convert its condition to a Boolean, so basically we’re left with this:

If Nothing Then

Else

'Obviously we'll always land here

End If

This can be really surprising when working with nullables, so we’ve decided to add a warning for this case in VB10:

The warning explains the fix – use “Is” instead of = to avoid the null propagation and get the semantics you expect:

Dim x As Integer? = Nothing

If x Is Nothing Then

MsgBox("Yes: x contains null")

Else

MsgBox("No: x does not contain null, and has a real value")

End If

Check back for a similar case but with a bit of a twist tomorrow...

Create and Use a Custom Command - Follow-Up

XTab (Ged Mead) - XTab — Wed, 04 Nov 2009 01:09:00 PST

Channel: XTab (Ged Mead)

In this earlier blog, I explained how you can create and use a Command to carry out a task based on a variety of user actions. These actions included key presses, mouse actions and key/mouse combinations, as well as clicking on WPF controls. At the time I said that if you didn't want to have the Image move unless the right mouse button was clicked directly on the Image itself (as opposed to clicking anywhere in the Window or on its other children) then you could use Bubbling and Tunneling. When I came to test this theory, however, I couldn't find an obvious way of achieving this. I could stop a right click on the Image working, but that was the exact opposite of what I was trying to do!

Whether this failure is due to the way the Command infrastructure works or (more likely) my inability to grasp the finer nuances of routing, I've had to admit defeat - at least temporarily. So I thought I should at least post up a workaround for anyone who read that blog item and did want the right click to work only on the Image itself.

The 'fix', such as it is, is to ditch the InputGesture for MouseAction.RightClick in the InputGestureCollection and use a standard event handler purely for the Image MouseDown event.

So, the MoveItCommand code becomes:

Public Class MoveItCommand2
 
    Private Shared _moveit As RoutedUICommand
    Public Shared ReadOnly Property MoveIt() As RoutedUICommand
        Get
            Return _moveit
        End Get
    End Property
 
    Shared Sub New()
        '  Add keyboard and mouse gestures
        Dim UserInputs As New InputGestureCollection()
        UserInputs.Add(New KeyGesture(Key.M, ModifierKeys.Alt))
        UserInputs.Add(New KeyGesture(Key.F12, ModifierKeys.None))
        ' UserInputs.Add(New MouseGesture(MouseAction.RightClick, ModifierKeys.None))
        UserInputs.Add(New MouseGesture(MouseAction.LeftClick, ModifierKeys.Shift))
        '  Assign these gestures to the _moveit field (and thereby to the MoveIt property)
        _moveit = New RoutedUICommand("Move Element", "Move", GetType(MoveItCommand), UserInputs)
    End Sub
 
End Class

You'll notice that I've renamed the class to MoveItCommand2.

The code behind for the Window now takes an event handler for the Image MouseDown:

    Private Sub MoveableImage_MouseDown(ByVal sender As Object, ByVal e As System.Windows.Input.MouseButtonEventArgs) Handles MoveableImage.MouseDown
        If e.ChangedButton = MouseButton.Right Then
            CommandBinding_Executed(MoveableImage, Nothing)
        End If
    End Sub

The code in that event handler simply calls the execution code for the original Command (so at least we retain some semblance of coordination).

Finally, the markup for the Image in the XAML Pane includes a pointer to the new MouseDown event handler:

      <Image x:Name="MoveableImage" Width="55" Source="questionmark2.jpg"
       Canvas.Left="0" Canvas.Top="0" 
       MouseDown="MoveableImage_MouseDown" 
         />

To avoid confusion, I'll show all the revised markup below, as all references to the Command now have '2' appended to them, and they are easy to miss!

<Window x:Class="Window4"
  xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
   xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
   xmlns:local="clr-namespace:GetValue"
   Title="Right Mouse Test" Height="300" Width="300">
 
  <Window.CommandBindings>
    <CommandBinding Command="local:MoveItCommand2.MoveIt"
                   Executed="CommandBinding_Executed" 
                   CanExecute="CommandBinding_CanExecute"/>
  </Window.CommandBindings>
 
  <Grid x:Name="MainGrid">
    <Grid.RowDefinitions>
      <RowDefinition Height="Auto" />
      <RowDefinition Height="218*" />
      <RowDefinition Height="Auto" />
    </Grid.RowDefinitions>
 
    <!--  Canvas in the main middle section -->
    <Canvas x:Name="MainCanvas" Grid.Row="1"
        >
      <Image x:Name="MoveableImage" Width="55" 
       Source="questionmark2.jpg"
       Canvas.Left="0" Canvas.Top="0" 
       MouseDown="MoveableImage_MouseDown" />
    </Canvas>
 
    <!-- Menu at the top -->
    <Menu Grid.Row="0" Margin="3">
      <MenuItem Header="Move It" Margin="5"
        Command="local:MoveItCommand2.MoveIt" />
    </Menu>
 
    <ToolBar Grid.Row="2" >
      <Button Content="Move It" 
       Command="local:MoveItCommand2.MoveIt"  />
    </ToolBar>
 
    <Button Grid.Row="1" VerticalAlignment="Bottom"
             HorizontalAlignment="Right" Width="100"
             Height="33" Content="Move It" Margin="0,0,4,2"
             Command="local:MoveItCommand2.MoveIt" />
  </Grid>
</Window>
 

Silverlight 3 - Enabling the Silverlight 'Out of Browser' Experience

Mike McIntyre - Mike McIntyre — Fri, 23 Oct 2009 13:09:00 PST

Channel: Mike McIntyre

Silverlight 3 applications can be installed as local applications on PCs and MACs.

This is a brief 'how to' for enabling, installing, and removing a Silverlight 3 out of browser applications.

1. Use Visual Studio 2008 or 2010 to create a Silverlight 3 project.

2. Open the Silverlight 3 project's properties dialog. Select the 'Silverlight' tab. Check the 'Enable running application out of the browser'. Click the 'Out-of-Browser Settings...' button.

3. The 'Out-of-Browser Settings' dialog opens. Use it to configure your Silverlight 3 application for out of browser installation.

4. Run your application. Right-click a page in your application and select 'Install..' menu item.

5. The 'Install application' dialog opens. Use it to install short cuts to your application.

6. The Silverlight 3 out of browser application short cut on the desktop:

7. Use the short cut to launch the application on the computer. Here's a screen shot of my sample application running locally on my computer:

8 To remove the Silverlight 3 out of browser application from your computer: run it, right-click a page in the application, and select the 'Remove this application...' menu item.

Visual Studio 2010 - Changes to Help System

Mike McIntyre - Mike McIntyre — Tue, 03 Nov 2009 15:01:00 PST

Channel: Mike McIntyre

There are changes to the Visual Studio 2010 help system that you'll want to learn about.

For example, the new 'Manage Help Settings' menu item:

The menu item opens the new 'Help Library Manager' dialog:

From MSDN: "The Help Library Manager (HLM) application allows you to manage product documentation in the local Microsoft Help 3.0 content store. Using HLM, you can find and install new content from the web or from media, go online to get updates for your offline content, and remove offline content. The Help Library Manager also manages settings that allow you to customize your help experience."

How To Create and Use a Custom Command in WPF

XTab (Ged Mead) - XTab — Mon, 02 Nov 2009 04:45:00 PST

Channel: XTab (Ged Mead)

I've got to be honest and admit up front that initially I wasn't completely sold on the idea that WPF Commands are the great leap forward that they are sometimes billed as. OK, so I get that they can reduce the repetition of event handling code, but even their most ardent supporters aren't going to be able to claim that the required code is particularly intuitive. I will agree though that the availability of CanExecute is useful sometimes when multiple controls are bound to a Command. As a WinForms developer moving to WPF, I still find that in many cases I'm happy to use event handlers and, where necessary, a utility method or two.

So, having got that caveat out of the way, let's look at a basic situation where we want a range of different user actions to trigger the same task.

I've decided to use the scenario that I covered in this blog. It's maybe not the most realistic scenario, but it does give an opportunity to use a wide range of user inputs and gestures to move the image across the screen. It also allows the use of the CanExecute event.

In the earlier blog, the user had to click on an image to make it move from left to right across a Canvas. This can soon become tiresome, so by means of a Command we'll give her several other options. In order to make the use of CanExecute realistic, we will say that once the image reaches the far right edge of the Canvas, it must stay there. So the image move will be allowed to happen (i.e. CanExecute) as long as it hasn't reached the right hand edge of the canvas.

Creating the User Interface
The following XAML will create an updated version of the Canvas-and-Image UI used previously. This version includes various controls that will be bound to the Command.

<Window x:Class="Window3"
   xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
   xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
 
   Title="Using A Command" Height="300" Width="300">
 
 
    <Grid x:Name="MainGrid">
    <Grid.RowDefinitions>
      <RowDefinition Height="Auto" />
      <RowDefinition Height="218*" />
      <RowDefinition Height="Auto" />
    </Grid.RowDefinitions>
 
 
      <!--  Canvas in the main middle section -->
    <Canvas x:Name="MainCanvas" Grid.Row="1">
      <Image x:Name="MoveableImage" Width="55" Source="questionmark2.jpg"
 
        Canvas.Left="0" Canvas.Top="0" />
    </Canvas>
 
    <!-- Menu at the top -->
    <Menu Grid.Row="0" Margin="3">
      <MenuItem Header="Move It" Margin="5"
 
               ></MenuItem>
    </Menu>
 
    <ToolBar Grid.Row="2" >
      <Button Content="Move It" 
              />
    </ToolBar>
 
      <Button Grid.Row="1" VerticalAlignment="Bottom"
             HorizontalAlignment="Right" Width="100"
             Height="33" Content="Move It" Margin="0,0,4,2"
              />
  </Grid>
</Window>

(If you've looked at the markup closely and think that the order of elements is haphazard, you would be wrong. Try moving the MenuItem to what seems a more logical position above the Canvas and you will get an Error when the code is completed. As you will see, the code behind for the MenuItem will eventually have a link to the Image. So therefore the Image must be created first in the top down XAML file, before the MenuItem can know about it . I often think that it's these little potential Gotchas that make the WinForms-to-WPF learning curve so difficult.)

This is what it should look like:

Creating the Command
Let's start by creating a new Command Class called MoveItCommand. It will have a single property named MoveIt, a backing field named _move it and a parameterless constructor. The property and field are of type RoutedUICommand, but apart from that are standard and really don't need any additional explanation:

    Private Shared _moveit As RoutedUICommand
    Public Shared ReadOnly Property MoveIt() As RoutedUICommand
        Get
            Return _moveit
        End Get
    End Property

The constructor is used to create the various keyboard and mouse gestures that can be used to move the image. For the purposes of demonstration, I've gone totally overboard on these and have included four variations in the final version. But for clarity, I am only showing one in the code snippet below:

Shared Sub New()

        '  Add keyboard and mouse gestures
        Dim UserInputs As New InputGestureCollection()
        UserInputs.Add(New KeyGesture(Key.M, ModifierKeys.Alt))
 
         '  Assign these gestures to the _moveit field (and thereby to the MoveIt property)
        _moveit = New RoutedUICommand("Move Element", "Move", GetType(MoveItCommand), UserInputs)
 
    End Sub 

The constructor begins by creating a new empty collection of mouse gestures.
The second line creates and stores a gesture which takes the Alt and M keys as the combination to be used to fire this command. Notice the order of the keys used as arguments - effectively it is "M & Alt" which isn't the way we usually think of the combination. If you switch the order and place the Modifier key first, you will get a runtime error. Trust me, I've been there, done that!
Finally, a new RoutedCommand is created, containing descriptive text, its name, owner type (which is this custom command class - MoveItCommand), and the collection of Gestures that will work with this command.

Note that all the members of this class are Shared, ensuring that only instance of the Command will be in use in the application when it runs.

Additional Gestures
If you are happy with how the Class and its Constructor works, I'll now add in those other gestures I mentioned. These include F12 on its own, a mouse click on its own and finally a combination of mouse click and key press. Here's the revised code:

    Shared Sub New()
        '  Add keyboard and mouse gestures
        Dim UserInputs As New InputGestureCollection()
        UserInputs.Add(New KeyGesture(Key.M, ModifierKeys.Alt))
        UserInputs.Add(New KeyGesture(Key.F12, ModifierKeys.None))
        UserInputs.Add(New MouseGesture(MouseAction.RightClick, ModifierKeys.None))
        UserInputs.Add(New MouseGesture(MouseAction.LeftClick, ModifierKeys.Shift))
         '  Assign these gestures to the _moveit field (and thereby to the MoveIt property)
        _moveit = New RoutedUICommand("Move Element", "Move", GetType(MoveItCommand), UserInputs)
    End Sub

The first gesture is Alt and M, which I've already covered.
The second gesture is the F12 key on its own. Note that you must include Modifiers.None. if you don't, you will get a runtime error.
The third gesture will fire the command when the mouse is right clicked anywhere in the Window. Because of the way that WPF and RoutedCommands work, this effectively means that you can still click on the Image to make it move. If you wanted to limit the mouse click to the Image only, you could harness the power of Bubbling and Tunneling events to trap the mouse button press at the Image level. I haven't done that in this example.
The final gesture takes a combination of both the mouse left button click together with holding down the Shift key. Quite awkward to use and only included to demonstrate the range of available gestures.

Command Bindings
Having created the custom Command Class, if we want to use it in the XAML - and we do - then it is necessary to create an XML namespace mapping. Without this link, the XAML markup would have no idea about the existence of the class and its property. The syntax is fairly simple:

   xmlns:local="clr-namespace:GetValue" 

The alias of 'local' is used as the key which is mapped to the namespace in which the MoveItCommand class resides. The namespace is the same as the name of the project and in this case the project is named 'GetValue'.

Given this namespace mapping, we can now set up the CommandBinding in the XAML pane:

  <Window.CommandBindings>
    <CommandBinding Command="local:MoveItCommand.MoveIt"
                   Executed="CommandBinding_Executed" 
                   CanExecute="CommandBinding_CanExecute"/>
  </Window.CommandBindings>

As you see from the snippet above, you create a new CommandBinding inside a CommandBindings collection. The Command property of the CommandBinding points to that MoveIt property created in the MoveItCommand class.

The Executed and CanExecute properties point to two methods which we will create next in the code-behind.

Executing The CommandBinding The task of the CommandBinding_Executed method is to carry out whatever tasks we want to have actioned when the command is invoked. In this demonstration project, this task is simply to shunt the image a few units to the right. So the code is as follows:

    Private Sub CommandBinding_Executed(ByVal sender As System.Object, ByVal e As System.Windows.Input.ExecutedRoutedEventArgs)
        '  Move the image 5 units to the right
        Dim LeftPos As Double = MoveableImage.GetValue(Canvas.LeftProperty)
        MoveableImage.SetValue(Canvas.LeftProperty, LeftPos + 5)
 
    End Sub 

(If you are not sure about how the GetValue and SetValue functions work, you can read up on it in my blog here).

CanExecute
CanExecute is an optional feature which can be quite useful. In this demonstration, we will only allow the Command to work (and therefore only allow the Image to continue moving to the right) if it hasn't reached the right hand edge of the Canvas. More subtly, if CanExecute becomes set to False, any controls that are bound to the Command will automatically be disabled. I will add Command Bindings to the buttons, etc shortly.

First, here is the code for the CanExecute method:

    Private Sub CommandBinding_CanExecute(ByVal sender As System.Object, ByVal e As System.Windows.Input.CanExecuteRoutedEventArgs)
        '  Only allow execution of the command if the image
        '  has not yet reached the right hand edge.
        e.CanExecute = MoveableImage.GetValue(Canvas.LeftProperty) < (MainCanvas.ActualWidth - MoveableImage.Width)
 
    End Sub 

It tests the current position of the Image to see if it has reached the right hand edge of the Canvas. CanExecute will be set to True if there is still space to the right side of the Image, otherwise it will be set to False.

The complete code behind for the Window and the Custom Command class together now looks like this:

Partial Public Class Window3
 
    Private Sub CommandBinding_Executed(ByVal sender As System.Object, ByVal e As System.Windows.Input.ExecutedRoutedEventArgs)
        '  Move the image 5 units to the right
        Dim LeftPos As Double = MoveableImage.GetValue(Canvas.LeftProperty)
        MoveableImage.SetValue(Canvas.LeftProperty, LeftPos + 5)
 
    End Sub
 
    Private Sub CommandBinding_CanExecute(ByVal sender As System.Object, ByVal e As System.Windows.Input.CanExecuteRoutedEventArgs)
        '  Only allow execution of the command if the image
        '  has not yet reached the right hand edge.
        e.CanExecute = MoveableImage.GetValue(Canvas.LeftProperty) < (MainCanvas.ActualWidth - MoveableImage.Width)
 
    End Sub
End Class
 
Public Class MoveItCommand
 
    Private Shared _moveit As RoutedUICommand
    Public Shared ReadOnly Property MoveIt() As RoutedUICommand
        Get
            Return _moveit
        End Get
    End Property
 
    Shared Sub New()
        '  Add keyboard and mouse gestures
        Dim UserInputs As New InputGestureCollection()
        UserInputs.Add(New KeyGesture(Key.M, ModifierKeys.Alt))
        UserInputs.Add(New KeyGesture(Key.F12, ModifierKeys.None))
        UserInputs.Add(New MouseGesture(MouseAction.RightClick, ModifierKeys.None))
        UserInputs.Add(New MouseGesture(MouseAction.LeftClick, ModifierKeys.Shift))
     

Project Communication

VB & .NET Blogs @ vbCity.com - LarryBlake — Fri, 30 Oct 2009 18:44:00 PST

Channel: VB & .NET Blogs @ vbCity.com

The most successful projects, software or otherwise, are the ones where everyone has a good idea of what they're doing and why. A healthy organization communicates its goals, successes and failures, and has well-informed employees.

A really good illustration of the importance of communication is given by Nobel-winning physicist Richard Feynman in his lecture Los Alamos From Below . (This lecture is also a chapter in his very entertaining autobiography, Surely You're Joking, Mr. Feynman .) During the second world war, Feynman was part of the Manhattan Project, building an atomic bomb in Los Alamos, New Mexico. This was a top-secret project, but it employed a number of civilians who were not in on the details.

One day, Feynman was doing some work around the civilian area, and he noticed that some explosive materials were being handled in a very casual way. He realized that there could be a dangerous accident unless the personnel got proper training. When the army finally agreed to allow Feynman to train them, there was also an enormous improvement in productivity. "We're trying to develop an important weapon before they do? Why didn't you tell us?" All kinds of new ideas started pouring in. And of course, the immediate danger was avoided.

Sometimes it's really easy for a manager or a business person to tell a programmer "I need a program to do X and I need it Thursday", without explaining why X, and how X fits into the larger picture. This has several risks:

1. By not discussing it, no one ever thinks of Y, which would be much better for the organization. Opportunity lost.
2. Eventually, someone will think of Y and insist that it be done. At that point, much of the effort on X was a waste of resources.
3. The programmer might be diverted from working on a new release which could easily have incorporated X. Would it have been better to wait and not need a retrofit?

And finally, the programmer doesn't feel valued. When employees believe that management just leads them around, often changing course and reversing earlier decisions, it's easy to feel that it's just a job, just a paycheck, no thought necessary, why bother. People stagnate.

I recently attended a project management seminar where the speaker said teams that communicate well are 43% more productive. I'm not sure how you measure that, but it's an enormous number. Isn't it worth a few minutes to really discuss what you're doing?

How To Edit Items in a Windows Forms ListView

XTab (Ged Mead) - XTab — Thu, 29 Oct 2009 11:52:00 PST

Channel: XTab (Ged Mead)

As I was finishing off the previous blog item on the Windows Forms ListView, it occurred to me that there isn't much documentation around to explain how to edit the ListView items. So I thought it might be useful to cover a couple of approaches in this blog.

If you're disappointed that there isn't a built-in way to edit all the items and sub items, the thing to bear in mind is that ListView is essentially a display control, rather than an editing one. That said, there is one built-in tool that you can use - but only as long as you are content to edit items in the first column exclusively.

Edit First Column Only
What you can do is set the ListView's LabelEdit property to True. You can set this via the Properties Window or in code, ideally in the Load Event:

    Private Sub Form2_Load(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Load
        LVMVPs.LabelEdit = True
    End Sub

Now, if you click on an item in the first column on any row, the data in the first column of the selected row will become editable. I actually found that I had to triple-click, but I'm not sure if this is just a reflection of my mouse click speed settings or is the default requirement:

If you have the FullRowSelect property set to True, you can click anywhere along the row and the item in the first column will become editable as shown in the screenshot above. If FullRowSelect is set to False then you do need to click directly on the first column.

Edit Any Column
You have to do a bit of work yourself if you want to be able to edit any cell in the ListView, but there isn't really much to it. To demonstrate the technique, I've added three TextBoxes and an Update button to the Form:

The code below will allow the user to Right-click on any row and this will cause the three items of data in that row to be displayed in the three TextBoxes.

Dim ItemSelected As ListViewItem

   Private Sub LVMVPs_MouseDown(ByVal sender As Object, _
    ByVal e As MouseEventArgs) Handles LVMVPs.MouseDown
        '  Test that user wants to edit
        If e.Button = Windows.Forms.MouseButtons.Right Then
            '  Identify the selected ListViewItem
            ItemSelected = LVMVPs.GetItemAt(e.X, e.Y)
 
            ' Display in TextBoxes to allow editing
            If (ItemSelected IsNot Nothing) Then
                TextBox1.Text = (ItemSelected.SubItems(0).Text)
                TextBox2.Text = (ItemSelected.SubItems(1).Text)
                TextBox3.Text = (ItemSelected.SubItems(2).Text)
            End If
        End If
    End Sub

As you can see, it first tests that the Right mouse button has been clicked and if it has then each of the sub items is pasted into an individual TextBox below. The key feature in this block of code is the GetItemAt method of the ListView. This is the magic ingredient that allows you to easily identify exactly which row the user wants to deal with (and if you've spent a lot of fruitless time trying to work out how to use other ListView selection methods, you'll be pleased that you landed here!). Note that ItemSelected (the variable I am using to hold the current selection) is a ListViewItem object, not an index number - which is where most people seem to get caught.

The Confirm code is also very simple.

    Private Sub btnConfirm_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btnConfirm.Click
        '  Update ListView
        ItemSelected.SubItems(0).Text = TextBox1.Text
        ItemSelected.SubItems(1).Text = TextBox2.Text
        ItemSelected.SubItems(2).Text = TextBox3.Text
        '  Avoid confusion by clearing TextBoxes
        TextBox1.Clear()
        TextBox2.Clear()
        TextBox3.Clear()
 
    End Sub

The content of each TextBox is transferred back to the relevant ListView sub item (regardless of whether it has been changed - although you could of course build in a filter here if you wanted to). The TextBoxes are then cleared.

And for a simple project, that's really all there is to it. As you can see, I did also add a button to clear the ListView, but that was just for my own convenience, so I could test multiple consecutive edits without duplicating the data in the file.

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

Not so obviously, I did also make a change to the file save code. I wanted to ensure that there wasn't a new blank line at the end of the text file, which might have caused a problem, so I tweaked the btnSave Click event as shown below:

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

To avoid errors when there is no data in the TextBoxes, you might also want to disable and enable the Confirm button when appropriate. The sample project which you can download from here, includes this feature.

XML, take 4

VB & .NET Blogs @ vbCity.com - LarryBlake — Wed, 28 Oct 2009 15:49:00 PST

Channel: VB & .NET Blogs @ vbCity.com

I just got a note from Visual Basic MVP Steele Price, who pointed out a fourth way of writing XML. Unlike the three in my last post, this method will not work in C#.

As I should have mentioned, VB allows you to put XML directly in your code, which is great if you don't need to do a lot of dynamic modification to the XML. Now with LINQ, you can also insert variables, using a syntax resembling Classic ASP.

Since Steele was nice enough to send me a good example, I'll just post his.

Sub xml5(ByVal peoplepairs As IList(Of KeyValuePair(Of Integer, String)))
     'convert the List to XML
     Try
            Dim thelist = _
            <People>
                <%= From p In peoplepairs _
                    Select _
                    <Person id=<%= p.Key.ToString %>><%= p.Value %></Person> %>
            </People>

' Start document and write header
Dim xd As New XDocument(New XDeclaration("1.0", "UTF-8", "yes"), thelist)

            Try
                'Save the file
                xd.Save("MyXML.xml")

            Catch ex2 As Exception
                'do something here if the save fails
            End Try

        Catch ex1 As Exception
            'do something here if the conversion fails
        End Try
End Sub

There's always more ways to skin the cat. Steele's website is http://blog.steeleprice.net/ . Thanks!

How to Ask the User for Input

DevCity.NET - Articles - Larry Blake — Tue, 27 Oct 2009 00:00:00 PST

Channel: DevCity.NET - Articles

Visual Basic provides three easy ways to ask for input: MessageBox, InputBox and custom forms. I'll talk a little about all three.