.NET GUI

Hallo,

ich habe eine kleine Frage zum laden von XAML in einen "Bereich". Grundlage dessen ist der Artikel
von Norbert Eder ( http://dotnet-gui.com/forums/t/36.aspx ).

Nun habe ich mit einigen Dockpanels (geht bestimmt auch eleganter) mir Bereiche geschaffen und möchte diese
mit entsprechenden XAML füllen. Aussehen tut das wie folgt:

<Window x:Class="LoadXAML.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="Window1" Height="300" Width="300">
  <DockPanel Name="DPanel5">
    <StackPanel Name="Area5" DockPanel.Dock="Bottom" Background="Blue">
      <Label>Bereich5</Label>
    </StackPanel>
    <DockPanel Name="DPanel1">
      <StackPanel Name="Area1" DockPanel.Dock="Left" Background="AntiqueWhite">
        <Label>Bereich1</Label>
      </StackPanel>
      <DockPanel Name="DPanel2">
        <StackPanel Name="Area2" DockPanel.Dock="Right" Background="Beige">
          <Label>Bereich2</Label>
        </StackPanel>
        <DockPanel Name="DPanel3">
          <StackPanel Name="Area4" DockPanel.Dock="Bottom" Background="Chocolate">
            <Label>Bereich4</Label>
          </StackPanel>
          <StackPanel Name="Area3" DockPanel.Dock="Top" Background="BlanchedAlmond">
            <Label>Bereich3</Label>
          </StackPanel>        
        </DockPanel>
      </DockPanel>         
    </DockPanel>
  </DockPanel>
</Window>

Die Frage ist nur, wie fülle ich so einen Bereich? Ich habe das Gefühl das es nicht so einfach wie im
Artikel wird da ich keine Content Eigenschaft für ein Stackpanel o.ä. finde.

	
		
			
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
26
27
		
			
    public void LoadXAMLMethod()
    {
      // Delegate erstellen
      FPointer fp;
      // Klasse welche die Logik enthält instanzieren
      Klasse kl = new Klasse();
      // Dem Delegate die Funktion mit der Logik zuweisen
      fp = new FPointer(kl.MSG);

      try
      {
        // XAML Datei laden
        StreamReader sReader = new StreamReader("C:\\3S\\WPFPages\\Maske.xaml");
        DependencyObject doRoot = XamlReader.Load(sReader.BaseStream) as DependencyObject;
        // Ergeignisse hinzufügen
        _remoteButton = LogicalTreeHelper.FindLogicalNode(doRoot, "btKnopf") as Button;
        // Als Ergeignisshandler den Delegate angeben
        _remoteButton.Click += new RoutedEventHandler(fp);
        //Maske übernehmen / erstellen
        this.Content = doRoot;    
      }
      catch (Exception ex)
      {
        // Bei Fehler "Datei nicht vorhanden" Error Message werfen
        MessageBox.Show(ex.Message.ToString(),"Fehler");
      }
    }
	

Nun meine Frage, wie weise ich das Objekt doRoot einem Bereich zu?
Ist das nicht möglich oder ist dieses Ziel nur auf Umwegen zu erreichen?

Danke schon im voraus :-)

Was genau ladest du? Handelt es sich dabei um ein UIElement? Wenn ja, dann kannst du das so machen:

StreamReader sReader = new StreamReader("C:\\3S\\WPFPages\\Maske.xaml");        
UIElement doRoot = XamlReader.Load(sReader.BaseStream) as UIElement;        // Ergeignisse hinzufügen
_remoteButton = LogicalTreeHelper.FindLogicalNode(doRoot, "btKnopf") as Button;        // Als Ergeignisshandler den Delegate angeben
_remoteButton.Click += new RoutedEventHandler(fp);        //Maske übernehmen / erstellen        
this.Children.Add(doRoot);  

