You can find all the videos from the event here.  I believe each keynote and every session is now available for streaming.  I am currently going through them and watching the ones that I am interested in but couldn’t attend.

The first keynote was interesting.  The primary focus was Silverlight 4 and Windows Phone 7 Series.  The main reason for me being there was together  information on the upcoming release (version 4) of Silverlight so that portion of the keynote was definitely interesting.  I also have to admit that I liked what I saw regarding the phone.  It seems appealing but I am primarily excited about being able to develop apps for it using Silverlight.

The second keynote was not quite as interesting.  I did enjoy Bill Buxton’s talk about NUI(Natural User Interface) but I wasn’t overlly joyed or moved by the unveiling of Internet Explorer 9.  I believe the only thing of interest, to me, regarding IE 9 was the announcement that they are pushing and working hard to ensure that the same HTML and code works in IE 9 just as it does in the other browsers.  Basically, they are actually embracing the standards (especially HTML 5) and even going so far as to work with W3C.

I only wanted this first post to be a brief overview so I am going to stop here.  I have written many notes regarding the sessions that I attended and I am working on conducting additional research and compiling all the notes so I can write several related articles.  I am also working on configuring one of my computers with all the RC and beta products I need.  I do want to make a quick note that if you want to do phone development, you need Vista or Windows 7 (XP is not supported).

When I first started Mass Effect 2 I was greeted by a dialog asking me to login to EA.  I did so, as I had an account from DragonAge.  Then the screen froze at a “Please Wait” message and I had to kill the process.  I did research and I found it was an issue many people were experiencing.  Eventually, they resolve the issue and I was able to login.  I could have bypassed it but I wanted to get the free content (as I had purchased the Deluxe edition via Steam).  After a little download time I had all the extras and I was ready to play.

I wasn’t sure what “type” of character I wanted to play this time around.  I was pleased to learn that I could import my character from the first game, which I did.  I thought this would give me a completely different start then starting the game without the import, allowing me a little extra replay value.  It isn’t a direct import but your imported stats are used to give bonuses and somewhat influence your character for Mass Effect 2.  It is stated that choices that were made (such as any party members who died) would be carried over as well.  I don’t know to what extent but I feel that adds a potential interesting twist to playing from an import.

Once I got the character generation all wrapped up I started on the prologue.  I was very impressed with the opening story and the graphics as well.  It really pulled me and imeediately had me interested in what was coming next.  The action started immediately as well, which I like.  I also noted that the interface and character interaction was updated between the two versions of the game.  I have to say I like the changes.  Holding LEFT SHIFT freezes the action and displays a menu where actions can be chosen.  Releasing LEFT SHIFT executes those actions.  A very simple and well done approach.  I have made it even better for me by binding one of the extra buttons on my mouse to LEFT SHIFT.

There are other chanegs I have come across.  Many of them are on your new ship.  The ship navigation is differen as is planetary exploration.  I like these improvements as well.  So far I haven’t had to drive around that annoying little buggy looking for materials, you just scan for them, form your ship, and launch probes to collect.  I think it is a neater approach.  The buggy may still show up but it hasn’t yet (accept for comming across an older one already on the planet).

All told, it looks gorgeous and the story is great.  I have played through a couple of the main missions (mainly gathering team members) and dealt with some side quests.  I don’t find the combat or play tedious and the voice acting, story and graphics (as I have said) are fantastic.  I will state that I have noticed a couple over sights though.  The biggest is that the game doesn’t seem to understand what you are wearing.  For some reason, when I am on a base or inside, my character insists on walking around with his space helmet on.  He looks rather like an idiot.  This was a big problem when he ordered a drink at a bar and didn’t bother removing his helmet as he tilted his head back and took a big gulp.  The armor I was wearing was a bonus set from the Deluxe edition so I don’t know if this issue occurs for all suits or not.  I think it is only a minor issue but it seems so small and simple that it should have been taken care of.

I wanted to add an additional note about the graphical bugs.  I have come across a few more weird scenarios related to it in the game.  Drinking with the helmet on was bad enough but it appears I am too lazy to take the helmet off when kissing as well.  Maybe it is just a fetish that I am unaware of.

