WPF Discussion Boards

23-Mar-09 11:08

I am using .Net 3.5 and WPF.

I've got a list box that needs to draw text in one of three ways, depending on some criteria. In the process of trying to make this work (which it still doesn't), I've got this question:

When I do this:

private void listboxWords_LayoutUpdated(object sender, EventArgs e)
{
    ListBox listbox = sender as ListBox;
}

...both of the method parameters are null. Why?

"Why don't you tie a kerosene-soaked rag around your ankles so the ants won't climb up and eat your candy ass..." - Dale Earnhardt, 1997
-----
"...the staggering layers of obscenity in your statement make it a work of art on so many levels." - Jason Jystad, 10/26/2001

Christian Graus23-Mar-09 15:20

Christian Graus

23-Mar-09 15:20

The way to owner draw is to have a number of derived classes for styles and then to set the style in XAML. As for your event, I have no idea, but I do believe that's the wrong time to be trying to change how things look.

Christian Graus

Driven to the arms of OSX by Vista.

#realJSOP23-Mar-09 23:21

23-Mar-09 23:21

Well, I googled the helll out of it before posting my question, and that's how everyone seems to be doing it. I hate WPF.

ABitSmart23-Mar-09 17:28

ABitSmart

23-Mar-09 17:28

LayoutUpdated is a static event. It is fired on layout change of any element in the element tree. It's by design that no parameters are passed to it. That's how it is. Link[^]

For your case, you might want you have a trigger (if the criteria is a property value) or an ItemTemplateSelector[^] (if the criteria is a type)

#realJSOP23-Mar-09 23:20

23-Mar-09 23:20

ABitSmart wrote:
It's by design that no parameters are passed to it.

