The Visual Basic Team : WPF

Composite Application Guidance for WPF and Silverlight: VB QuickStarts, Hands-On-Labs, and How-To Topics released! (Lisa Feigenbaum)

VBTeam — Thu, 26 Mar 2009 06:37:00 GMT

Today the Microsoft Patterns & Practices team released a download aimed to help Visual Basic developers use the Composite Application Library. It includes VB versions of the QuickStarts, Hands-On-Labs, and How-To topics:

http://www.microsoft.com/downloads/details.aspx?displaylang=en&FamilyID=537da1cd-43e1-4799-88e7-a1da9166fb46

I've included some more information about the Composite Application Guidance below . You can also find more resources on MSDN and on CodePlex.

Please post feedback on the current VB release to Blaine's blog. (Blaine is a Program Manager on the Microsoft Patterns & Practices team.)

http://blogs.msdn.com/blaine/archive/2009/03/25/vb-quickstarts-and-how-to-s-now-available-for-prism.aspx

Cheers,
Lisa

What’s PRISM?

The Composite Client Application Guidance (formerly codenamed "Prism") is designed to help you more easily build modular Windows Presentation Foundation (WPF) and Silverlight client line of business applications.

These types of applications typically feature multiple screens, rich, flexible user interaction and data visualization, and role-determined behavior. They are built to last and built for change. This means that the application's expected lifetime is measured in years and that it will change in response to new, unforeseen requirements. This application may start small and over time evolve into a composite client—composite applications use loosely coupled, independently evolvable pieces that work together in the overall application.

Included in this release:

· Composite Application Library

· Reference Implementation (Stock Traders application in WPF and Silverlight)

· Quick starts (9)

· How-Tos (26) and

· Lots of documentation for everything you want to know about UI patterns and client architectures

Goals of This Release

Prism 1.0 shipped in July 2008 with support for WPF. This release takes the composite line of business scenarios and provides guidance on how to extend the scenario to Silverlight by:

· Providing guidance on building modular and composite Silverlight applications.

· Simplifying the composition of the user interface.

· Providing guidance and light tooling on reusing code between Silverlight and WPF.

Getting Started

The Composite Application Guidance is for building modular applications using WPF or Silverlight. You should consider using the Composite Application Guidance in any of the following scenarios:

· You are building a application that presents information from multiple sources through an integrated user interface.

· You are developing, testing, and deploying modules independently of the other modules.

· Your application will add more views and more functionality over the coming years.

· You must be able to change the application quickly and safely to meet emergent business requirements.

· Your application is being developed by multiple collaborating teams.

· Your application targets both WPF and Silverlight, and you want to share as much code as possible between the two platforms.

The following topics may help in understanding the guidance and how it applies to your scenarios:

· When to use this guidance

· Intended audience

· Evaluating the Composite Application Guidance

· Modularity design concept

· UI composition design concept

About patterns & practices

The Microsoft patterns & practices (p&p) team is responsible for delivering applied engineering guidance that helps software architects, developers, and their teams take full advantage of Microsoft’s platform technologies in their custom application development efforts.

Their goal is to help software development teams be more successful with the Microsoft application platform. They do this by delivering guidance that:

· Helps to simplify the Microsoft application platform.

· Provides solution guidance to common problems.

· Helps development teams grow their skills and learn.

For more information: http://msdn.microsoft.com/practices

Channel 9 Interview: WPF Improvements in VS2010 for Business Apps (Beth Massi, Milind Lele)

VBTeam — Tue, 24 Mar 2009 22:01:08 GMT

Today I posted a new interview on Channel 9 on WPF Improvements in Visual Studio 2010 for Building Business Apps.

At the MVP Summit a few weeks ago, Italian MVP Alessandro del Sole was so excited about the new WPF features in Visual Studio 2010 that he asked me if he could interview Milind Lele himself to get the low-down -- I said sure!

Milind is a Program Manager on the Visual Studio Pro Tools team. In this interview he chats with Alessandro about the new WPF improvements in Visual Studio 2010 for building business applications. This time Milind shows off the new Visual Studio UI and the new WPF data grid as he quickly builds a master-details form against an Entity Data Model using the new RAD drag-drop data binding features for WPF.

Also check out Milind's blog post on this topic for more information.

Enjoy,
-Beth Massi, Visual Studio Community

New WPF "How Do I" Video on Formatting Data Entry (Beth Massi)

VBTeam — Wed, 07 Jan 2009 00:14:06 GMT

Today we released a new How Do I Video onto the VB Dev Center on how to format controls on data entry forms using the IValueConverter like I showed on my blog here. The IValueConverter allows you full control over the display of the data as well as the editing of that data by users in the controls.

Check out all the WPF Forms over Data videos here.

Enjoy!

Channel 9 Interview: WPF Drag-Drop Data Binding in Visual Studio 2010 (Beth Massi)

VBTeam — Wed, 26 Nov 2008 23:00:04 GMT

I just posted a new Channel 9 video with Milind Lele, Program Manager on the Visual Studio Pro Tools team. In this interview Milind shows one of the new RAD improvements I was talking about that is coming to WPF in Visual Studio 2010 -- Drag-Drop Data Binding.

Also check out his blog post on this topic for more information. His team is looking for feedback on this feature so visit the Visual Studio 2010 CTP page to download the CTP and visit the feedback forums.

See it in action for yourself on Channel 9.

Enjoy,
-Beth Massi, Visual Studio Community

Drag-drop data binding for WPF in Visual Studio 2010 (Milind Lele)

VBTeam — Wed, 19 Nov 2008 23:39:00 GMT

One of the improvements in VS2010 (CTP available for download here) is drag and drop data binding for WPF. Drag-drop data binding has been available for WinForms since Visual Studio 2005. So those of you that are familiar with that will find the WPF experience quite similar and readily usable. In VS2010 we've brought that to WPF.

VS2008 SP1 brought the ability to add an Entity Data Model (EDM) to your projects. In VS2010 we've added support for EDM in the data sources window. Thus when you add an EDM to your project, the entities show up in the data sources window. You can simply drag the entities and drop them onto your WPF form or control to bind them.