Even with the minor technical glitches, so far, I really enjoy the game and I am looking forward to playing it more (right after I finish this article and grab some lunch).

Ok, I lied.  I will repeat myself briefly because it is important.  The sudoku board is a 9 x 9 grid.  Each cell in this grid holds a value as part of the puzzle.  The cells are further grouped into what is called a Minigrid, of which there are 9.  Each mini grid is a smaller 3 x 3 grid of cells (9 total).

Covering that was important because I used that knowledge to design the board itself.  To keep things straight forward, I used UserControls as their really wasn’t a need to create a custom Control.  The parent control is the Board.  The XAML for the Board UserControl can be found below.

<UserControl
    x:Class="Sudoku.Board"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="clr-namespace:Sudoku"
    Width="400" Height="400">

    <Grid x:Name="LayoutRoot" Background="White" >
        <Grid.ColumnDefinitions>
            <ColumnDefinition />
            <ColumnDefinition />
        <ColumnDefinition />
        </Grid.ColumnDefinitions>
        <Grid.RowDefinitions>
            <RowDefinition />
            <RowDefinition />
            <RowDefinition />
        </Grid.RowDefinitions>
        <Border x:Name="MainBorder" Grid.ColumnSpan="3" Grid.RowSpan="3"  Background="White" BorderBrush="Black" BorderThickness="1" Margin="-1" />

        <!-- Miini Grids -->
        <local:MiniGrid x:Name="C1R1" Grid.Column="0" Grid.Row="0" />
        <local:MiniGrid x:Name="C2R1" Grid.Column="1" Grid.Row="0" />
        <local:MiniGrid x:Name="C3R1" Grid.Column="2" Grid.Row="0" />
        <local:MiniGrid x:Name="C1R2" Grid.Column="0" Grid.Row="1" />
        <local:MiniGrid x:Name="C2R2" Grid.Column="1" Grid.Row="1" />
        <local:MiniGrid x:Name="C3R2" Grid.Column="2" Grid.Row="1" />
        <local:MiniGrid x:Name="C1R3" Grid.Column="0" Grid.Row="2" />
        <local:MiniGrid x:Name="C2R3" Grid.Column="1" Grid.Row="2" />
        <local:MiniGrid x:Name="C3R3" Grid.Column="2" Grid.Row="2" />

        <!-- Highlighters -->
        <Rectangle x:Name="MiniGridHighlighter" Grid.Column="0" Grid.Row="0" Fill="#FF848484" Opacity=".5" IsHitTestVisible="False" Visibility="Collapsed" />
    </Grid>
</UserControl>

The Board itself is pretty simple.  It mainly consists of a Grid control which has 3 columns and 3 rows.  This grid uses a Border to draw a black line around the outside of the board itself.  Each cell in the Grid contains a MiniGrid control.  A MiniGrid is a user control that I created that represents, well, a mini grid on the board.  Each MiniGrid is named after the cell that is in.  For example, the MiniGrid that occupies the first cell on the board (column 1 and row 1) is named “C1R1″.  The Rectangle, named MiniGridHighlighter, is currently a place holder.  The Board doesn’t really use this yet.  I created it because I figured I might need a way to highlight the entire minigrid when I start working on the user interaction and game play.

