Jamie Dixon's Home

WPF and Images In Subdirectories

September 17, 2013 Leave a comment

Dear Jamie of the future:

When you have a WPF project and you want to add images in a subfolder to a page, you need to do this:

Image x:Name="TestImage" Source="/Images/TestImage.png">

Note the forward slashes.

Also, if you have two images and you change the location on both, you will get the blue squiggly line of approbation like this:

If you fix the first one, BOTH will still have the BSLA:

So it looks to be all or none – perhaps b/c the IDE can’t parse anything so it leaves the last BSLA in place? In any event, fix all of them and the BSLA goes away.

Sincerely,

Jamie of the past

PS: you really should exercise more….

Filed under WPF

MVVM on a Windows Store App

September 10, 2013 Leave a comment

I blog for a couple of reasons:

Professionalism – to think and write about a topic at least once a week
Marketability – when I talk to people about jobs, I can point them to my blog to see how I code (and think about coding). To me, it is much more effective and insightful than a exam or esoteric interview questions
To keep track of stuff for me - I write stuff down so I don’t have to remember something.

That last point came back to me today. I wanted to take a break from F# so I looked at MVVM in a Windows RT application. I went to refresh my brain on MVVM so I hit up Bing and Google. All of the recent articles that I ran across talked about MVVM –as an after thought. They were all pimping MVVM helpers like relay command, frameworks like MVVMLight, and other non-core MVVM concepts. All important to be sure, but non related to MVVM.

I then hit up my own blog and sure enough – I blogged about MVVM 2 years ago when I did a Windows Phone 7 app and I could see just the MVVM in action. So then I fired up a basic Windows RT application and added 3 folders to it: Models, Views, and ViewModels.

I then added a Model like so:

public class Person
{
    public Int32 Id { get; set; }
    public String FirstName { get; set; }
    public String LastName { get; set; }
}

I then added a View Model

public class PersonViewModel: INotifyPropertyChanged
{
    private Person _person = null;
    public event PropertyChangedEventHandler PropertyChanged;
 
    public PersonViewModel(Person person)
    {
        _person = person;
    }
 
    public Int32 Id
    {
        get { return _person.Id; }
        set 
        {
            PropertyChanged(this, new PropertyChangedEventArgs("Id"));
            _person.Id = value; 
        }
    }
    public String FirstName
    {
        get { return _person.FirstName; }
        set
        {
            PropertyChanged(this, new PropertyChangedEventArgs("FirstName"));
            _person.FirstName = value;
        }
    }
    public String LastName
    {
        get { return _person.LastName; }
        set
        {
            PropertyChanged(this, new PropertyChangedEventArgs("LastName"));
            _person.LastName = value;
        }
    }
 
}

I then added a View like so:

and then in the code behind of the View:

public PersonView(PersonViewModel viewModel)
{
    InitializeComponent();
    this.mainGrid.DataContext = viewModel;
}

Then in the main page, the ViewModel is injected into the View:

public partial class MainWindow : Window
{
    public MainWindow()
    {
        InitializeComponent();
        Person person = new Person(){Id=0,FirstName="Test",LastName="Person"};
        PersonViewModel viewModel = new PersonViewModel(person);
        PersonView view = new PersonView(viewModel);
        view.Show();
    }
}

And we have data binding:

Now I know this is not a complete project and that many patterns are helpful (esp. the relay command one), but this is the core of making MVVM work the MSFT way: data binding and IPropertyNotifyChanged.

Filed under MVVM, Windows RT

Multiple Linear Regression Using R and F#

September 3, 2013 Leave a comment

Following up on my previous post, I decided to test calling R from F# for a multiple linear regression. I decided to use the dataset from chapter 1 of Machine Learning For Hackers (ufo sightings).

Step #1 was to open R from F#

#r @"C:\TFS\Tff.RDotNetExample_Solution\packages\R.NET.1.5.3\lib\net40\RDotNet.dll"
#r @"C:\TFS\Tff.RDotNetExample_Solution\packages\R.NET.1.5.3\lib\net40\RDotNet.NativeLibrary.dll"
 