Then why the frak does the method have parameters? (just a rhetorical question meant to indicate a certain level of anger and frustration - you don't need to answer it).

Pete O'Hanlon24-Mar-09 1:30

24-Mar-09 1:30

John - why not use something like this[^]? It's simple and much more effective.

"WPF has many lovers. It's a veritable porn star!" - Josh Smith

As Braveheart once said, "You can take our freedom but you'll never take our Hobnobs!" - Martin Hughes.

#realJSOP24-Mar-09 2:55

24-Mar-09 2:55

Pardon my abruptness, but I've pretty much reached the end of my rope where WPF is concerned, so...

-------------

Because I didn't frakking know about templates, and there's really nothing I can find that presents the information COMPLETELY. All of the examples I've found assume I want to put frakking pictures in a listbox. I simply have strings thatI want to apply visual styles to based on certain criteria that I establish.

In WinForms, this took about 15 lines of code inside an event handler, and took me 20 minutes to figure out how to do. For WPF, it appears I have to write HUNDREDS of lines of code/XAML to do the same frakking thing, and I'v been trying to find a way to do it for TWO DAYS now! How the frak is this "better" than WinForms? Half-assed tools, requires twice the work on my part, and no frakking support from the anal pores that dreamed this steaming pile of horseshit up in the first place.

All I see is a bunch of half-brained ass-kissers running around with little WPF erections because they got it in their heads that this is somehow the end-all be-all of coding.

-------------

...even after that rant, I don't feel the slightest bit better. I'm just thoroughly pissed off.

I'm now off to look at the link you provided, but I'm really not confident that it will answer my questions nor provide even half of a solution.

I'm trying to convert my anagrams article to WPF. The Listbox is not bound to a collection. It accepts manually entered strings which are displayed in black (the default control color). When the user clicks a button, the strings that were already in the listbox are displayed in red, and all other possible strings are added and displayed in dark gray italics.

I'm not looking someone to code this for me - I just want to know how it's supposed to be done.

Pete O'Hanlon24-Mar-09 3:24

24-Mar-09 3:24

Well, I'm glad I gave you the chance to vent. Poke tongue | ;-P

When I started with WPF, I had pretty much the same reaction as you - it's taken me a long time to get to the point where it's second nature to me, and I know that it can be a pain.

Thing is though - if you stick with it, parts do fall into place - but you have to want to work with WPF in order to put that time in. If you don't want to work with it, don't - there are plenty of alternatives that don't require you to go through the "pain barrier".

"WPF has many lovers. It's a veritable porn star!" - Josh Smith

As Braveheart once said, "You can take our freedom but you'll never take our Hobnobs!" - Martin Hughes.

#realJSOP24-Mar-09 3:56

24-Mar-09 3:56

I guess the worst part is that I'm alone in my dissatisfaction with WPF here at work. Every time I run into something like this, it just pisses me off even more that we're even using WPF.

Pete O'Hanlon24-Mar-09 5:37

24-Mar-09 5:37

John - here's a simple application that you can use to test this type of functionality. I've added an ObservableCollection which consists of words that the user adds in via a textbox.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections.ObjectModel;
using System.Windows.Controls;
using System.Windows;

namespace SampleWpfApplication
{
  public class WordManager
  {
    public string Text { get; set; }
  }

  public class Words : ObservableCollection<WordManager>
  {
  }

  public class WordTemplateSelector : DataTemplateSelector
  {
    public DataTemplate NormalWordTemplate { get; set; }
    public DataTemplate RedWordTemplate { get; set; }

    public override DataTemplate SelectTemplate(object item, DependencyObject container)
    {
      WordManager word = item as WordManager;
      if (word.Text == "Howdy")
      {
        return RedWordTemplate;
      }
      else
      {
        return NormalWordTemplate;
      }
    }
  }
}

Here's the XAML that's used:

<Window x:Class="SampleWpfApplication.Window1"
  xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="clr-namespace:SampleWpfApplication"
  Title="Window1" Height="300" Width="300">
  <Window.Resources>
    <DataTemplate x:Key="NormalWords">
      <Grid>
        <TextBlock Text="{Binding Path=Text}" Foreground="Brown"/>
      </Grid>
    </DataTemplate>

    <DataTemplate x:Key="RedWords">
      <TextBlock Text="{Binding Path=Text}" FontWeight="Bold" Foreground="Red"/>
    </DataTemplate>
    
    <local:Words x:Key="Words" />
    <local:WordTemplateSelector 
      x:Key="TemplateSelector" 
      NormalWordTemplate="{StaticResource NormalWords}"
      RedWordTemplate="{StaticResource RedWords}" />
  </Window.Resources>

  <StackPanel>
    <ListBox x:Name="myList" 
         ItemsSource="{Binding Mode=Default, Source={StaticResource Words}}" 
         ItemTemplateSelector="{StaticResource TemplateSelector}"
         x:FieldModifier="private"></ListBox>
    <TextBox x:Name="myText" x:FieldModifier="private" Width="30" />
    <Button Content="Click" Click="Button_Click" />
  </StackPanel>
</Window>

Finally, here's the button click code:

private void Button_Click(object sender, RoutedEventArgs e)
{
  if (!string.IsNullOrEmpty(myText.Text))
  {
    Words words = this.Resources["Words"] as Words;
    if (words != null)
    {
        words.Add(new WordManager{Text=myText.Text});
    }
  }
}

Basically the XAML is set up so that there can be multiple templates, which get applied based on certain conditions - chosen by the WordTemplateSelector class. By providing a template selector class, it's possible to add as many conditions as you like - all of which can have a simple template. The beauty of the approach here, is that we're using an ObservableCollection so that the template gets reevaluated whenever an item is added in. If you need more information, please feel free to ask.

"WPF has many lovers. It's a veritable porn star!" - Josh Smith

As Braveheart once said, "You can take our freedom but you'll never take our Hobnobs!" - Martin Hughes.

Re: Listbox items - how to "owner draw" [modified]

#realJSOP24-Mar-09 10:01

24-Mar-09 10:01

Well, it doesn't like part of the xaml stuff (I had implemented all of the stuff you showed before I saw your message). Here's what I have:

namespace AnagramsWPF
{

    public class WordItem
    {
        public string Text  {  get; set; } 
        public bool Used { get; set; }

        public WordItem(string text)
        {
            Text      = text;
            Used      = false;
        }

	public override string ToString()
        {
            return Text;
        }
    }


    public class WordTypeTemplateSelector : DataTemplateSelector
    {
        public DataTemplate UnusedWordTemplate { get; set; }
        public DataTemplate UsedWordTemplate { get; set; }

        public override DataTemplate SelectTemplate(object item, DependencyObject container)
        {
            WordItem wordItem = item as WordItem;
            DataTemplate template = null;
            if (wordItem.Used)
            {
                template = UsedWordTemplate;
            }
            else
            {
                template = UnusedWordTemplate;
            }
            return template;
        }
    }
}

In the xaml, I have this:

<Window.Resources>
    <DataTemplate x:Key="unusedWord">
        <Grid>
            <TextBlock Text="{Binding Path=Text}" Foreground="DarkGray" />
        </Grid>
    </DataTemplate>
    <DataTemplate x:Key="usedWord">
        <Grid>
            <TextBlock Text="{Binding Path=Texe}" Foreground="Red" FontStyle="Italic" />
        </Grid>
    </DataTemplate>
    <local:WordTypeTemplateSelector
        x:Key="wordTypeTemplateSelector"
        UsedWordTemplate="{StaticResource usedwordTemplate}"
        UnusedWordTemplate="{StaticResource unusedwordTemplate}" />
</Window.Resources>

It doesn't like the underlined portion (it shows the error - "The type 'local:WordTypeTemplateSelector' was not found. Verify that you are not missing an assembly reference and that all referenced assemblies have been built.").

I don't need the ObservableCollection stuff because the words are already in the collection before the user starts putting words into the listbox.

modified on Tuesday, March 24, 2009 4:15 PM

Pete O'Hanlon24-Mar-09 11:20

24-Mar-09 11:20

You need to add this into your XAML to use the WordTypeTemplateSelector:

xmlns:local="clr-namespace:AnagramsWPF"

If it's already present, build your application - this type of reference only works if there are no build errors that prevent that class being updated. I'm busy writing a WPFified version of CPAM and this might help to clarify things for you.

"WPF has many lovers. It's a veritable porn star!" - Josh Smith

As Braveheart once said, "You can take our freedom but you'll never take our Hobnobs!" - Martin Hughes.

#realJSOP25-Mar-09 3:29

25-Mar-09 3:29

Well, I got it to work, but it was a royal pain in the ass. It was a LOT simpler in WinForms.

Pete O'Hanlon25-Mar-09 3:44

25-Mar-09 3:44

Congratulations.

"WPF has many lovers. It's a veritable porn star!" - Josh Smith

As Braveheart once said, "You can take our freedom but you'll never take our Hobnobs!" - Martin Hughes.