<UserControl>
    x:Class="Sudoku.MiniGrid"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="clr-namespace:Sudoku"
    Height="Auto" Width="Auto">

    <Grid x:Name="LayoutRoot">
            <Border Grid.ColumnSpan="3" Grid.RowSpan="3" BorderBrush="Black" BorderThickness="1">
            <!-- Cell Container -->
            <Grid x:Name="CellLayout">
                <Grid.ColumnDefinitions>
                    <ColumnDefinition />
                    <ColumnDefinition />
                    <ColumnDefinition />
                </Grid.ColumnDefinitions>
                <Grid.RowDefinitions>
                    <RowDefinition />
                    <RowDefinition />
                    <RowDefinition />
                </Grid.RowDefinitions>

                <!-- Cells -->
                <local:Cell x:Name="C1R1" Grid.Column="0" Grid.Row="0" />
                <local:Cell x:Name="C2R1" Grid.Column="1" Grid.Row="0" />
                <local:Cell x:Name="C3R1" Grid.Column="2" Grid.Row="0" />
                <local:Cell x:Name="C1R2" Grid.Column="0" Grid.Row="1" />
                <local:Cell x:Name="C2R2" Grid.Column="1" Grid.Row="1" />
                <local:Cell x:Name="C3R2" Grid.Column="2" Grid.Row="1" />
                <local:Cell x:Name="C1R3" Grid.Column="0" Grid.Row="2" />
                <local:Cell x:Name="C2R3" Grid.Column="1" Grid.Row="2" />
                <local:Cell x:Name="C3R3" Grid.Column="2" Grid.Row="2" />

                <!-- Highlighters -->
                <Rectangle x:Name="ColumnHighlighter" Grid.Column="0" Grid.RowSpan="3" Fill="#FF848484" Opacity=".5" IsHitTestVisible="False" Visibility="Collapsed" />
                <Rectangle x:Name="RowHighlighter" Grid.ColumnSpan="3" Grid.Row="0" Fill="#FF848484" Opacity=".5" IsHitTestVisible="False" Visibility="Collapsed" />
            </Grid>
        </Border>
    </Grid>
</UserControl>

The MinGrid is constructed similar to the Board. Everything is contained within a parent Grid control. This has a Border control and an inner Grid. The inner Grid control, as with the Board control, has 3 columns and 3 rows.  This gives us nine cells total.  Each of these cells contains a Cell control.  Each Cell is named in the same manner as the MiniGrids were (as discussed above).  The MiniGrid also has two highlighter Rectangle controls which we may use later.  One is capable of highlighting a row while the other takes care of the column.

<UserControl>
    x:Class="Sudoku.Cell"
    xmlns">http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Height="Auto" Width="Auto">

    <Grid x:Name="LayoutRoot">
        <Border BorderBrush="Gray" BorderThickness="1" />
        <TextBlock x:Name="ValueTextBlock" Foreground="Black" VerticalAlignment="Center" HorizontalAlignment="Center" FontWeight="Bold" FontSize="24" />
    </Grid>

</UserControl>

Finally, above, we have the Cell itself.  This control is very simple and is made up of a Grid that contains a Border and a TextBlock.  The TextBlock is where the actually value for the cell will be displayed.

Sudoku Board

The three user controls, mentioned previously, make up the Sudoku puzzle board, which looks like the image shown above.  At this point there is no interaction but we are ready to fill the board with the actual puzzle (which I will cover in the next article).

My situation was pretty straight forward.  I haven’t logged into my domain controller (running Windows Server 2008) in about a month but tried last night.  I was extremely surprised when the password didn’t work.  I tried every variation I could think of and nothing worked.  I still think that the password was somehow changed or corrupted but I suppose my memory could be failing as well.

In any event, after hours of trying passwords and other avenues, I was not able to get in to the server.  I was rapidly approaching the last resort of having to rebuild the machine.  I was dreading this because the server was running two other virtual servers that I would also have to rebuild from scratch.  Yes, I know I should have had images for all of this (which I am building now) but I didn’t, so let us move on.

I searched and searched and I just couldn’t find much of anything that would actually work.  Until this morning, that is.  Before I get into the details I want to credit the article that provided me with the solution to my problem.

The solution is a two stage process.  The first stage is preparation and requires the use of PING (Partimage is not ghost) which is a linux environment that can run off of a disc.  You need to download the PING image and burn it to a disc before continuing.

Now that you have the disc ready, here are the steps to follow:

1. Put the disc in your server and boot off of it.  The process to do this differs by server but I am sure you can figure it out (or have done it before).
2. The PING linux environment will load.
3. When the environment is fully loaded, you will receive a “>>” prompt.
4. At the “>>” prompt, type “x” and press the ENTER key.  “x“  will take you to a command shell rather than launching the PING user interface.
5. At the “PING login:” prompt, type in “root” and press the ENTER key.
6. At this ping you should be logged into the PING operating system.  Now we need to run a few shell commands.
7. Run the following command:  fdisk -l : grep NTFS
8. This command will list all the NTFS partitions.  As best as you can, note the name of the one that contains the Windows directory.
9. Run the following command:  mkdir -p /mnt/windows
10. This command creates a directory called “/mnt/windows” that will be used for mounting the windows partition
11. Run the following command:  mount -t ntfs-3g /dev/sda3 /mnt/windows
12. This command actually performs the mount.  “/dev/sda3″ is the name of the device (from step 7) that holds the windows partition.  This was “sda3″ for me but may vary for you.
13. Run the following command:  cd /mnt/windows/Windows/System32
14. This command changes the current directory to the System32 directory in the Windows partition.  Now that the partition has been mounted, you can consider “/mnt/Windows” as the root drive of your server so “/mnt/windows/Windows/System32″ is the equivalent to “C:\Windows\System32″.
15. Run the following command:  mv Magnify.exe Magnify.bak
16. This command renames the “Magnify.exe” file, which is in the System32 folder.
17. Run the following command:  cp cmd.exe Magnify.exe
18. This command, the final one, makes a copy of “cmd.exe” and names it “Magnify.exe”.
19. Remove the disc and reboot

The steps above all make up the first stage, which is really the primary stage.  You see, we can’t really (easily) recover the password.  All the steps above bring you to a point where you will actually be able to bypass authentication all together with something akin to a backdoor.  Now you see why I started by saying that it should only be used for good.

For the second stage, we need to wait until Windows has booted and you are at the login screen.  On this screen you will notice a small icon in the lower left corner of the screen.  This is known as the “Ease of Access” feature, which provides accessibility options.  Click on this icon to bring up the dialog box.  You will notice several different accessibility options, one of them being “Make items on the screen larger (Magnifier)”.  This launches a tool called Magnify.exe which is used to make items on the screen larger.

Yes, I said “Magnify.exe”.  If you remember from the first stage of this solution, we replaced this tool with cmd.exe (which runs a command prompt).  On the “Ease of Access” dialog, select “Make items on the screen larger (Magnifier)” and press the OK button.  As you might expect now, instead of the Magnify tool being launched you are presented with a command prompt.  We have just fully bypasses the Windows Sever 2008 authentication.  You can run almost anything you can think from this command prompt as it is running under the NT AUTHORITY/SYSTEM account.  I ran “explorer.exe” which brought up the task bar.  I then went through the normal options to reset the password on the Administrator account and was able to immediately log in with the new password.

One more time I must stress that this information is only being presented to assist those who find themselves in a situation similar to mine.  Please do not use this information in an attempt to access a system that you should not have access too.

I am still using Silverlight but the biggest initially change is that I am not going to bother dynamically creating the Grid this time around.  The first artile, which I should have up in a couple days, will cover the board itself.  I am almost finished designing it in Expression Blend 3.  I have the main board and the minigrid control designed.  I just need to finish up the inidivudal cells.  Once this is all done I will move the XAML over to Visual Studio to wire-up with code.

Thanks for your patience, I promise I will have it up and running soon.

I guess this means I need to start tweeting more now.  I do have my PS3 and XBOX 360 hooked up to my Twitter account so those will send automatic tweets as I play the various games that I am currently involved in.  I will attempt to add more development related tweets for those that may find thos more interesting.  Please try out the TweetBoard and let me know what you think.

This is part 2 of a multi-part article on a custom Slider control.  You can find the other articles here:

• Overview
• The Base Class

The source code is now available on CodePlex

The purpose of this article is to start digging into some of the details behind the updated Slider control.  The best place to start is with the underlying base class.  The standard slider that comes with Silverlight has a base class called RangeBaseand can be found in the System.Windows.Controls.Primitives namespace.  This class defines the standard properties (Minimum, Maximum, LargeChange, SmallChange and Value).  Minimum and Maximum describe the lower and upper range of the slider itself will Value reflects the current value of the slider (where the thumb currently is located).  LargeChange and SmallChange indicate a value that will be used to increment/decrement the value property.  The RangeBase class also defines the ValueChanged event, which is fired when the Value property changes, and ensures all properties are correctly coerced (which I describe in more detail further down).