Edit: War Norbert mal wieder schneller :-) Im Text Beziehe ich mich auf das Beispiel (http://dotnet-gui.com/forums/t/36.aspx ) und nicht auf seinen Post oben.

Hallo Kjuettemeier.

Das Beispiel (http://dotnet-gui.com/forums/t/36.aspx ) von Norbert ist so nicht 100% richtig. (Lehn ich mich mal weit aus dem Fenster ;-))

Norbert überschreibt in seinem Beispiel sein eigenes Stackpanel und benutzt es gar nicht um dort seine Page anzuzeigen. Das Stackpanel könntest du dort auch einfach weglassen.

Eine Page kann man nur in einen Window oder Frame anzeigen und daher müssen wir den Code etwas abändern um die Page im Stackpanel anzeigen zu lassen.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
        public void LoadXAMLMethod()
        {
            try
            {
                StreamReader sReader = new StreamReader("PageToLoad.xaml");
                DependencyObject doRoot = XamlReader.Load(sReader.BaseStream) as DependencyObject;
                _remoteButton = LogicalTreeHelper.FindLogicalNode(doRoot, "PageButton") as Button;
                _remoteButton.Click += new RoutedEventHandler(Button_Click);
                Frame frame = new Frame {Content = doRoot};
				
                StackPanelMain.Children.Add(frame);
            }
            catch (FileNotFoundException ex)
            {
                MessageBox.Show(ex.Message.ToString());
            }
        }

Ich habe meinen StackPanel einen Namen gegeben (x:Name="StackPanelMain") und greife auf die Children Eigenschaft zu. Dies ist eine UIElementCollection und bietet was man so gewöhnt ist von Collections. Die Frage ist aber ob das alles wirklich der richtige Weg für dich ist. Was hast du denn genau vor?

Naja, mein Ziel ist es eine Page in einen Bereich zu laden.
Bei dem Projekt geht es darum eine Schema für eine "große Maske" zu erzeugen. Dem Schema sage ich in welchen Bereich ich eine Darstellung/Maske laden will.
So würde z.b. in Bereich 1 ein Menü kommen, in Bereich 3 die Erfassungsmaske oder genrell der Content der Software.
Momentan gestalte ich xaml Pages die ich vorerst einfach nur in einem Bereich anzeigen will. Später ist mein Ziel diese Pages möglichst dynamisch zu generieren und dann in einem
Bereich anzuzeigen - aber das wäre erst der nächste Schritt ( für den ich aber auch schon Tipps annehme ;-) ).

Ich habe gerade mal versucht meinen Code von der Maske.xaml in den Bereich 3 bzw. mein Stackpanel 3. Anzeige war nach Aufruf der LoadXAMLMethod nur das normale Bereichsfenster
wie ich es oben schon hochgeladen habe. Ziel wäre es in dem Bereich 3 eine komplette Maske darzustellen.

BTW: Ich muss nicht unbedingt ein Stackpanel verwenden, ich wollte vorerst nur Bereiche auf meiner Hauptmaske erzeugen (was mit dem Dockpanel recht einfach war) und habe dort zur
Vereinfachung für mich Stackpanel mit unterschiedlichen Farben angelegt. Wenn es anders besser geht, bin ich für Vorschläge offen :-)

Aber um auf mein momentanes Ziel zurückzukommen: Wie bekomme ich die PageToLoad.xaml (= Maske.xaml) in einen Teilbereich der Hauptmaske?

Da du eine Page laden möchtest, solltest du einen Frame verwenden, wie im Beispiel direkt vor deinem Posting zu entnehmen. Das sollte also dann schon funktionieren.

Die größe des Hauptfensters war zu klein um den Button von PageToLoad.xaml mit der Margin-Eigenschaft darzustellen. Daher sah es so aus als ob der
Bereich weiterhin ungeflüllt bleibt. Danke, damit ist das Problem vorerst gelöst :-)

Habt ihr evtl. noch einen Tipp zum performanten erstellen dynamischer Masken (anhand Informationen in der Datenbank oder Klassen)?

Mit dynamischen Masken meinst du zur Laufzeit generierte Masken?

Da muss ich leider passen.

Ja, zur Laufzeit generierte Masken :)
Ich möchte allerdings auch abdecken, daß Benutzer weitere Steuerelemente der Maske hinzufügen können und diese von einer Art Template Engine
dann "schön" in die generierung der Maske miteinbeziehen. Die Funktionalität würde dann weitesgehend in der Klasse liegen die mit der Maske durch
mich logisch verbunden wird. Diese Klasse müsste bei neuen Benutzerobjekten in der Maske natürlich auch "mitwachsen".

Wenn diese Informationen nicht ausreichen.. Wär es vielleicht besser wenn ich ( in einem seperaten Thread?) das was ich vorhabe genauer erläutere?

Ja, separater Thread wäre besser.

Mal sehen ob ich eine Idee für dich hab.