open System.IO
open RDotNet
 
 
//open R
let environmentPath = System.Environment.GetEnvironmentVariable("PATH")
let binaryPath = @"C:\Program Files\R\R-3.0.1\bin\x64"
System.Environment.SetEnvironmentVariable("PATH",environmentPath+System.IO.Path.PathSeparator.ToString()+binaryPath)
 
let engine = RDotNet.REngine.CreateInstance("RDotNet")
engine.Initialize()

Step #2 was to import the ufo dataset and clean it:

//open dataset
let path = @"C:\TFS\Tff.RDotNetExample_Solution\Tff.RDotNetExample\ufo_awesome.txt"
let fileStream = new FileStream(path,FileMode.Open,FileAccess.Read)
let streamReader = new StreamReader(fileStream)
let contents = streamReader.ReadToEnd()
let usStates = [|"AL";"AK";"AZ";"AR";"CA";"CO";"CT";"DE";"DC";"FL";"GA";"HI";"ID";"IL";"IN";"IA";
                    "KS";"KY";"LA";"ME";"MD";"MA";"MI";"MN";"MS";"MO";"MT";"NE";"NV";"NH";"NJ";"NM";
                    "NY";"NC";"ND";"OH";"OK";"OR";"PA";"RI";"SC";"SD";"TN";"TX";"UT";"VT";"VA";"WA";
                    "WV";"WI";"WY"|]
let cleanContents =
    contents.Split([|'\n'|])
    |> Seq.map(fun line -> line.Split([|'\t'|]))
    |> Seq.filter(fun values -> values |> Seq.length = 6)
    |> Seq.filter(fun values -> values.[0].Length = 8)
    |> Seq.filter(fun values -> values.[1].Length = 8)
    |> Seq.filter(fun values -> System.Int32.Parse(values.[0].Substring(0,4)) > 1900)
    |> Seq.filter(fun values -> System.Int32.Parse(values.[1].Substring(0,4)) > 1900)
    |> Seq.filter(fun values -> System.Int32.Parse(values.[0].Substring(0,4)) < 2100)
    |> Seq.filter(fun values -> System.Int32.Parse(values.[1].Substring(0,4)) < 2100)
    |> Seq.filter(fun values -> System.Int32.Parse(values.[0].Substring(4,2)) > 0)
    |> Seq.filter(fun values -> System.Int32.Parse(values.[1].Substring(4,2)) > 0)
    |> Seq.filter(fun values -> System.Int32.Parse(values.[0].Substring(4,2)) <= 12)
    |> Seq.filter(fun values -> System.Int32.Parse(values.[1].Substring(4,2)) <= 12)      
    |> Seq.filter(fun values -> System.Int32.Parse(values.[0].Substring(6,2)) > 0)
    |> Seq.filter(fun values -> System.Int32.Parse(values.[1].Substring(6,2)) > 0)
    |> Seq.filter(fun values -> System.Int32.Parse(values.[0].Substring(6,2)) <= 31)
    |> Seq.filter(fun values -> System.Int32.Parse(values.[1].Substring(6,2)) <= 31)
    |> Seq.filter(fun values -> values.[2].Split(',').[1].Trim().Length = 2)
    |> Seq.filter(fun values -> Seq.exists(fun elem -> elem = values.[2].Split(',').[1].Trim().ToUpperInvariant()) usStates)
    |> Seq.map(fun values -> 
        System.DateTime.ParseExact(values.[0],"yyyymmdd",System.Globalization.CultureInfo.InvariantCulture),
        System.DateTime.ParseExact(values.[1],"yyyymmdd",System.Globalization.CultureInfo.InvariantCulture),
        values.[2].Split(',').[0].Trim(),
        values.[2].Split(',').[1].Trim().ToUpperInvariant(),
        values.[3],
        values.[4],
        values.[5])
cleanContents
 
let relevantContents =
    cleanContents
    |> Seq.map(fun (a,b,c,d,e,f,g) -> a.Year,d,g.Length)