One of the main requirements for the new Slider was to be able to select a range of values (an upper and lower bound) rather than just a single value.  Since I still wanted to support everything else offered by RangeBase, I created DualRangeBase which inherits from it.  This became the base class for my version of the Slider control.

This new base class provides three additional properties:  LowerRangeValue, UpperRangeValue and  RangeValue.  LowerRangeValue and UpperRangeValueprovide the lower and upper values of the range (dictated by the position of the lower and upper thumbs repectively) while the RangeValue is the difference between the lower and upper values.  The DualRangeBase also adds three additional events:  LowerRangeValueChanged, UpperRangeValueChanged and RangeChanged.  The first two can be used if you want to handle the events separately while RangeChanged is fired any time either value changes.

The code snippet below shows the definitions of these properties.

// Defines the LowerRangeValue dependency property.
public static readonly DependencyProperty LowerRangeValueProperty = DependencyProperty.Register("LowerRangeValue", typeof(double), typeof(DualRangeBase), new PropertyMetadata(0.2d, OnLowerRangeValuePropertyChanged));

// Gets or sets the LowerRangeValue of the range.
public double LowerRangeValue
{
     get { return (double)GetValue(LowerRangeValueProperty); }
     set { SetValue(LowerRangeValueProperty, value); }
}

// Defines the UpperRangeValue dependency property.
public static readonly DependencyProperty UpperRangeValueProperty = DependencyProperty.Register("UpperRangeValue", typeof(double), typeof(DualRangeBase), new PropertyMetadata(0.8d, OnUpperRangeValuePropertyChanged));

// Gets or sets the UpperRangeValue of the range.
public double UpperRangeValue
{
     get { return (double)GetValue(UpperRangeValueProperty); }
     set { SetValue(UpperRangeValueProperty, value); }
}

///
/// Gets the size of the current range based on the difference
/// between the lower and upper range values.
///
public double RangeValue
{
    get { return UpperRangeValue - LowerRangeValue; }
}

The trickiest part of the base class, for me, was dealing with coercion.  I got the concept of this from the source code of the RangeBase class which uses coercion as well.  The concept of this is to ensure that when the value of any of the main properties (such as Maximum) is set it undergoes a set of validation checks.  If any of these checks fail the value is changed appropriately.  Coercion occurs during the properties PropertyChanged event handler.  For instance, the UpperRangeValue cannot be greater than the Maximum value.  If it is, the value is changed to equal Maximum.  You can imagine the trouble this can cause.  A single change to a value can cause a recursive loop of multiple changes.

This issue is at its worse when property values are being set during Design Time or the values are programmatically set within the code.  Let’s look at the previous example again and say that you want to set UpperRangeValue to 80.  Since we haven’t yet set Maximum to 100 (our target), the default value of 1 is used when the UpperRangeValue is coerced, which causes it to be set to 1 (the current value of Maximum).  Now you can see the difficulty I had ensuring the coercion between all the properties worked correctly to ensure the intended values got used.  I was able to overcome the issue (mentioned in the example) by coding the coercion process in a way that it remembered the intended value and attempts to use it when it can.  This means, in the example, after the Maximum is set to 100, the intended UpperRangeValue of 80 is applied.

