private ColorMatrix GetSepiaMatrix()
{
    return new ColorMatrix(new float[][]
    {
        new float[] {0.393f, 0.349f, 0.272f, 0, 0},
        new float[] {0.769f, 0.686f, 0.534f, 0, 0},
        new float[] {0.189f, 0.168f, 0.131f, 0, 0},
        new float[] {     0,      0,      0, 1, 0},
        new float[] {     0,      0,      0, 0, 1}
    });
}

OpenFileDialog ofd = new OpenFileDialog();
ofd.Filter = "JPEG-Files:*.jpg";
ofd.DefaultExt = ".jpg";
ofd.Title = "Open JPG File";

if (ofd.ShowDialog() == DialogResult.OK)
{
    if (OriginalPicture.Image != null)
        OriginalPicture.Image.Dispose();
    if (SepiaPicture.Image != null)
        SepiaPicture.Image.Dispose();

    Image img1 = Image.FromFile(ofd.FileName);
    Image img2 = Image.FromFile(ofd.FileName);

    OriginalPicture.Image = img1;

    ImageAttributes imageAttrs = new ImageAttributes();
    imageAttrs.SetColorMatrix(GetSepiaMatrix());
    using (Graphics g = Graphics.FromImage(img2))
    {
        g.DrawImage(
            img2, 
            new Rectangle(0, 0, img2.Width, img2.Height),
            0, 0, img2.Width, img2.Height, 
            GraphicsUnit.Pixel, imageAttrs);
    }

    SepiaPicture.Image = img2;
}

Bietet die WPF bereits ein entsprechendes Konzept?

Das Model-View ViewModel Pattern

Weitere Patterns

Fazit

Warum UI von Aufgaben trennen

Wie kann die WPF hier helfen?

• Commands müssen das UI aktualisieren
• Commands können komplett frei von allen UI-Einflüssen ausgeführt werden

• ApplicationCommands
• ComponentCommands
• NavigationCommands
• MediaCommands
• EditingCommands

<UserControl.CommandBindings>
    <CommandBinding 
      Command="MediaCommands.Play" 
      CanExecute="OnQueryExecute" 
      Executed="Execute"/>
</UserControl.CommandBindings>

<StackPanel Grid.Row="2" Orientation="Horizontal">
    <Button 
      Command="MediaCommands.Play" 
      Content="{Binding RelativeSource={RelativeSource Self}, 
        Path=Command.Text}" />
</StackPanel>

Eigene Commands via ICommand implementieren

• CanExecute
• Execute
• CanExecuteChanged

public class MySaveCommand : ICommand
{
    #region ICommand Members

    public bool CanExecute(object parameter)
    {
        return true;
    }

    public event EventHandler CanExecuteChanged;

    public void Execute(object parameter)
    {
        if (parameter is EasySum)
        {
            EasySum es = (EasySum)parameter;
            es.Result = es.Summand1 + es.Summand2;
        }
    }

    #endregion
}

RoutedCommand erstellen

public static RoutedCommand ChangeBackgroundCommand = new RoutedCommand();

private void ChangeBackgroundCommandCanExecute(
    object sender, CanExecuteRoutedEventArgs e)
{
    if (sender is Panel)
        e.CanExecute = true;
    else
        e.CanExecute = false;

}

private void ChangeBackgroundCommandExecuted(
    object sender, ExecutedRoutedEventArgs e)
{
    Panel target = e.Source as Panel;
    if (target != null)
    {
        if (target.Background == Brushes.AliceBlue)
        {
            target.Background = Brushes.LemonChiffon;
        }
        else
        {
            target.Background = Brushes.AliceBlue;
        }

    }
}

<StackPanel Name="MyStackPanel"
    Background="AliceBlue"
    Focusable="True">
    <StackPanel.CommandBindings>
        <CommandBinding 
            Command="{x:Static custom:Window1.ChangeBackgroundCommand}"
            Executed="ChangeBackgroundCommandExecuted"
            CanExecute="ChangeBackgroundCommandCanExecute"/>
    </StackPanel.CommandBindings>
    <Label>A StackPanel</Label>
    <Button Command="{x:Static custom:Window1.ChangeBackgroundCommand}"
      CommandParameter="ButtonOne"
      CommandTarget="{Binding ElementName=MyStackPanel}" 
      Content="Change Background" />
</StackPanel>

Fazit

Ein kurzer Rückblick

2007 in ein paar wenigen Zahlen

Ausblick 2008

Abschluss