Step #3 was to run the regression using the dataset. You will notice that I made the length of the report the Y (dependent) variable – not that I think I will find any causality but it was a good enough to use). Also, notice the Seq.Map of each column in the larger Seq(Int*String*Int) into the Vector.

let reportLength = engine.CreateIntegerVector(relevantContents |> Seq.map (fun (a,b,c) -> c))
engine.SetSymbol("reportLength", reportLength)
let year = engine.CreateIntegerVector(relevantContents |> Seq.map (fun (a,b,c) -> a))
engine.SetSymbol("year", year)
let state = engine.CreateCharacterVector(relevantContents |> Seq.map (fun (a,b,c) -> b))
engine.SetSymbol("state", state)
 
let calcExpression = "lm(formula = reportLength ~ year + state)"
let testResult = engine.Evaluate(calcExpression).AsList()

Sure enough, you can get the results of the regression. The challenge is teasing out the values that are interesting from the real data structure that is returned (testResult in this example)

> testResult.Item(0).AsCharacter();;
val it : CharacterVector =
seq
["31775.5599180962"; "-15.2760355122386"; "37.8028841898059";
"-91.2309146099364"; …]

Intercepts, I think, are Item(0).

Filed under F#, R

RDotNet and F#: Example from the Code Project

September 3, 2013 1 Comment

I added the R type provider via NuGet and it showed up in my references tab:

When I go to reference the library in code:

But if I fully-qualify the reference, it works:

Very Strange, but then I get yummy intellisense

I then wanted to add in the RDotNet assembly:

Filly qualified does not work

but if you add the “@” symbol, it does…

