.NET GUI

Ich probiere gerade einen Elliptischen Button mit einem Datatemplate zu schreiben. Das Problem ist, dass ich die Daten nicht in den Button bekomme. Ich lege ein ControlTemplate für den Button an damit er seine elliptische Form bekommt. Einen Text und ein Bild soll er auch anzeigen. Beim Klicken auf den Button sollen die Daten angezeigt werden. Hier ist der Code dazu. Was mache ich falsch? Das Verändern der Größe funktioniert. Da der Button ja auch ein Contentproperty hat kann man auch ein Datatemplate verwenden. Damit kann ich aber den Button nicht elliptisch aussehen lassen. Würde mich sehr über eine Antwort freuen.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
private void btn_Click(object sender, RoutedEventArgs e)
{
try
{
ImageSource mySource = FindResource("close") as ImageSource;
btn.Content = new ButtonContent("halllo", mySource);
btn.Width = 200;
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
namespace ControlTemplateTest
{
class ButtonContent
{
public ButtonContent(string text, ImageSource icon)
{
_text = text;
_icon = icon;
}
public ButtonContent()
{ }
private string _text;
private ImageSource _icon;
public string Text
{
get { return _text; }
set { if (value != null) _text = value; }
}
public ImageSource Icon
{
get { return _icon; }
set { if (value != null) _icon = value; }
}
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
<Window
 xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
 xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
 x:Class="ControlTemplateTest.Window1"
 x:Name="Window"
 Title="Window1"
 Width="640" Height="480">

 <Grid x:Name="LayoutRoot">
  <Button HorizontalAlignment="Left" x:Name="btn" VerticalAlignment="Top" Content="Button" Click="btn_Click" Template="{DynamicResource ButtonControlTemplate1}"/>
 </Grid>
</Window>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
<ResourceDictionary
 xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
 xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
 <!-- Resource dictionary entries should be defined here. -->
  <ControlTemplate x:Key="ButtonControlTemplate1" TargetType="{x:Type Button}">
  <Grid>
   <Ellipse Fill="#FFFF9797" Stroke="#FF000000"/>
   <Label HorizontalAlignment="Left" VerticalAlignment="Center" Content="{Binding Path=Text, Mode=Default}"/>
   <Image Margin="0,0,25,0" Source="{Binding Path=Icon, Mode=Default}"/>
  </Grid>
 </ControlTemplate>
</ResourceDictionary>

1
2
3
4
5
6
7
8
<ResourceDictionary
 xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
 xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
 <!-- Resource dictionary entries should be defined here. -->
    <ImageSource x:Key="close">grafics\close.ico</ImageSource>
</ResourceDictionary>

Ich habe im Forum gesucht ob es Formatierungen für Code gibt. Habe ich nicht gefunden. Kann ich aber vielleicht anschließend editieren wenn ich es gefunden habe wie man es macht. In dem Artikel wie poste ich richtig oder in der Hilfe habe ich nichts gefunden.

Danke für den Hinweis . Habs geändert.

knatterton:

Ich habe im Forum gesucht ob es Formatierungen für Code gibt. Habe ich nicht gefunden. Kann ich aber vielleicht anschließend editieren wenn ich es gefunden habe wie man es macht. In dem Artikel wie poste ich richtig oder in der Hilfe habe ich nichts gefunden.

<Label HorizontalAlignment="Left" VerticalAlignment="Center" Content="{TemplateBinding Content}"/>

public class ImageButton : Button
	{
		public ImageSource Image
		{
			get { return base.GetValue(ImageProperty) as ImageSource; }
			set { base.SetValue(ImageProperty, value); }
		}
		public static readonly DependencyProperty ImageProperty = DependencyProperty.Register("Image", typeof(ImageSource), typeof(ImageButton));
	}

<Image Margin="0,0,25,0" Source="{TemplateBinding Image}"/>

btn.Image = mySource;

Danke  

Mal angenommen ich habe aber schon einen Button in XAML definiert und möchte jetzt ein Databinding per CLR vornehmen. Muss ich den Button dann neu anlegen. In deinem Beispiel muss das Control mit dem DependencyProperty ja schon vor dem Design instanziert sein. Ist das wirklich der Weg den MS da gehen will?

Ok. Los gehts...

Es ist so das in nächster Zeit ein großes Projekt ansteht. Das soll mit WPF umgesetzt werden. Es ist auch so, dass viele Leute an dem UI arbeiten werden. Bisher hatte ich mir das so vorgestellt, dass ein ganz kleiner Teil mit Expression Design gemacht wird. Alles das was man mit Blend nicht machen kann. Die Designer die keine Ahnung von C# haben sollten die Controls anlegen. Die Controls sollten aber auch schon richtig angelegt werden. D.h. man muss vorher wissen ob ich jetzt ein Datatemplate oder ein Controltemplate verwende. Die Unterschiede scheinen mir erstmal soweit klar zu sein. Dennoch verleitet XAML dazu Datatemplates anzulegen wo sie evtl. keinen Sinn ergeben. Zum Beispiel die Geschichte mit dem Button. Button hat ein Contentproperty. Über dieses wäre es möglich ein Datatemplate anzulgen. Wenn ich jetzt mit der CLR Klasse den Content füllen will geht das. Steht auch so in einigen Büchern beschrieben. Wie ich aber schon mitbekommen habe ist das wohl nicht der optimale Weg. Warum? Weil ich den Aufbau des Button nicht überschreiben kann. Dazu braucht man ein Controtemplate. Da funktioniert aber dann das Databinding nicht richtig. Jetzt ist es so, dass du mir eine Lösung gezeigt hast die bestimmt funktioniert. Habe noch keine Zeit gehabt es auszuprobieren aber beim Googlen bin ich auf den Artikel gestoßen. Nun ist es ja so, dass die Designer die maximal XAML editieren dann erstmal auf den Programmierer warten müssen damit er den abgeleiteten Button bekommt um ihn "schön" zu machen. Und da ist mein Problem. Ich habe von Microsoft gehört, dass man nur in sehr seltenen Fällen ein CustomControl anlegen muss.

Was ich an der ganzen Sache nicht verstehe ist, dass man auf der einen Seite sagt man ist auf beiden Seiten (XAML und C#) offen. Das ist aber nur so wenn man vorher weiß wie man etwas umsetzen muss. Wenn man sich die Webcasts anschaut dann denkt man, dass alles ganz einfach ist. Bei dem Button... Da gibt es unzählige Beispiele wie man so ein Control elliptisch macht. Aber beim Databinding hört es dann auf einmal auf. Angenommen ich habe jetzt schon einen Haufen Controls in XAML mit Template und Styles angelegt. Die kann ich dann ja garnicht mehr benutzten wenn die Daten auf einmal per CLR bestückt werden sollen. Ich habe heute ein neues Buch bekommen. Mal sehen was da so drin steht. Aber über Antworten und Meinungen hierauf würd ich mich freuen.