I blogged about this on the Visual Studio Data blog recently.

Download the CTP, give it a try and do let me know what you think.

Milind Lele
Program Manager

New WPF How Do I Videos Released! (Beth Massi)

VBTeam — Tue, 04 Nov 2008 19:02:32 GMT

I posted two more WPF "Forms over Data" videos onto the Developer Center that you should check out.

How Do I: Edit Tabular Data in WPF? - learn how to create a simple data grid in WPF for editing tabular data using Visual Studio 2008 Service Pack 1.

How Do I: Create a Master-Detail Data Entry Form in WPF? - learn how to create a master-detail (or one-to-many) data entry form in WPF using Visual Studio 2008 Service Pack 1.

Subscribe to the How Do I video feed.

Enjoy,
-Beth Massi, Visual Studio Community

Are you using Windows Presentation Foundation with Visual Basic? (Lisa Feigenbaum)

VBTeam — Tue, 09 Sep 2008 23:30:00 GMT

After watching this video, you just might be convinced to try it out! VB MVP Billy Hollis demonstrates that Windows Presentation Foundation (WPF) is about a lot more than just pretty UI. He shows how the technology can be used in an extremely useful way, to create killer line-of-business applications. Watch a few minutes, and you'll understand what I mean!

The webcast is hosted on http://www.dnrtv.com/. You can find a direct link to the video HERE. Brad Abrams has also created a post about this video on his weblog.

How-Do-I Videos: WPF Forms over Data (Beth Massi)

VBTeam — Fri, 18 Jul 2008 00:34:00 GMT

If you haven't noticed, we released a couple new how-to videos on the VB Dev Center starting a new series which is focused on data-based application development in Windows Presentation Foundation using Visual Studio 2008. The videos are also being featured on www.WindowsClient.net today. Look for many more in the coming weeks!

Enjoy,
-Beth Massi, VS Community

Protein is Good for You, part 2 (Matt Gertz)

VBTeam — Tue, 17 Jun 2008 17:30:00 GMT

In yesterday’s blog post, I walked through an engine for translating DNA to its amino acid results via messenger RNA. In today’s blog, we’ll work on the visualization using WPF StackPanels. (This example requires VS2008, although it could certainly be written in WinForms as well with just a little bit of extra work.)

Caution: The point of this blog is to demonstrate StackPanels, and specifically how you can control their orientation and nesting. Consequently, for the sake of that argument, I’m creating a lot of text objects (one for each base and each amino) and nesting them to demonstrate this. For a really robust program, I would ditch the extra objects and just do owner draw directly. In other words, don’t use this example on enormous 20000-sequence strands of DNA, as neither you nor your PC would like the performance results.

StackPanels

In the last post, I added a ScrollViewer to the Window, changed it to scroll horizontally instead of vertically, but otherwise left it alone. Now we’ll dig into the details of how we’ll populate it with StackPanels.

StackPanels expose a very easy way to organize a set of drawable objects on the screen. StackPanels expose a Children collection, and when you add objects to the that collection, they’ll display in the order you add them and in the direction you specify. What’s really cool is that StackPanels will nest with each other, and I’ll take advantage of that fact by creating three StackPanels that organize information horizontally (one each for DNA, mRNA, and aminos), and then adding them to a parent StackPanel so that they line up with each other. I’ll then add the parent StackPanel to the ScrollViewer so that the alignment of all three sub-panels can be seen.

Each of the sub-panels will contain one of more text objects which either contain the abbreviation of a base, the abbreviation of an amino, or blank space (representing unused intron material). Aminos correspond to three bases, and so those text objects need to be three times wider. I’ll create some helper functions to return the appropriate text objects:

Const baseWidth As Integer = 16

Private Function DrawBase(ByVal base As Char) As TextBlock

Dim baseTextBlock As New TextBlock

Select Case base ' Switch for colors

Case "C"

baseTextBlock.Background = Brushes.LightSalmon

Case "G"

baseTextBlock.Background = Brushes.LightGoldenrodYellow

Case "A"

baseTextBlock.Background = Brushes.LightGreen

Case "T"

baseTextBlock.Background = Brushes.LightSkyBlue

Case "U"

baseTextBlock.Background = Brushes.LightSteelBlue

End Select

baseTextBlock.Inlines.Add(New Bold(New Run(base)))

baseTextBlock.Height = 32

baseTextBlock.Width = baseWidth

baseTextBlock.TextAlignment = TextAlignment.Center

Return baseTextBlock

End Function

That last function will be used by both DNA and RNA, creating and returning a fixed block of an appropriate color (a different one for each base) 16 x 32 pixels with the base abbreviation (passed into the function) centered within it. I've chosen light colors so that the dark text will show up against the background properly.

For the amino chains, it’s pretty similar, except that each block is three times wider, to keep the amino lined up with the codon:

Private Function DrawAmino(ByVal amino As String) As TextBlock

Dim aminoTextBlock As New TextBlock

Select Case amino ' Switch for colors

Case "Phe"

aminoTextBlock.Background = Brushes.AliceBlue

Case "Leu"

aminoTextBlock.Background = Brushes.Beige

Case "Ser"

aminoTextBlock.Background = Brushes.Cyan

Case "Tyr"

aminoTextBlock.Background = Brushes.LightSeaGreen

' (Etc… the other aminos omitted for brevity’s sake; see final code for full list.)

End Select

aminoTextBlock.Inlines.Add(New Bold(New Run(amino)))

aminoTextBlock.Height = 32

aminoTextBlock.Width = baseWidth * 3

aminoTextBlock.TextAlignment = TextAlignment.Center

Return aminoTextBlock

End Function

And for empty space, I just pass in the number of spaces required and multiple it by the baseWidth:

Private Function DrawNoMap(ByVal noMapSize As Integer) As TextBlock

Dim noMapTextBlock As New TextBlock

noMapTextBlock.Background = ScrollViewer1.Background

noMapTextBlock.Height = 32

noMapTextBlock.Width = baseWidth * noMapSize

Return noMapTextBlock

End Function