I then added the test case that is on codeplex(https://rdotnet.codeplex.com/).

After figuring out that your can only have 1 instance of the engine going at any point in time and the FSI holds a reference (my issue logged here), I wrote this very much procedural code:

#r @"C:\TFS\Tff.RDotNetExample_Solution\packages\R.NET.1.5.3\lib\net40\RDotNet.dll"
#r @"C:\TFS\Tff.RDotNetExample_Solution\packages\R.NET.1.5.3\lib\net40\RDotNet.NativeLibrary.dll"
 
open System.IO
open RDotNet
 
let environmentPath = System.Environment.GetEnvironmentVariable("PATH")
let binaryPath = @"C:\Program Files\R\R-3.0.1\bin\x64"
System.Environment.SetEnvironmentVariable("PATH",environmentPath+System.IO.Path.PathSeparator.ToString()+binaryPath)
 
let engine = RDotNet.REngine.CreateInstance("RDotNet")
engine.Initialize()
 
let group1 = engine.CreateNumericVector([30.02;29.99;30.11;29.97;30.01;29.99]);
engine.SetSymbol("group1", group1)
let expression = "group2 <- c(29.89,29.93,29.72,29.98,30.02,29.98)"
let group2 = engine.Evaluate(expression).AsNumeric()
 
let calcExpression = "t.test(group1, group2)"
let testResult = engine.Evaluate(calcExpression).AsList()
 
printfn "P-Value = %A" (testResult.Item("p.value").AsNumeric())

With the results coming out:

Filed under F#, R

Calling R from F#

August 27, 2013 Leave a comment

So I thought I would check out R.NET so I downloaded R from its home site. I then created a basic F# library and installed R.DotNet. I found it amusing that it installed from the recycle bin:

I then fired up a F# project to test it out. I decided to mimic the C# example on the Codeplex site in F#. I gopt to the 4th line where I actually tried to create an instance of the REngine:

So I typed into Google R and F# and what do you know, some folks created a type provider for R How cool is that? I installed the RProvider from NuGet and then typed in the basic code sample but it was not getting recognized.

I then read in the documentation that you need to restart Visual Studio (good to know) and make sure that the .NET version is 4.5. Still no luck. I then downloaded the example script that is on Github and I was getting the same problem. Out of desperation, I hit F6 and I got this:

Then all of the R type provider references resolved. I then changed the R.Net to point at the bin and all of those references resolved. I then commented out

//open RProvider.tseries
//open RProvider.zoo

and

//let adf = R.adf_test(msft) 

and no more red squiqqley! When I hit F6 though, I get this:

Undaunted, I ran the script anyway and sure enough, I got some output:

Filed under F#, R

F# and Unit Testing

August 20, 2013 Leave a comment

Consider this code snippet in F#

module Board = 
    let tiles = [|0 .. 39|]
    let random = System.Random()
 
    let communityChest x = 
        let communityChestDraw = random.Next(1,17)
        if communityChestDraw = 1 then
            0
        else if communityChestDraw = 2 then
            10
         else
            x

I then went to create a unit test for the communityChest function when it hit me that I will get unpredictable behavior because I am getting a random number within the method body. I made this same mistake when I created my windows phone 7 game where there combat engine was using a Random.Next() result.

Basically, I am repeating my mistakes across two languages. The good news is that the solution is the same for both languages: I need to inject the result from Random.Next() into community chest.

let communityChest x y = 
    if y = 1 then
        0
    else if y = 2 then
        10
     else
        x

And then

let move x y =
    let communityChestDraw = random.Next(1,17)
 
    if x + y > 39 then
        x + y – 40
    else if x + y = 30 then
        10
    else if x + y = 2 then
        communityChest 2 communityChestDraw
    else if x + y = 7 then
        chance 7
    else if x + y = 17 then
        communityChest 2 communityChestDraw
    else if x + y = 22 then
        chance 22
    else if x + y = 33 then
        communityChest 2 communityChestDraw
    else if x + y = 36 then
        chance 36
    else
        x + y

The other nice thing is I found the bug that was, well, bugging me. The reason that 2 showed up the most was that I had copied and pasted 2 to be the results of all community chest runs. I then changed the code to reflect the actual position of community chest:

let move x y =
    let communityChestDraw = random.Next(1,17)
 
    if x + y > 39 then
        x + y – 40
    else if x + y = 30 then
        10
    else if x + y = 2 then
        communityChest 2 communityChestDraw
    else if x + y = 7 then
        chance 7
    else if x + y = 17 then
        communityChest 17 communityChestDraw
    else if x + y = 22 then
        chance 22
    else if x + y = 33 then
        communityChest 33 communityChestDraw
    else if x + y = 36 then
        chance 36
    else
        x + y

So now I can do my unit tests:

[TestClass]
public class SimulatorTests
{
    [TestMethod]
    public void communityChestWithOne_ReturnsZero()
    {
        var result = Simulator.communityChest(2, 1);
        Assert.AreEqual(0, result);
    }
 
    [TestMethod]
    public void communityChestWithTwo_ReturnsTen()
    {
        var result = Simulator.communityChest(2, 2);
        Assert.AreEqual(10, result);
    }
 
    [TestMethod]
    public void communityChestWithThree_ReturnsTwo()
    {
        var result = Simulator.communityChest(2, 3);
        Assert.AreEqual(2, result);
    }
}

And the tests run green:

I love being able to write C# tests and test F# code…

Filed under F#, Unit Testing || Mocking

F# and Monopoly Probabilities

August 13, 2013 Leave a comment

My sons and I were playing Monopoly when we started discussing different strategies for property acquisition. For example, should you try and get Park Place and Boardwalk for the large rent but low probability of someone landing on it or should you get the purples with a high hit chance but lower payout?

We decided to run a simulation and since I an teaching myself F#, we coded up a F# answer. I created a F# Tutorial project and then added a .fsx file. In that file, I first created a couple of variables – 1 of which is a .NET type:

let tiles = [|0 .. 39|]
let random = System.Random()

I then added a Community Chest function that returns a 1 in 16 chance of Going to Jail (board location 10) and a 1 in 16 chance of going to GO (board location 0). This is not completely accurate because we don’t shuffle the deck after every draw – but it seems close enough.

let communityChest x = 
    let communityChestDraw = random.Next(1,17)
    if communityChestDraw = 1 then
        0
    else if communityChestDraw = 2 then
        10
     else
        x

I then added a Chance function that did the same thing – with a lot more possibilities (Go to Boardwalk, go to the nearest railroad, etc…)

let chance x =
    let chanceDraw = random.Next(1,17)
    if chanceDraw = 1 then
        0
    else if chanceDraw = 2 then
        10
    else if chanceDraw = 3 then
        11
    else if chanceDraw = 4 then
        39
    else if chanceDraw = 5 then
        x – 3
    else if chanceDraw = 6 then
        5
    else if chanceDraw = 7 then
        24
    else if chanceDraw = 8 then
        if x < 5 then
            5
        else if x < 15 then
            15
        else if x < 25 then
            25
        else if x < 35 then
            35
        else
            5
    else if chanceDraw = 9 then
        if x < 12 then
            12
        else if x < 28 then
            28
        else
            12
    else
        x    

I then added a move function that handled going past the 39th tile and looping around past go and also the “Go to Jail” Tile:

let move x y =
    if x + y > 39 then
        x + y – 40
    else if x + y = 30 then
        10
    else if x + y = 2 then
        communityChest 2
    else if x + y = 7 then
        chance 7
    else if x + y = 17 then
        communityChest 2
    else if x + y = 22 then
        chance 22
    else if x + y = 33 then
        communityChest 2
    else if x + y = 36 then
        chance 36
    else
        x + y

I then put it together with a simulation function that ran 10000 iterations:

let simulation = 
    let mutable startingTile = 0
    let mutable endingTile = 0
    let mutable doublesCount = 0
    let mutable inJail = false
    let mutable jailRolls = 0
    for diceRoll in 1 .. 10000 do
        let dieOneValue = random.Next(1,7)
        let dieTwoValue = random.Next(1,7)
        let numberOfMoves = dieOneValue + dieTwoValue
        
        if dieOneValue = dieTwoValue then
            doublesCount <- doublesCount + 1
        else
            doublesCount <- 0
 
        if inJail = true then
            if doublesCount > 1 then
                inJail <- false
                jailRolls <- 0
                endingTile <- move 10 numberOfMoves
            else
                if jailRolls = 3 then
                    inJail <- false
                    jailRolls <- 0
                    endingTile <- move 10 numberOfMoves
                else
                    inJail <- true
                    jailRolls <- jailRolls + 1
        else
            if doublesCount = 3 then
                inJail <- true
                endingTile <- 10
            else
                endingTile <- move startingTile numberOfMoves
        
        let endingTile = move startingTile numberOfMoves
 
        printfn "die1: %A + die2: %A = %A FROM %A TO %A" 
            dieOneValue dieTwoValue numberOfMoves startingTile endingTile
 
        startingTile <- endingTile
        tiles.[endingTile] <- tiles.[endingTile] + 1

I hate the mutable keywords. I don’t know enough about F# to not use it – but it seems that my code is a F# plate of spaghetti

I then spit out the results like this:

let Aggregation =
    for tile in tiles do 
        printfn "%A" tile

And sure enough, I got some results:

I then put these results into Excel where I added the tile names

and did a quick pivot table on property groups like this:

Note that the results seem wrong (or not 100% correct) because Tile #2 (Community Chest) can’t be the most landed on tile and I also had 30 out of the 10,000 times where the cop was the final resting place for a turn – which can’t happen.

If I was using C#, I would have done this in about 25% of the time and been 100% right using unit tests – but I am trying to make myself uncomfortable by learning F# and so I muddle through – often I find that the process is more important than the results in learning.

In any event, I want to make the following changes:

1) Create a tuple using the Tile Name, the PropertyGroup, and the Count
2) Write the unit tests so that I am 100% correct
3) Re-write it getting rid of the mutable keyword
4) Aggregate the list using the F# constrcuts (versus using Excel)