In an attempt to understand this better, lets take a close look at the OnUpperRangeValuePropertyChanged method (which is called when the UpperRangeValue dependency property changes.

DualRangeBase dualRangeBase = d as DualRangeBase;

// Validate the provided UpperRangeValue.
if (!IsValidDoubleValue(e.NewValue))
{
    throw new ArgumentException("Invalid double value", UpperRangeValueProperty.ToString());
}

This beginning portion of the method simply creates an instance (since the method is static) of the DualRangeBase that called it and checks to ensure that the NewValue is valid.

// The code that follows is borrowed from the Microsoft code in RangeBase
// that performs the same actions on the Value property.  The trick here
// is to hold calls to the property changed methods until after all
// coercion has completed.
if (dualRangeBase.levelsFromUpperRootCall == 0)
{
    dualRangeBase.requestedUpperRangeValue = (double)e.NewValue;
    dualRangeBase.preCoersionUpperRangeValue = (double)e.NewValue;
    dualRangeBase.initialUpperRangeValue = (double)e.OldValue;
}
dualRangeBase.levelsFromUpperRootCall++;

This portion of the method saves the new value (requestedUpperRangeValue), the new value before it has been coerced (preCoersionUpperRangeValie) and the old value (initialUpperRangeValue).  These values are used later as part of the coercion testing.  If you remember from what I mentioned earlier, coercion can cause the value to be changed multiple times in an almost recursive manner.  levelsFromUpperRootCall is used to determine the current phase of this process.  I must thank Microsoft for this idea as it is how they did it and it works very well.

// Coerce values
dualRangeBase.CoerceUpperValue();

// This portion of the borrowed Microsoft code finally fires
// the change events once all coercion is confirmed complete.
dualRangeBase.levelsFromUpperRootCall--;
if (dualRangeBase.levelsFromUpperRootCall == 0)
{
    double value = dualRangeBase.UpperRangeValue;
    if (dualRangeBase.initialUpperRangeValue != value)
    {
        dualRangeBase.OnUpperRangeValueChanged(dualRangeBase.initialUpperRangeValue, value);
        dualRangeBase.OnRangeChanged(dualRangeBase.initialLowerRangeValue, dualRangeBase.LowerRangeValue, dualRangeBase.initialUpperRangeValue, value);
    }
}

The above code covers the last part of the method. First, the call to the coersion method is made. I talked about this a little bit already but the biggest thing to remember here is that the value being changed may actually be changed again during coersion. Once coersion has been completed, and the process has returned back to the initial call to the method, the OnUpperRangeValueChanged and OnRangeChanged events are fires.

That pretty much concludes the base class.  I know that might seem a bit confusing but you will understand my points if you step through the code once in Debug-mode.  All of the work that was put into the coercion functions allows the control to behave property when the properties are being set in the XAML in either Blend or the Visual Studio designer.  It also ensures only the appropriate values can be set.  I included a set of unit tests specifically for testing this and suggest you examine those in detail for further understanding.

This is part 1 of a multi-part article on a custom Slider control. You can find the other articles here:

• Overview
• The Base Class

The source code is now available on CodePlex.

As I promised, here is the initial post in a series that I plan on writing that covers the Slider control that I created for Berico Tailored Systems (BTS).  This is the control that I entered into the Silverlight Control Contest and that I blogged about earlier.

 This custom Slider came about because of an application (SnagL) that I have been working on for Berico Tailored Systems (BTS).  Several of the application’s requirements dictated the need for a slider with additional functionality, primary the ability to provide a range of values rather than just a single value.  My initial plan was to simply subclass the existing Microsoft Slider control and make the required changes to include the additional Thumb control.  I also decided to add handles at either end of the slider to make the control more standardizes (as most sliders have these handles for increasing and decreasing the value of the slider).  I quickly found out that I couldn’t do this by inheriting from the existing Slider control.  The root of the problem is in the UpdateTrackLayout method.  The purpose of this method is to appropriately layout the controls along the track as the slider is updated.  Some of the calculations used in this method use ActualWidth and ActualHeight, which refers to the width and height of the control itself and not just the track that the Thumb controls are on.  Adding the handles to the either end of the track changes the overall size of the control which causes the calculations to be off.  Since this method is marked as internal, it cannot be overridden by our class.  I was forced to create the updated Slider control from scratch.

Since I was starting from scratch I figured I would design the control from the ground up and look at what is available to sliders in other applications.  I will say from the start that much of the code that was used for the Microsoft slider was reused for this control, although it was greatly altered.  Here are the main requirements I decided on:

• Provide functionality to select a range
• Provide a way to switch from a regular slider to a range slider
• Provide an increase and decrease handle
• Provide a way to turn handles on and off
• Support all the standard slider functionality such as Orientation, IsDirectionReversed and IsEnabled
• Support styling and custom styles and templates
• Work with the Visual Studio IDE and Expression Blend
• Display tooltips over the Thumbs during dragging

Below is a sample Silverlight application that demonstrates this new Slider control.  Obviously, you will need the Silverlight plugin installed to be able to see it.

<Berico:Slider x:Name="TestH1" Style="{StaticResource FancySliderStyle}" IsEnabled="true" Grid.Column="1" Grid.Row="1" IsRangeEnabled="False" Value="5" />
<Berico:Slider x:Name="TestH2" Style="{StaticResource FancySliderStyle}" IsEnabled="true" Grid.Column="1" Grid.Row="2" IsRangeEnabled="True" />
<Berico:Slider x:Name="TestV1" IsEnabled="true" Grid.Column="2" Grid.Row="1" Grid.RowSpan="2" IsRangeEnabled="false" Value="5" Orientation="Vertical" />
<Berico:Slider x:Name="TestV2" IsEnabled="true" Grid.Column="3" Grid.Row="1" Grid.RowSpan="2" IsRangeEnabled="True" LowerRangeValue="2" UpperRangeValue="8" Orientation="Vertical" />

I finally got around to setting up a CodePlex project for the custom controls (including this Slider) that I have been working on. I will update it as often as I can.

BTS has a product called SnagL that is built on Silverlight 2.  I helped design the look of the application and created most of the controls that make up the user interface.  Marc Schweigert of Microsoft even conducted an interview with us about the product.  I have been very pleased with Silverlight and in how well some of the controls I worked on turned out.  While many of the controls are specific to SnagL, a few other controls are more general and usable by other applications so I broke those off into their own namespace.  This namespace contains the controls that I was curious about entering into the contest.

I decided, on a whim, to discuss the issue with BTS.  They were more then happy to embrace the idea and provided me permission to release these controls  as open source (under the Ms-PL license).  After some discussions and some research I got the official go ahead to release the source code as open source.

This leads me up to last night, when that final approval came through.  I selected the custom Slider control and created a new project to just include it.  I then submitted this control to the Silverlight Contest, which you can find here.  The contest ends on September 19th and I am excited about it.  Not only do I have a chance to win some great prizes but I am more than happy to share my custom Slider with the Silverlight community.

Aside from the contest, I hope to start a CodePlex project to host the custom control library.  I also plan on writing a series of detailed blogs on how I created each control (starting with the Slider).  Look for those soon.

I just wanted to update this article and mention that the winners for the control contest were announced and my Slider control was, unfortunately, not picked. I guess it just wasn’t flashy enough. I do hope  that it is, at the very least, helping someone else out in IT land.  I have started on that series of article that detail the Slider control and I have posted a project for it (and other custom controls) on CodePlex.

I could log into the computer fine and her files were fine.  Some applications would work (those that did not rely on any network connectivity) but everything was very sluggish and just wasn’t right.  Something was tragically wrong with her computer.  I begin to go through my diagnosing steps.  I discovered that the DHCP (Dynamic Host Configuration Protocol) and SENS (System Event Notification Service) services were hung in the Starting state.  Since many other services depend on these two I was unable to get any network connectivity and I couldn’t even check the Event Log for any clues.

I tried all the standard network tricks (IPCONFIG, Using a static IP, PINGing) but nothing worked.  All commands returned errors.  It appeared that the network was simply dead which caused the entire system to suffer.  I used another computer to do some searching and found hundreds of posts related to the same issue.  As with most google searches, finding the posts is easy but answers are usually harder to come by.

Last night I stumled on a post that simply mentioned a single command to try:  netsh winsock reset.  There was no explanation, just a note saying to try it.  At that point I was already in the process of trying to backup my wife’s data so I could reinstall the OS (most likely Windows 7 RC, rather than Vista again).  I figured I had nothing to lose so I ran the command.  It appeared to run and told me to restart.  I restarted the computer and swore I heard the computer sigh deeply as it booted back up.  I logged in and everything was working fine.

Amazed I tried to find details on the command.  I couldn’t find anything that detailed exactly what it does but the concept is that it resets Winsock back to its default settings.  Obvisouly something internal to Winsock got confused or garbled during one of the power outages and the reset refreshed everything.  I was able to find a Microsoft KB article that talks about the issue (although it doesn’t mention the DHCP and SENS services being hung).

I am just happy, as is my wife, that I got the system back up and running.  Now I can wait until the full version of Windows 7 is released to upgrade her computer to a MUCH more stable operating system.