Now I have the tools; we can put them to good use. First, let’s create & populate the DNA StackPanel:

Private Function DrawBases(ByVal s As String) As StackPanel

' DNA goes here (horizontal orientation):

Dim myStackPanel As New StackPanel

myStackPanel.HorizontalAlignment = System.Windows.HorizontalAlignment.Left

myStackPanel.VerticalAlignment = System.Windows.VerticalAlignment.Top

myStackPanel.Orientation = Orientation.Horizontal

'Add child elements to the parent StackPanel.

For i As Integer = 0 To s.Length - 1

myStackPanel.Children.Add(DrawBase(s(i)))

Return myStackPanel

End Function

This is a simple function that does three things:

(1) Create a stack panel that has horizontal orientation, containing object that start from the top left.

(2) Step through each base in the DNA or RNA and add the TextBlock for it created in DrawBase.

(3) Return the completed StackPanel

I can use this for both DNA and mRNA just by passing in the appropriate string. Aminos are a bit trickier because I’ve decided to save them as lists of strings rather than one long string (to make it easier to access individual proteins should I wish to expand this program in the future):

Private Function DrawAminos() As StackPanel

' Aminos go here (horizontal orientation):

Dim myStackPanelAminos As New StackPanel

myStackPanelAminos.HorizontalAlignment = System.Windows.HorizontalAlignment.Left

myStackPanelAminos.VerticalAlignment = System.Windows.VerticalAlignment.Top

myStackPanelAminos.Orientation = Orientation.Horizontal

'Add child elements to the parent StackPanel.

For Each p In Proteins

Dim i As Integer = 0

Do While i < p.Length - 1

If p(i) = " " Then

Dim noMapSize As Integer = 0

Do While i < p.Length AndAlso p(i) = " " ' Make sure we don't go over when lining things up

noMapSize += 1

i += 1 ' Skip piece of intron for spacing

Loop

myStackPanelAminos.Children.Add(DrawNoMap(noMapSize))

Else

myStackPanelAminos.Children.Add(DrawAmino(p.Substring(i, 3)))

i += 3 ' Skip length of amino

End If

Loop

Return myStackPanelAminos

End Function

In this case, the panel is once again oriented horizontally from the top-left, but I have to (a) go through each string in the list looking for aminos to draw and (b) determine if there are spaces that need to take up room in the drawing but don’t contain actual amino content. Sequences without a stop codon would always be the final sequence (because the engine would have run through the whole string looking for them) and are just ignored by the application; they imply space without having to explicitly draw that space, since nothing else comes after it.

I don’t want to create a text block for each space in an adjacent block of spaces – that’s too wasteful even for a simple example like this – so I’ll determine the number of adjacent spaces whenever I encounter them and group them together in on big “no map” block. The “gotcha” in the above code is that I need to make sure that I don’t go past the final character both when looking for aminos as well as when drilling through the spaces.

Now, having created all of the drawing code as well as the code that runs through the sequences and calls them, I can create a master function that kicks off the drawing. First, I need to get rid of any old content in the ScrollViewer, tossing it into the garbage collector:

Private Sub DrawResults()

'Get rid of any old content

Me.ScrollViewer1.Content = Nothing

Next, I’ll create the master stack panel. Unlike the others, its orientation is vertical (which is the default, so I don’t need to explicitly state it), because I’m going to stack the other panels vertically from top-left:

' This stack panel will contian the other stack panels.

' It defaults to a vertical orientation

Dim myStackPanel As New StackPanel

myStackPanel.HorizontalAlignment = System.Windows.HorizontalAlignment.Left

myStackPanel.VerticalAlignment = System.Windows.VerticalAlignment.Top

Now, I’ll use the previously defined helper functions to create and draw the sub-panels, and then add them to the parent StackPanel:

Dim myStackPanelDNA As StackPanel = DrawBases(DNA)

Dim myStackPanelRNA As StackPanel = DrawBases(RNA)

Dim myStackPanelAminos As StackPanel = DrawAminos()

myStackPanel.Children.Add(myStackPanelDNA)

myStackPanel.Children.Add(myStackPanelRNA)

myStackPanel.Children.Add(myStackPanelAminos)

Finally, I add the parent panel to the ScrollViewer:

'Add the StackPanel as the lone Child of the Border

Me.ScrollViewer1.Content = myStackPanel

End Sub

I’m almost done now; there’s only one thing left to do. I’ve got to call DrawResults() after the DNA is loaded and translated, so I’ll add this line of code to the end of the LoadSequenceBtn_Click handler:

DrawResults()

And we’re done! I can launch the application, load in a file, see the translation visually, and save the results. For example, with a text file containing the string:

ACACGGGCGCGTACAAAAGATGAACTGGGGCCCCGCGCTACCGCCGCCACATTAAAAA

The output I save will look like:

ACACGGGCGCGTACAAAAGATGAACTGGGGCCCCGCGCTACCGCCGCCACATTAAAAA

UGUGCCCGCGCAUGUUUUCUACUUGACCCCGGGGCGCGAUGGCGGCGGUGUAAUUUUU

MetPheSerThr MetAlaAlaVal

On the screen, it looks much prettier, and I can scroll left-to-right to see all of the results.

That’s it for this post. The final code is posted at https://code.msdn.microsoft.com/Release/ProjectReleases.aspx?ProjectName=templeofvb&ReleaseId=1172 -- enjoy!

‘Til next time,

--Matt-

Protein is Good for You (Matt Gertz)

VBTeam — Tue, 17 Jun 2008 08:21:00 GMT

As I was preparing to graduate from the University of Michigan way back in the late eighties, I had a big decision to make regarding grad school – robotics at Carnegie Mellon, or biology at Washington State? On the one hand, biology was something I’d always really loved, having even intended to go to med school at one point. On the other hand, robotics was ~~more likely to help me pay off my debts~~ a very exciting field with a lot of challenges still ahead of it. Ultimately, I chose robotics (gaining a degree that, to this day, I have never used), but I often wonder what it might have been like to go into biology.