The kids also want to put in the expected rate of return based on the rent for each tile and then the adjustment for each house. That might be fun – but it is irrelevant for actually winning the game (the marginal benefit of additional analysis is very low). As long as you know they key colors and can get monopolies on them (and prevent monopolies by your opponent), you will win more often than not.

Filed under F#

Infer.NET

August 6, 2013 Leave a comment

I was on vacation last week so I decided to have some fun with Infer.Net. As someone interested in F#/Machine learning, Infer.Net seemed like a cool side project. I was not disappointed. I downloaded the most recent bits (though no NuGet) and wired up a basic problem of determining the probability of 2 even-sided coins to both come up heads:

Console.WriteLine("Start");
 
Variable<bool> firstCoin = Variable.Bernoulli(0.5);
Variable<bool> secondCoin = Variable.Bernoulli(0.5);
Variable<bool> bothHeads = firstCoin & secondCoin;
 
InferenceEngine engine = new InferenceEngine();
Console.WriteLine("Probability both coins are heads: " + engine.Infer(bothHeads));
 
Console.WriteLine("End");
Console.ReadKey();

Sure enough:

I can’t wait to dig into the other tutorials and then apply the inference to some of the real data sets I have collected…

Filed under Machine Learning

Pluralsight

July 23, 2013 1 Comment

Or is it Pluralsite? They seem to use both. In any event, I finished an audition for Pluralsight yesterday. It was a 10 minute demo of slides and code. It was a really interesting process and makes me appreciate what it takes to do it. Lesson learned include:

1) Script the slide deck – down to the pauses for breathing. I first tried to do it without any help – epic failure. I then tried to do it with bullet points – failure. After about an hour of takes and re-takes of the first slide, I surrendered and scripted everything. I then could get through the slide deck in about 5 takes per slide.

2) Everything is editable. In the beginning, once I screwed up, I would stop and restart. Then, I realized that I was re-recoding my good content so I started to place a break after my screw up, re-record and then edit out the the screw-up. I learned that to do this effectively, I need splice points that don’t look like splice points so I can screw up without losing the good stuff.

3) Speaking of which, I spent waaaay too much time in Camtasia, the video editing software. Just learning how to use that took a better part of my Sunday. Once I figured it out some, it was great to use.

4) I did the code in about 6 takes – and it shows. I did not script my code, instead I treated it more like the classes I teach with the occasional flub and mistyping (And I technical error that Rob Seder sent me). I also typed my code versus drag and dropping code blocks (or using code snippets). I talked to different people and each have a different option on this – I find presentations more interesting with typing, even if it is not as smooth as a professional typist. Some people like the typing (you can really hear my mechanical keyboard in the video), others do not. Derik Whittaker was kind enough to do a full-on, no holds-barred review of what I did suggested in speeding up time for the longer typing moments – which I didn’t even think of.

5) Speaking of Derik, he has done a couple of courses and he showed me how to prepare for a course. If I get picked up, I will implement much of his methodology. Basically, you can’t be too organized for teaching a Pluralsight course. Derik has a 3 monitor setup when recording and he scripts everything in one-note. He also does much of his effects in editing, so he is not concentrating on that stuff when recording.

6) Speaking of getting picked up, there is a TON of content in the pipeline. I am pitching .NET best practices and there are several other courses that have some overlap (some already in prod) so I am curious that if the course gets green-lighted, how many people will actually watch it.

In any event, it was an interesting process and since I learned something, it was worth it. If I get picked up, I will take a hiatus from blogging because my free time will be spent on that. Seems like a worthwhile adventure, no?

Filed under Pluralsight

WPF Event Bubbling and Routed Events

July 16, 2013 Leave a comment

Consider a User Control with a single button on it:

<UserControl x:Class="Tff.ButtonClickBubble.MainUserControl"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation&quot;
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml&quot;
             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006&quot; 
             xmlns:d="http://schemas.microsoft.com/expression/blend/2008&quot; 
             mc:Ignorable="d" Height="100" Width="100">
    <Grid Background="Red" Margin="0,0,0,0">
        <Button x:Name="MainButton" 
            Content="Push Me" HorizontalAlignment="Left" 
                Margin="19,36,0,0" VerticalAlignment="Top" 
                Width="62" Height="25"
                Click="MainButton_Click"/>
    </Grid>