Anyway, back when I was dating my future wife (who was in the molecular biology graduate program), I wrote a quick’n’dirty program to translate DNA coding sequences to chains of amino acids for her advisor. That was fun, and I got feel like I was participating in the research (in a very teeny-tiny way). Beyond that, I haven’t had much interaction with hands-on biology work in many years, although I try to keep up with what’s going on. Recently, though, I’ve been scrambling trying to come up with new ideas for blog articles, and that program I wrote nearly 18 years ago came to mind. I’d never been happy with the visualization of the data, so I decided to give it a second try, this time using the WPF designer to help me out.

In this blog, I’ll cover the creation of a program to translate DNA from proteins, and tomorrow I’ll talk about visualizing the results using StackPanel controls. The overall example requires VS2008 or later to code up, although today’s blog code is mostly machinery that would pretty much work on either WinForms or WPF.

“Captain… the alien virus is rewriting his DNA! He’s changing!”

One of the problems in being both a computer specialist and also somewhat knowledgeable about biology is that it’s very difficult to make it through your average Star Trek episode, between the bad computer science and the bad biology. (For the record, changing your DNA won’t change your appearance, since the protein structures they code for already exist and represent roughly seven years of dead-end energy investment on your part. If you’re lucky, any changes will have no impact at all or even be beneficial; if you’re less lucky, the cell will die or cause some deleterious behavior.) At any rate, this will be a simple DNA/RNA/protein visualization program, and no DNA altering will be allowed. J

I’m not going to give a big overview on DNA transcription; if you don’t remember enough from school to follow along, the Wikipedia article on DNA is pretty good for refreshing one’s memory (as I found out). For the purposes of this exercise, we’ll just note that DNA is used to determine which proteins are created for a cell:

(1) DNA is comprised of a combination of 4 base pairs (A, T, C, G) connected longitudinally by a sugar/phosphate group and latitudinally by hydrogen bonds. A (adenine) always connects latitudinally to T (thymine), and C (cytosine) always connects to G (guanine).

(2) During transcription, the DNA (a double-helix) in a given chromosome is cut down the middle

(3) An mRNA (“messenger RNA”) string is built up from the DNA side which contains the appropriate information for that part of the string. (RNA is very similar to DNA except that the connective sugar is ribose instead of deoxyribose, and thymine is replaced with uracil (U)). The resulting mRNA string is an inverse copy of the strand it copied. I’ll be using the terms mRNA and RNA interchangeably for the purpose of this blog.

(4) Amino acids are assembled together based on the sequence of the mRNA. It takes three bases to code for one amino, so given four bases, there are 4^3 = 64 possible combinations for a given triplet (codon) of bases. Some codons code for the same amino; there are 20 standard aminos mapping to 61 codons. (Three of the possible codons simply indicate the end of a sequence; one codon indicates the start of a sequence and also codes for a specific amino, methionine.)

Basically, the plan for the program is this: allow the user to read in a sequence of DNA, automatically convert it to an mRNA sequence, and then convert it to zero or more sequences of amino acids. We’ll then throw a visual representation of all strings onto the form.

The basic application

First, I’ll create a new WPF application called “VBProtein.” On its grid, I’m going to throw three main controls:

(1) A ScrollViewer control for display the sequences graphically. I’ll set mine to be 112 pixels high (enough for three rows of sequences of height 32 pixels plus the scrollbar). In the properties of the ScrollViewer, I’ll set “HorizontalScrollbarVisibility” to “Visible” and “VerticalScrollbarVisibility” to “Disabled,” since the sequences will be listed left-to-right. I’ve also set its “TabIndex” to “0”.

(2) A Button control labeled “Load” (“TabIndex” = “1”).

(3) A Button control labeled “Save” (“TabIndex” = “2”).

I’ve also added a few label controls and changed a few colors, but that’s the all of the important stuff. Everything else gets added in code, so let’s take a look at that. Double-click on the window frame to generate the Window1_Loaded event. We’ll populate it later, but for the moment we’ll concentrate on the members we’ll need for the application. These are:

Public Translations As New Microsoft.VisualBasic.Collection

Public DNA As String

Public RNA As String

Public Proteins As New List(Of String)

We’ll load in the value of DNA, translate it to RNA, and then translate that to the Proteins – in other words, we’ll deal with those later. Let’s worry about the Translations instead.

For the translations, I decided to go with a Collection since they are easy to work with, they support keys for lookup, and I’m not dealing with too many objects – just the 64 possible codons. There’s a lot of information I’ll want to keep with each Translation:

Enum Sequence

Normal = 0

SequenceStart = 1

SequenceStop = 2

End Enum

Class Translation

Public Sub New(ByVal Triplet As String, ByVal Acid As String, _

ByVal Mnem As Char, ByVal Clue As Sequence)

Codon = Triplet

Amino = Acid

shortAmino = Mnem

Usage = Clue

End Sub

Public Overrides Function ToString() As String

Return Codon

End Function

Public Codon As String

Public Amino As String

Public shortAmino As Char

Public Usage As Sequence

End Class

Note that I’m overriding the “ToString” method to return the Codon value, which I’ll be using as a key in the collection. With this structure, I can initialize the translation collection (abridged from the actual code for the purposes of legibility):

Private Sub InitializeTranslations()

Translations.Add(New Translation("UUU", "Phe", "F", Sequence.Normal), "UUU") ' Phenylalanine

Translations.Add(New Translation("UUC", "Phe", "F", Sequence.Normal), "UUC") ' Phenylalanine

Translations.Add(New Translation("UAA", "OCH", ".", Sequence.SequenceStop), "UAA") ' Ochre stop sequence

Translations.Add(New Translation("UAG", "AMB", ".", Sequence.SequenceStop), "UAG") ' Amber stop sequence

Translations.Add(New Translation("UGA", "OPA", ".", Sequence.SequenceStop), "UGA") ' Opal stop sequence

Translations.Add(New Translation("AUG", "Met", "M", Sequence.SequenceStart), "AUG") ' Methionine

' Etc…

End Sub

Each translation has a codon, the abbreviated name of the matching amino, the one-character name of the matching amino (which I never use, but what the heck), and a setting which determines if this is a normal codon, a starting codon, or a stopping codon.

Now, in the Window1_Load code, I’ll add the following:

InitializeTranslations()

SaveResultsBtn.IsEnabled = False

(The second line is unrelated to the previous code and just disables the Save button until we have something to save.)

I can now start writing the functional code. Back on the grid, I’ll double-click the “Load” button, and in the resulting LoadSequenceBtn_Click event, I’ll add the following code:

' Load in the file

Dim dlg As New OpenFileDialog

dlg.Filter = My.Resources.FILT_FileFilter

If dlg.ShowDialog() = True Then

DNA = My.Computer.FileSystem.ReadAllText(dlg.SafeFileName)

End If

As you can see, first I’m throwing up a file dialog to get the name of the file to load (which is just a TXT file filled with bases -- FILT_FileFilter is a resource I've mapped to "Text Files (*.txt)|*.txt"), and then I open it up and read it into the DNA string variable using a handy “My.Computer” function.

Given the DNA, I can transcribe it to mRNA. First, I’ll need a transcription function:

Private Function Transcribe(ByVal Base As Char) As Char

Select Case Base

Case "A" ' Adenine

Transcribe = "U" ' Uracil

Case "T" ' Thymine

Transcribe = "A" ' Adenine

Case "G" ' Guanine

Transcribe = "C" ' Cytosine

Case "C" ' Cytosine

Transcribe = "G" ' Guanine

Case Else

Throw New ApplicationException(String.Format(My.Resources.ERR_UnknownBase, Base))

End Select

End Function

This is a very simple function which, given a character representing a base, returns the character which is the corresponding base. If it finds a character that it doesn’t understand, it throws an error, displaying a string (ERR_UnknownBase ) that I’ve defined in the project resources (right-click your project, choose “Properties,” and select the “Resources” tab from the resulting dialog to find the resources for the project). Transcription is now very easy:

Private Sub DNA2RNA()

RNA = ""

If DNA.Length < 6 Then Return ' Need two codons at least, or we're just wasting time.

Dim mRNA As New StringBuilder(DNA.Length)

For i As Integer = 0 To DNA.Length - 1

mRNA.Append(Transcribe(DNA(i)))

RNA = mRNA.ToString

End Sub

First I check to make sure there’s at least two codons (six bases) before doing anything – if less than that, then you can’t have both a start and a stop. Given that, I’ll iterate through the DNA string and collect the corresponding RNA characters. To save memory thrashing, I’ll use a stringbuilder to collect those and then save the result out to the RNA string.

Transcribing mRNA to aminos is slightly more difficult. We have to search the mRNA for a particular start sequence, and then end when one of three end sequences is found – and then repeat that again in case there are more sequences available farther along the mRNA string. (That’s why I’ve used List (Of String) for the collected proteins instead of just one string – if I ever chose to expand this program, it’s nice to have all of the sequences in separate strings already.) I’ll begin by freeing up any existing protein memory, doing the check on lengths, and setting up an index:

Private Sub RNA2Proteins()

' First, find the start codon. This is typically AUG.

' I'm deliberately not dealing with the rare exceptional

' cases sometimes found in mature mRNA.

Proteins.Clear()

If RNA.Length < 6 Then Return ' Need two codons at least, or we're just wasting time.

Dim sProteins As New StringBuilder

Dim currentIndex = 0

As with the DNA->RNA case, I’ll need a way of collecting bits of a string that doesn’t thrash memory, and thus I’ve declared a StringBuilder above. The currentIndex will track where we are in the RNA string.

I’ve got to look for the first entry codon. Since there’s only one type of those, I can use InStr to find it. I’ve got to be careful, though, because InStr is 1-based and not 0-based:

Do While currentIndex < RNA.Length

' Get past the current intron code (so-called "junk" DNA,

' though it may serve a function after all) to

' the next exon.

' CONSIDER: We could also modify this method to create

' mature mRNA from the precursor mRNA.

Dim startCodon = InStr(RNA.Substring(currentIndex), "AUG") - 1 ' InStr is 1-based, not 0-based

If startCodon = -1 Then Return ' Remember I subtracted 1 from the value, so not checking for 0 as normal

currentIndex = currentIndex + startCodon ' Jump to the start codon for the next exon

So now I’m pointing at the first starting codon (if any exists at all). At this point, I need to check my spec and note that I’m going to want to display the DNA, RNA, and aminos all next to each other and lined up properly. If I write out the aminos without taking account of the space taking up by the theoretically-unused portions of the genome, the aminos won’t line up properly with their corresponding genetic material. So, I’ll introduce whitespace for each base I skipped over:

Dim sProtein As New StringBuilder

sProtein.Append(" ", startCodon) ' Remember the offset; it will be important later when drawing.

Having inserted that reminder for later use, I then proceed to grab every three bases and translate them to their amino equivalents. I’ll do this until I find one of the “stop” codon. (If I don’t find a stop codon before I get to the end of the mRNA, I’ll ignore the entire string.) Note that I’m using the Translations collection to easily map the three-base codon (the key to the collection) to its amino equivalent. “Stop” codons don’t map to aminos, so when I find one of those, I simply insert three spaces, add the current protein string to the list of proteins, and exit the loop:

Dim StopFound As Boolean = False

Do While currentIndex + 2 < RNA.Length ' Need to consume this character plus 2 more

Dim entry As Translation

entry = Me.Translations(RNA.Substring(currentIndex, 3))

currentIndex += 3 ' Skip to next sequence, no matter what happens

If entry.Usage <> Sequence.SequenceStop Then

sProtein.Append(entry.Amino)

Else

StopFound = True

sProtein.Append(" ") ' Add three spaces to make sure spacing works when drawing

Proteins.Add(sProtein.ToString)

Exit Do

End If

Loop

I might have exited the loop due to running out of mRNA, so now I need to check for that condition. (If I didn’t run out of space, I’ll just loop back up and look for the next start codon, if any.)

If StopFound <> True Then Exit Do

Loop

End Sub

Finally, I’ll go back to the LoadSequenceBtn_Click event and call the two translator functions (inserting this code after the file is loaded), and also notify the Save button that we now have something to save:

DNA2RNA()

RNA2Proteins()

' We've loaded & processed, so we can save now.

SaveResultsBtn.IsEnabled = True

The code for the Save button (double-click on it to create the event handler) is very similar to that of the Load button, except that instead of reading one string, we’re writing two strings plus the list of proteins:

Dim dlg As New SaveFileDialog

dlg.Filter = My.Resources.FILT_FileFilter

If dlg.ShowDialog() = True Then

My.Computer.FileSystem.WriteAllText(dlg.SafeFileName, DNA & vbCrLf, False) ' Overwrite existing file on first write

My.Computer.FileSystem.WriteAllText(dlg.SafeFileName, RNA & vbCrLf, True)

For Each p In Proteins

My.Computer.FileSystem.WriteAllText(dlg.SafeFileName, p, True)

End If

And if you look at the results in a fixed-text font without word wrap (i.e., Notepad), everything should line up correctly. I could do more work here to break it all up into 80-char-width chunks, but I’ll leave that as an exercise for the audience.

We’ve got all of the information translated properly – now we need to display it. In tomorrow’s blog post, I’ll show one way of doing this using the WPF Designer.

‘Til next time,

--Matt--*

"Git Over Here": Making Your Windows Mind Their Manners (Matt Gertz)

VBTeam — Thu, 03 Apr 2008 21:50:00 GMT

Supporting the “pajama programmer”

Telecommuting is a great thing, and as the environmentally-conscious person that I strive to be, is something I wholeheartedly endorse when it can be done practically. My current job involves a lot of face-to-face meetings with people, so I don’t actually do a lot of it. However, I do work from home in the evenings (for example, when crafting blog posts), so it’s important to me that my setup for working from home is usable.

The challenge that I face is that my work machine is dual-monitor, whereas my home machine is single-monitor. Consequently, unless I make a conscious decision to move all of my windows to monitor #1 before I go home, many of the windows I need are off-screen when I remotely access my work machine from home. Choosing to “cascade” or “tile” the windows doesn’t work, since those commands don’t actually move windows from their current monitor. I can, of course, right-click on the relevant window’s icon in the task bar and choose “Move” to slowly move the window to monitor #1 with the cursor keys, but that’s a hassle. What I want is a quick way to say “git over here!” to one or more windows.

Now, I’m sure there is plenty of freeware out there that already does this sort of thing, but I’d also been looking for an opportunity to play around with WPF (Windows Presentation Foundation, formerly known as “Avalon”) windows, so I decided to take the time to put this together by hand as a way of learning more about them since I haven’t had too much experience with them yet. So, note that I’m not going to be demonstrating anything “WPF-ish” in this post – no transparency or special effects or whatnot – mostly, this exercise was just a way for me to get used to the variations in the designer and the properties before I jump in to anything trickier.

The goal is to create an application with a listview containing all of the titled windows on the system, and a button to move the selected window to location (10,10), which would certainly be on monitor #1. (VS2005 and earlier users: although I’ll be doing this using a WPF window in VS2008, there’s absolutely no reason this code won’t also work with forms – the translations are pretty straightforward.)

Creating the basic app – the designer

First, choose “New Project…” and select “WPF Application” from the list of Windows project types, give it a name (I chose “VBGitOverHere”) and press “OK.” After the project is created, you’ll see a designer which is rather different looking than the one you’d be used to for forms. At the top is something that sort of looks like the Forms designer, but at the bottom you’ll see a XAML pane. XAML is the backbone of WPF and ultimately describes the layout of the window, rather like an ActiveX form, if you’ve used one of those before. (We won’t actually be interacting with the XAML editor in this example, as everything I discuss in this post can be done in the designer and editor.)

The property grid for a window works pretty much the same way it does for forms. One of the biggest differences is that the name of the object is specified at the top of the properties window containing the grid, and not in the grid itself – go ahead & change that to whatever you like. Also, let’s change the Title property to “VBGitOverHere” (or whatever makes sense to you), Topmost to “True,” WindowStartupLocation to “Manual”, and both Left and Top to 10. This will make sure that this window always starts up in the upper-left corner of the first monitor, on top of everything else. (It would obviously defeat the purpose of this app to have it pop up on the second monitor, and I also want to make sure it stays on top as windows are moved around.)

One thing to notice is that the window in the designer already controls a control – a grid, which you can think of as the client area for your controls. It can of course be resized and moved around. The other controls you add will be nested in this, and their position property values are relevant to it, not to the enclosing window. So, drag out a ListBox from the toolbox into the grid and call it “WindowList.” Resize it so that it takes up the left side of the grid. Set its TabIndex property to “1” and its SelectionMode property to Multiple. This is the list that we’ll put the window titles in.

Now add four buttons into the right side of the Grid. You’ll want to set their TabIndex values appropriately (2, 3, 4, 5), and you’ll want to give then appropriate names (GitOverHereBtn, RefreshBtn, SelectAllBtn, ClearAllBtn) to code against. They also need titles as well. To set the title of the button, you use the Content property – there is no “Text” property such as Forms controls have.

Adding helper code

Now, to the code. Select the window (not the grid – the actual window) and double-click it. You’ll be taken to a code editor and dropped into editing the Window1_Loaded method (or whatever you called it). This is the equivalent of the “Form1_Load” method for forms. The only thing you’ll be doing in this method is populate the listview. You’ll want to write a helper method for that, since you’ll also want a way to refresh the list of windows in case a new one opens or one is closed. But before that, you’ll need to declare some Windows APIs to help me get the list of windows from the operating system. To do this, add the following declarations inside the class:

Declare Auto Function SetWindowPos Lib "user32.dll" (ByVal hWnd As IntPtr, _

ByVal hWndAfter As IntPtr, ByVal X As Integer, ByVal Y As Integer, _

ByVal CX As Integer, ByVal CY As Integer, ByVal uFlags As UInteger) As Integer

That will allow you to set the position of a window that’s not owned by your own application.

Delegate Function EnumWindowsCallback(ByVal hWnd As IntPtr, _

ByVal lParam As Integer) As Boolean

Declare Ansi Function EnumChildWindows Lib "user32.dll" (ByVal hwnd As IntPtr, _

ByVal MyCallBack As EnumWindowsCallback, ByVal lParam As Integer) As Boolean

Those two will allow you to ask the operating system for the list of all windows currently in existence on your machine. You initiate that by calling EnumChildWindows, and that in turn calls a delegated function, once per found window, with the required information.

Declare Ansi Function GetWindowTextA Lib "user32.dll" (ByVal hwnd As IntPtr, _

ByVal Str As StringBuilder, ByVal lSize As Integer) As Integer

That will allow you to get the title bar text for a window that’s not owned by your own application.

Declare Function GetWindowLongA Lib "user32.dll" (ByVal hwnd As IntPtr, _

ByVal num As Integer) As Integer

That will allow you to get the general properties for a window that’s not owned by your own application, so we can eliminate listing window types that we don’t actually care about.

You’ll also need to define some constants that those APIs will be expecting, so add these right after the previous lines:

Public Const SWP_NOSIZE = &H1

Public Const SWP_NOZORDER = &H4

Const WS_VISIBLE = &H10000000

Const WS_BORDER = &H800000

Const GWL_STYLE = -16

Now, you can create the helper function:

Private Sub UpdateWindowList()

Me.WindowList.Items.Clear()

Me.WindowList.SelectedIndex = -1

Me.GitOverHereBtn.IsEnabled = False

EnumChildWindows(0, AddressOf ChildWinCallback, 0)

End Sub

Basically, this method makes sure that the listview is cleared, with nothing selected (that’s actually redundant, but I tend to do it anyway for peace of mind), and that the button to move a window over is disabled, since it should only be enabled if there’s a selection. After that’s done, it calls the enumerator we declared above to actually go and get the windows for us. The callback for that is declared like this, matching the signature of the delegate we defined above:

Function ChildWinCallback(ByVal lhWnd As IntPtr, ByVal lParam As Integer) As Boolean

Now, you could just grab the window handle that’s passed to us, get its title, and throw it into the list, but you need to have some way to cache that handle so that you can use it later when the corresponding window title is selected. To assist with this, create a child class to cache that info:

Class WinWrapper

Sub New(ByVal h As IntPtr, ByVal c As String)

Hwnd = h

Caption = c

End Sub

Overrides Function ToString() As String

Return Caption

End Function

Public Hwnd As IntPtr

Public Caption As String

End Class

(In my implementation, I’ve embedded this class is in the overall window class, since I don’t have any reason for anything else to use it.) The class caches both the window handle and the window’s caption, and then exposes the caption via “ToString” so that anything trying to get a string from an object of this class will retrieve the caption.

Getting the window’s title and throwing it into the listview are now quite easy things to do. ChildWinCallback now looks like this:

Function ChildWinCallback(ByVal lhWnd As IntPtr, ByVal lParam As Integer) As Boolean

Dim Caption As New StringBuilder("", 500)

GetWindowTextA(lhWnd, Caption, Caption.Capacity)

Dim c As String = Caption.ToString

If c.Length > 0 Then

Dim wrappedWindow As New WinWrapper(lhWnd, c)

Me.WindowList.Items.Add(wrappedWindow)

End If

Return True

End Function

When you add the wrappedWindow object to the listview, it will use ToString to get the window text.

Now, note that code above only adds windows that actually have a title, because it checks to make sure that the title length is greater than zero. However, there may be other windows you don’t care about. Calvin Hsia has an excellent blog post on retrieving window information, and I’ve already borrowed one idea from it -- the cool use of StringBuilder above to get the window text. I’m also following in his footsteps to check for the visibility of a window, which can be done by adding use of the GetWindowLongA method which was declared above:

Dim nStyle = GetWindowLongA(lhWnd, GWL_STYLE)

If (nStyle And (WS_VISIBLE + WS_BORDER)) = (WS_VISIBLE + WS_BORDER) Then

Dim Caption As New StringBuilder("", 500)

GetWindowTextA(lhWnd, Caption, Caption.Capacity)

Dim c As String = Caption.ToString

If c.Length > 0 Then

Dim wrappedWindow As New WinWrapper(lhWnd, c)

Me.WindowList.Items.Add(wrappedWindow)

End If

In other words, if the style of the window doesn’t include a border or isn’t visible, it’s probably not something you care about.

Hooking in the events

That’s all of the set-up work, now you can leverage it and add handlers to all of the buttons. As with buttons on forms, you just double-click the button to take you to a place where you can edit the handler for “Click”. (As an aside, whenever you switch back to the designer, it may prompt you to refresh it, due to changes in the editor. If it needs to do this, it will tell you so via a gold status bar at the top of the designer – clicking on the gold bar will cause the refresh to happen.)

Code-wide, for Refresh, it’s very simple – you just call the helper function we defined above:

Private Sub RefreshBtn_Click(ByVal sender As System.Object, ByVal e As System.Windows.RoutedEventArgs) Handles RefreshBtn.Click

UpdateWindowList()

End Sub

For SelectAll and ClearAll, it’s also straightforward:

Private Sub ClearAll_Click(ByVal sender As System.Object, _

ByVal e As System.Windows.RoutedEventArgs) Handles ClearAll.Click

Me.WindowList.SelectedIndex = -1

End Sub

Private Sub SelectAll_Click(ByVal sender As System.Object, _

ByVal e As System.Windows.RoutedEventArgs) Handles SelectAll.Click

Me.WindowList.SelectAll()

End Sub

That just leaves the “GitOverHere” button, which was the whole point of this exercise. The solution here is to iterate over each selected object in the listview and call SetWindowPos on the window it wraps:

Private Sub GitOverHereBtn_Click(ByVal sender As System.Object, _

ByVal e As System.Windows.RoutedEventArgs) Handles GitOverHereBtn.Click

For Each wrappedWindow As WinWrapper In Me.WindowList.SelectedItems

If SetWindowPos(wrappedWindow.Hwnd, Nothing, 10, 10, -1, -1, _

SWP_NOSIZE Or SWP_NOZORDER) = False Then

MsgBox(String.Format(My.Resources.WindowError, Me.Title))

End If

End Sub

In this code, you’re telling each window to move to (10,10), and not to change its size nor its z-order (i.e., its depth relative to other windows). You can thus pass in -1, -1 for the size coordinates, and Nothing for the hWndAfter parameter. If the call fails (as it might if the window no longer exists), you’ll be popping up a message box showing a string (My.Resources.WindowError). The one I use is:

The window could not be moved -- its application may have already exited. Choose 'Refresh' in the {0} window to see the currently available windows.

The String.Format call will replace the {0} with the title of the application, “VBGitOverHere”. (As a reminder: to add string resources to a project, right-click the project, choose “Properties,” select the “Resources” tab in the resulting window, make sure the upper-left corner of the tab is set to “Strings,” and add string titles and values in the grid on that tab. You can reference them in code via the “My.Resources” namespace.)

There’s one last thing to do: you need to control the enabling/disabling of the “GitOverHere” button. At the top of the code editor, set the left-hand dropdown to “WindowList” and the right-hand one to “SelectionChanged.” That will generate the appropriate handler, and you’ll add one line to it:

Private Sub WindowList_SelectionChanged(ByVal sender As Object, _

ByVal e As System.Windows.Controls.SelectionChangedEventArgs) _

Handles WindowList.SelectionChanged

Me.GitOverHereBtn.IsEnabled = (Me.WindowList.SelectedItems.Count > 0)

End Sub

Now, every time the selection is changed, we’ll enable the button if there are any selections left, or disable it otherwise. (Note that for Forms controls, we’d be using the “Enabled” property instead of the “IsEnabled” property.)

That’s it, you’re done! When you launch the app, you’ll be presented with a list of all of the titled, visible, bordered windows on the system. You can select any or all of them and click “Git Over Here,” and the windows will jump over to the leftmost part of the first screen. You could easily modify this program to tile them as well, or control windows in other ways. (I do urge you to check out Calvin’s blog on some other cool things you can do programmatically with windows!)

Administrivia

I’ve posted the entire solution at my site on Code Gallery, so feel free to download it from there. Note that I’m going on vacation in a couple of days, so I won’t be able to respond to any comments on this post immediately – I’ll do my best to follow up when I get back in mid-April.

‘Til next time,

--Matt--*

Petzold WPF Book Sample Conversion - Final Chapters (Young Joo)

VBTeam — Wed, 30 Jan 2008 02:02:00 GMT

I've just posted a final set of chapters (Chapters 25 - 31). This completes our conversion efforts and you now have access to entire sample code from Petzold's book in VB. I would like to thank Evan and Ged who have been working with me on this. You guys rock!!!

A few things to note:

I moved all the code to the new MSDN Code Gallery. This is a central place where we can share sample applications and code snippets. You can also participate and contribute your own sample code. I've created a new gallery just for Petzold VB Sampe code. You can access it at http://code.msdn.microsoft.com/petzoldsamplevb.
I also updated the main page here (http://blogs.msdn.com/vbteam/pages/Petzold-WPF-VB-Samples.aspx) to point to the code gallery page.
In case you haven't noticed, Chapter 20 was missing XAMLCruncher project. We were having a bit of problem getting it property converted to VB. Ged was able to complete the conversion and I've uploaded the updated ZIP file for Chapter 20 which includes the XAMLCruncher project. Be sure to read the README.txt file to find out how you can address the potential issue of running the application in Debug mode from VS.

Hope you enjoy this!

Thanks!

Young Joo

Petzold WPF Book Sample Conversion - New Chapters (Young Joo)

VBTeam — Mon, 07 Jan 2008 22:59:00 GMT

Happy new year! Hope you enjoyed your holiday break! And hopefully you found some time to read Petzold's book and try out VB samples we've posted so far. :)

Evan and Ged had been working very hard to convert rest of chapters throughout December and I just posted Chapters 13 - 24 to Applications = Code + Markup (Charles Petzold) Visual Basic Code Sample page. We also have several more chapters converted but since we have a couple of chapters missing between sets, I will hold off posting them until we have those missing chapters ready.

I've also added a link to the single download file that contains all chapters converted so far. This should make the download much easier for you. The linked file will be updated as I post subsequent chapters.

Enjoy!

Drawing Maps with Visual Basic (Scott Wisniewski)

VBTeam — Mon, 26 Nov 2007 22:35:00 GMT

If you find yourself looking for something to do with your awesome new copy of Visual Studio 2008, you should check out the December 2007 edition of MSDN magazine. It features an article, written by me, that provides a walk through on how to visualize data on a map using VB 9, WPF and LINQ.

To give you a sneak preview of what the app described in the article does, I've included a screen shot below:

Over my next several posts I plan on expanding on the article by showing how you can extend the application by adding new functionality to it. For now, I will give you some time to read through the article, download the code sample, and play around with the app. In my next post I will show how you can make the application multithreaded while still taking full advantage of WPF data binding.

Enjoy!

Petzold WPF Book Sample Conversion Update (Young Joo)

VBTeam — Sat, 24 Nov 2007 15:21:00 GMT

Been a while since I posted Chapter 3 of Petzold's WPF book converted to VB. In case you missed it, Patrick started working on this project which I took over early this month. Anyway, I am very excited to tell you about progress we've been able to make so far.

First, we now have a separate article page, Applications = Code + Markup (Charles Petzold) Visual Basic Code Sample, where you can grab all the converted sample packages. We will be updating this article page as we continue with our conversion project. We did this to make it easier for you to find all sample codes without looking through old blog posts.

Remember that I told you about extra help we got, Evan Lim from Foothill Community College? Well, Evan is a trooper and he finished converting Ch. 4 - 12. They are posted in the article page now! Thanks Evan!

Another exciting news. Ged Mead, a VB MVP, has also decided to join the project recently and he already started working on converting several chapters. With Evan and Ged working together, I think we will be able to finish converting the entire book very soon.

By the way, I would like to know if this project is being helpful to you guys. Are you guys actually looking at the converted sample code while reading the book? Does it help to have both C# and VB code available?

Thanks!