</UserControl>

In the code behind, the click event shows a dialog

public partial class MainUserControl : UserControl
{
    public MainUserControl()
    {
        InitializeComponent();
    }
 
    private void MainButton_Click(object sender, RoutedEventArgs e)
    {
        MessageBox.Show(e.Source.ToString());
    }
}

After hitting F6 so the control will show in my toolbox, I then put an instance of that control on a basic page like so:

<Window
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation&quot;
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml&quot;
        xmlns:local="clr-namespace:Tff.ButtonClickBubble" x:Class="Tff.ButtonClickBubble.MainWindow"
        Title="MainWindow" Height="236" Width="184">
    <Grid x:Name="MainGrid" Background="AliceBlue">
        <local:MainUserControl HorizontalAlignment="Left" Margin="35,44,0,0" VerticalAlignment="Top"/>
    </Grid>
</Window>

When I hit F5, I get the expected MessageBox:

So now I want the main window to intercept that button click and pop its own dialog box. The Window class does not have a click event – rather it has a mousedown event. By adding the mouse down event hander to the main window, I have this:

<Window
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation&quot;
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml&quot;
        xmlns:local="clr-namespace:Tff.ButtonClickBubble" x:Class="Tff.ButtonClickBubble.MainWindow"
        Title="MainWindow" Height="236" Width="184" MouseDown="Window_MouseDown">

And in the code behind:

private void Window_MouseDown(object sender, MouseButtonEventArgs e)
{
    MessageBox.Show(e.Source.ToString());
}

Unfortunately, that doesn’t work. The button click event swallows the event so the MouseDown only fires on the part of the window where the button is not:

So I went into StackOverflow and I found this post that I think describes the problem. So I changed the MouseDown to the PreviewMouseDown event and sure enough, I can handle the event from the main screen:

But the ClickEvent on the button is not being fired. I then added a e.handled = false but that did not help:

private void Window_PreviewMouseDown(object sender, MouseButtonEventArgs e)
{
    MessageBox.Show(e.Source.ToString());
    e.Handled = false;
}

So the answer marked as correct on stack overflow does apply here. The answer below the marked as correct answer is relevant. I tried to add a handler to the Grid (Windows don’t have AddHandler methods) like this:

public MainWindow()
{
    InitializeComponent();
    MainGrid.AddHandler(MouseDownEvent, new MouseButtonEventHandler(MainGrid_MouseDown), true);
}
 
private void MainGrid_MouseDown(object sender, MouseButtonEventArgs e)
{
    MessageBox.Show(e.Source.ToString());
}

The problem is that it is not working either. Fortunately, the answer below THAT one does work:

<Window
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation&quot;
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml&quot;
        xmlns:local="clr-namespace:Tff.ButtonClickBubble" x:Class="Tff.ButtonClickBubble.MainWindow"
        Title="MainWindow" Height="236" Width="184" >
    <Grid x:Name="MainGrid" Background="AliceBlue" Button.Click="MainGrid_MouseDown">
        <local:MainUserControl HorizontalAlignment="Left" Margin="35,44,0,0" VerticalAlignment="Top"/>
    </Grid>
</Window>

And

public partial class MainWindow : Window
{
    public MainWindow()
    {
        InitializeComponent();
    }
 
    private void MainGrid_MouseDown(object sender, RoutedEventArgs e)
    {
        MessageBox.Show(e.Source.ToString());
    }
 
}

They key thing is wiring up the Grid like this: Button.Click="MainGrid_MouseDown"

Filed under WPF

← Older posts

Newer posts →

Jamie Dixon's Home

WPF and Images In Subdirectories

MVVM on a Windows Store App

Multiple Linear Regression Using R and F#

RDotNet and F#: Example from the Code Project

Calling R from F#

F# and Unit Testing

F# and Monopoly Probabilities

Infer.NET

Pluralsight

WPF Event Bubbling and Routed Events

Categories

Recent Posts

Archives

Blogroll

Meta