ScrollBars

  • WPF
  • .NET (FX) 4.5–4.8

Es gibt 10 Antworten in diesem Thema. Der letzte Beitrag () ist von Lightsource.

    ScrollBars

    Ich wollte mich tatsächlich mal mit WPF beschäftigen. ^^

    Ok, kein NumericUpDown =O
    Dann probier ich's halt mit Scrollbars, die ich irgendwie an jeweils eine TextBox hänge.

    Nun seltsam, TextBox gibt es als Type aber ScrollBar nicht? ;(

    Und dann, ich möchte ein kleines Tool für WPF umschreiben. Da konnte man in fünf NumericUpDown Controls jeweils den Wert ändern, und die anderen 4 werden dann über verschiedene Berechnungen angepasst.
    Um nicht in einer Eventschleife zu landen, hatte ich mit Add/RemoveHandler gearbeitet, und die jeweils nicht zu berechnenden Controls von den Events abgetrennt.

    Wie kann man so etwas mit WPF machen? Ich muss alle, in meinem Fall nun Scrollbars, über ihren Namen erkennen, um dann die Eventkette der nicht geänderten Scrollbars abschalten, bis ich
    die Ergebnisse in allen Textboxen und Scrollbars übertragen habe.

    Ich hoffe ich habe mich deutlich genug ausgedrückt.

    Es gibt zahlreiche Frameworks für WPF, u.a. z.B. MahApps.Metro und MaterialDesignForXaml.

    Diese Frameworks bieten zahlreiche Controls in modernen Designs.

    mahapps.com/
    materialdesigninxaml.net/

    Und hier gleich noch eine riesige Liste mit viel, viel mehr: github.com/Carlos487/awesome-wpf

    Da musst du dich einfach mal umschauen. Es ist aber auch nicht sehr schwer, seine eigenen Controls in WPF zu basteln. Muss man sich nur einmal mit auseinandergesetzt haben.
    Quellcode lizensiert unter CC by SA 2.0 (Creative Commons Share-Alike)

    Meine Firma: Procyon Systems

    Selbstständiger Softwareentwickler & IT-Techniker.

    Lightsource schrieb:

    Ich muss alle, in meinem Fall nun Scrollbars, über ihren Namen erkennen, um dann die Eventkette der nicht geänderten Scrollbars abschalten, bis ich
    die Ergebnisse in allen Textboxen und Scrollbars übertragen habe.

    Ich hoffe ich habe mich deutlich genug ausgedrückt.
    ähm... nicht wirklich.
    Aber soviel vermeine ich zu verstehen, dass ich dich auf dem kompletten Holzweg vermute.
    Keinesfalls musst du Scrollbars über ihren Namen erkennen und abschalten.

    Für mich klingt das, als bräuchtest du ein UserControl, welches sich als DataTemplate für ein bestimmtes Viewmodel eignet.
    Alles was ich verstanden habe ist, dass dieses UserControl 9 Scrollbars haben wird, wobei vier iwie mit fünf anderen interagieren.
    Diese Info gibt natürlich nichts her über das Viewmodel - tja, aber das Viewmodel ist genau des Pudels Kern...

    Ich habe inzwischen in einem Buch einen Ersatz für ScrollBars gefunden, den ich nehmen kann.

    Nochmal zu der anderen Frage:
    Ich hatte ja das Programm mit NumericUpdowns bereits funktionsfertig im Einsatz.
    Da ich WPF ein wenig üben wollte, bin ich jetzt halt am Suchen, wie ich bestimmte Sachen umsetzen kann,
    um mich vielleicht noch an größere Sachen zu wagen.

    Durch das Klicken auf ein NUD-Control wird dessen Zahlenwert verändert. Diese Veränderung wird als Event erfasst.
    der Zahlenwert wird mittels versch. Formeln zu mehreren Ergebnissen umgerechnet. Diese Ergebnisse
    werden dann vom Programm in die anderen NUDs eingetragen.
    Da dadurch aber eine Veränderung in diesen NUDs stattfindet, käme es zu einem Event, das nun
    wieder die Berechnung auslösen würde, um in den anderen NUDs die Ergebnisse einzutragen.
    Um das zu vermeiden, habe ich die Events zwischendrin still gelegt, so dass es nicht zu
    einem gegenseitigen Feuern kommt. Das habe ich mit RemoveHandler gemacht.

    Alle NUDs-Events werden von einer einzigen Ereignisroutine bearbeitet, in der ich über
    "sender".name feststelle, welcher NUD gerade gefeuert hat. Über Case/Select
    werden dann die verschiedenen Berechnungen gestartet.

    Nun habe ich mich gefragt, ob ich bei WPF diese AddHandler und RemoveHandler
    genau so nutzen kann wie bei Winforms, oder ob es dazu andere Methoden gibt.


    Nun habe ich mich gefragt, ob ich bei WPF diese AddHandler und RemoveHandler
    genau so nutzen kann wie bei Winforms, oder ob es dazu andere Methoden gibt.


    Geht beides, wenn das Projekt größer ist würde ich mit MVVM-Pattern arbeiten bei kleineren Projekten kann der MVVM Aufwand den Nutzen schnell übersteigen. Wenn du dich in WPF einarbeiten willst würde ich dir zu einer MVVM varinaten raten.

    Es hat tatsächlich mit AddHandler etc. geklappt. Da sind noch ein paar Kleinigkeiten, aber es reagiert zumindest richtig.

    Die NumericUpDowns habe ich mit RepeatButton simuliert. Zur Ein- und Ausgabe wird eine TextBox verwendet.

    Wie kann ich eine zusätzliche Eigenschaft in die TextBox/RepeatButton Kombination einfügen?
    Ich würde gerne einen maximalen und minimalen Wert vorgeben, der nicht überschritten werden sollte.
    Natürlich kann ich das auch im Code machen, aber es interessiert mich wie das in XAML geht.

    Da brauchst du ein AttachedProperty aber dann könntest du dir auch gleich eine NumericUpDown basteln.

    NumericUpDown



    NumericUpDown.cs

    C#-Quellcode

    1. using CustomControls.Commands;
    3. using System.Windows;
    4. using System.Windows.Controls;
    5. using System.Windows.Input;
    6. using System.Windows.Media;
    8. namespace CustomControls
    9. {
    10. /// <summary>
    11. /// Führen Sie die Schritte 1a oder 1b und anschließend Schritt 2 aus, um dieses benutzerdefinierte Steuerelement in einer XAML-Datei zu verwenden.
    12. ///
    13. /// Schritt 1a) Verwenden des benutzerdefinierten Steuerelements in einer XAML-Datei, die im aktuellen Projekt vorhanden ist.
    14. /// Fügen Sie dieses XmlNamespace-Attribut dem Stammelement der Markupdatei
    15. /// an der Stelle hinzu, an der es verwendet werden soll:
    16. ///
    17. /// xmlns:MyNamespace="clr-namespace:NumericUpDown"
    18. ///
    19. ///
    20. /// Schritt 1b) Verwenden des benutzerdefinierten Steuerelements in einer XAML-Datei, die in einem anderen Projekt vorhanden ist.
    21. /// Fügen Sie dieses XmlNamespace-Attribut dem Stammelement der Markupdatei
    22. /// an der Stelle hinzu, an der es verwendet werden soll:
    23. ///
    24. /// xmlns:MyNamespace="clr-namespace:CustomControls;assembly=CustomControls"
    25. ///
    26. /// Darüber hinaus müssen Sie von dem Projekt, das die XAML-Datei enthält, einen Projektverweis
    27. /// zu diesem Projekt hinzufügen und das Projekt neu erstellen, um Kompilierungsfehler zu vermeiden:
    28. ///
    29. /// Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf das Zielprojekt und anschließend auf
    30. /// "Verweis hinzufügen"->"Projekte"->[Dieses Projekt auswählen]
    31. ///
    32. ///
    33. /// Schritt 2)
    34. /// Fahren Sie fort, und verwenden Sie das Steuerelement in der XAML-Datei.
    35. ///
    36. /// <MyNamespace:NumericUpDown/>
    37. ///
    38. /// </summary>
    39. public class NumericUpDown : Control
    40. {
    41. public decimal Value
    42. {
    43. get => (decimal)GetValue(ValueProperty);
    44. set => SetValue(ValueProperty, value);
    45. }
    46. public static readonly DependencyProperty ValueProperty;
    48. public decimal MinValue
    49. {
    50. get => (decimal)GetValue(MinValueProperty);
    51. set => SetValue(MinValueProperty, value);
    52. }
    53. public static readonly DependencyProperty MinValueProperty;
    55. public decimal MaxValue
    56. {
    57. get => (decimal)GetValue(MaxValueProperty);
    58. set => SetValue(MaxValueProperty, value);
    59. }
    60. public static readonly DependencyProperty MaxValueProperty;
    62. public decimal Step
    63. {
    64. get => (decimal)GetValue(StepProperty);
    65. set
    66. {
    67. if (value < 0)
    68. value = 0.1M;
    69. SetValue(StepProperty, value);
    70. }
    71. }
    72. public static readonly DependencyProperty StepProperty;
    74. public Brush ButtonForeground
    75. {
    76. get => (Brush)GetValue(ButtonForegroundProperty);
    77. set => SetValue(ButtonForegroundProperty, value);
    78. }
    79. public static readonly DependencyProperty ButtonForegroundProperty = DependencyProperty.Register(nameof(ButtonForeground), typeof(Brush), typeof(NumericUpDown), new PropertyMetadata(Brushes.Black));
    81. public Brush ButtonMouseOverForeground
    82. {
    83. get => (Brush)GetValue(ButtonMouseOverForegroundProperty);
    84. set => SetValue(ButtonMouseOverForegroundProperty, value);
    85. }
    86. public static readonly DependencyProperty ButtonMouseOverForegroundProperty = DependencyProperty.Register(nameof(ButtonMouseOverForeground), typeof(Brush), typeof(NumericUpDown),new PropertyMetadata(Brushes.Yellow));
    88. public Brush ButtonBackground
    89. {
    90. get => (Brush)GetValue(ButtonBackgroundProperty);
    91. set => SetValue(ButtonBackgroundProperty, value);
    92. }
    93. public static readonly DependencyProperty ButtonBackgroundProperty = DependencyProperty.Register(nameof(ButtonBackground), typeof(Brush), typeof(NumericUpDown), new PropertyMetadata(Brushes.Transparent));
    95. public Brush ButtonMouseOverBackground
    96. {
    97. get => (Brush)GetValue(ButtonMouseOverBackgroundProperty);
    98. set => SetValue(ButtonMouseOverBackgroundProperty, value);
    99. }
    100. public static readonly DependencyProperty ButtonMouseOverBackgroundProperty = DependencyProperty.Register(nameof(ButtonMouseOverBackground), typeof(Brush), typeof(NumericUpDown));
    102. public ICommand IncreaseValueCommand
    103. {
    104. get => (ICommand)GetValue(IncreaseValueCommandProperty);
    105. private set => SetValue(IncreaseValueCommandProperty, value);
    106. }
    107. public static readonly DependencyProperty IncreaseValueCommandProperty;
    109. public ICommand DecreaseValueCommand
    110. {
    111. get => (ICommand)GetValue(DecreaseValueCommandProperty);
    112. private set => SetValue(DecreaseValueCommandProperty, value);
    113. }
    114. public static readonly DependencyProperty DecreaseValueCommandProperty;
    116. static NumericUpDown()
    117. {
    118. DefaultStyleKeyProperty.OverrideMetadata(typeof(NumericUpDown), new FrameworkPropertyMetadata(typeof(NumericUpDown)));
    120. // Property intialization
    121. StepProperty = DependencyProperty.Register(nameof(StepProperty), typeof(decimal), typeof(NumericUpDown),
    122. new FrameworkPropertyMetadata(default(decimal), FrameworkPropertyMetadataOptions.BindsTwoWayByDefault));
    124. ValueProperty = DependencyProperty.Register(nameof(Value), typeof(decimal), typeof(NumericUpDown),
    125. new FrameworkPropertyMetadata(default(decimal), FrameworkPropertyMetadataOptions.BindsTwoWayByDefault));
    127. MinValueProperty = DependencyProperty.Register(nameof(MinValue), typeof(decimal), typeof(NumericUpDown),
    128. new FrameworkPropertyMetadata(default(decimal), FrameworkPropertyMetadataOptions.BindsTwoWayByDefault));
    130. MaxValueProperty = DependencyProperty.Register(nameof(MaxValue), typeof(decimal), typeof(NumericUpDown),
    131. new FrameworkPropertyMetadata(default(decimal), FrameworkPropertyMetadataOptions.BindsTwoWayByDefault));
    133. // Command initialization
    134. IncreaseValueCommandProperty = DependencyProperty.Register(nameof(IncreaseValueCommand), typeof(ICommand), typeof(NumericUpDown));
    135. DecreaseValueCommandProperty = DependencyProperty.Register(nameof(DecreaseValueCommand), typeof(ICommand), typeof(NumericUpDown));
    136. }
    138. [System.Diagnostics.DebuggerStepThrough]
    139. public NumericUpDown()
    140. {
    141. Value = 0;
    142. MinValue = 0;
    143. MaxValue = 100;
    144. Step = 1M;
    145. Padding = new Thickness(1);
    147. IncreaseValueCommand = new ParameterlessCommand(() =>
    148. {
    149. Value += Step;
    150. },
    151. (o) =>
    152. {
    153. return Value + Step <= MaxValue;
    154. });
    155. DecreaseValueCommand = new ParameterlessCommand(() =>
    156. {
    157. Value -= Step;
    158. },
    159. (o) => {
    160. return Value - Step >= MinValue;
    161. });
    162. }
    163. }
    164. }



    StringToDecimalValueConverter

    C#-Quellcode

    1. using System;
    2. using System.Globalization;
    3. using System.Windows.Data;
    5. namespace CustomControls.Converter
    6. {
    7. internal class StringToDecimalValueConverter : IValueConverter
    8. {
    9. public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
    10. {
    11. if (decimal.TryParse(value.ToString(), out decimal val))
    12. return val;
    14. return null;
    15. }
    17. public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
    18. {
    19. throw new NotImplementedException();
    20. }
    21. }
    22. }



    ParameterlessCommand

    C#-Quellcode

    1. using System;
    2. using System.Diagnostics;
    3. using System.Windows.Input;
    5. namespace CustomControls.Commands
    6. {
    7. internal class ParameterlessCommand : ICommand
    8. {
    9. private readonly Action action;
    11. private readonly Func<object, bool> canExecute;
    13. public ParameterlessCommand(Action action) : this(action, null) { }
    15. public ParameterlessCommand(Action action, Func<object, bool> canExecute)
    16. {
    17. this.action = action;
    18. this.canExecute = canExecute;
    19. }
    21. public event EventHandler CanExecuteChanged
    22. {
    23. add => CommandManager.RequerySuggested += value;
    24. remove => CommandManager.RequerySuggested -= value;
    25. }
    27. [DebuggerStepThrough]
    28. public bool CanExecute(object parameter)
    29. {
    30. if (canExecute == null)
    31. return true;
    33. return canExecute(parameter);
    34. }
    36. public void Execute(object parameter) => action();
    37. }
    38. }



    NumericUpDown.xaml

    XML-Quellcode

    1. <ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    2. xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    3. xmlns:local="clr-namespace:CustomControls"
    4. xmlns:converter="clr-namespace:CustomControls.Converter">
    6. <converter:StringToDecimalValueConverter x:Key="StringToDecimalConverter" />
    8. <Style TargetType="{x:Type local:NumericUpDown}">
    9. <Setter Property="Padding" Value="1"/>
    10. <Setter Property="Template">
    11. <Setter.Value>
    12. <ControlTemplate TargetType="{x:Type local:NumericUpDown}">
    13. <ControlTemplate.Resources>
    14. <Style TargetType="{x:Type Button}" BasedOn="{StaticResource {x:Type Button}}">
    15. <Setter Property="Background" Value="{Binding ButtonBackground, RelativeSource={RelativeSource TemplatedParent}}"/>
    16. <Setter Property="BorderThickness" Value="0"/>
    17. <Setter Property="VerticalAlignment" Value="Stretch"/>
    18. <Setter Property="HorizontalAlignment" Value="Stretch"/>
    19. <Setter Property="Template">
    20. <Setter.Value>
    21. <ControlTemplate TargetType="{x:Type Button}">
    22. <Grid Background="{TemplateBinding Background}">
    23. <Border Padding="4 2">
    24. <ContentPresenter HorizontalAlignment="Center" VerticalAlignment="Center" />
    25. </Border>
    26. </Grid>
    27. </ControlTemplate>
    28. </Setter.Value>
    29. </Setter>
    30. <Style.Triggers>
    31. <Trigger Property="IsMouseOver" Value="True">
    32. <Setter Property="Background" Value="{Binding ButtonMouseOverBackground, RelativeSource={RelativeSource TemplatedParent}}" />
    33. </Trigger>
    34. </Style.Triggers>
    35. </Style>
    37. <Style TargetType="{x:Type TextBox}" BasedOn="{StaticResource {x:Type TextBox}}">
    38. <Setter Property="Padding" Value="0"/>
    39. <Setter Property="BorderThickness" Value="0"/>
    40. <Setter Property="VerticalAlignment" Value="Stretch"/>
    41. <Setter Property="HorizontalAlignment" Value="Stretch"/>
    42. <Setter Property="VerticalContentAlignment" Value="Center"/>
    43. </Style>
    45. <Style TargetType="{x:Type Path}">
    46. <Setter Property="Stroke" Value="Transparent" />
    47. <Setter Property="StrokeThickness" Value="0" />
    48. <Setter Property="UseLayoutRounding" Value="True" />
    49. <Style.Triggers>
    50. <!-- Trigger order is required, if you need to change the order you have to specify multi data trigger -->
    51. <DataTrigger Binding="{Binding IsEnabled, RelativeSource={RelativeSource AncestorType={x:Type Button}}}" Value="True">
    52. <Setter Property="Stroke" Value="{Binding ButtonForeground, RelativeSource={RelativeSource TemplatedParent}}" />
    53. <Setter Property="Fill" Value="{Binding ButtonForeground, RelativeSource={RelativeSource TemplatedParent}}"/>
    54. </DataTrigger>
    55. <DataTrigger Binding="{Binding IsMouseOver, RelativeSource={RelativeSource AncestorType={x:Type Button}}}" Value="True">
    56. <Setter Property="Stroke" Value="{Binding ButtonMouseOverForeground, RelativeSource={RelativeSource TemplatedParent}}" />
    57. <Setter Property="Fill" Value="{Binding ButtonMouseOverForeground, RelativeSource={RelativeSource TemplatedParent}}"/>
    58. </DataTrigger>
    59. <DataTrigger Binding="{Binding IsEnabled, RelativeSource={RelativeSource AncestorType={x:Type Button}}}" Value="False">
    60. <Setter Property="Stroke" Value="Gray" />
    61. <Setter Property="Fill" Value="Gray"/>
    62. </DataTrigger>
    63. </Style.Triggers>
    64. </Style>
    66. </ControlTemplate.Resources>
    67. <Border Background="{TemplateBinding Background}"
    68. BorderBrush="{TemplateBinding BorderBrush}"
    69. BorderThickness="{TemplateBinding BorderThickness}"
    70. Height="{TemplateBinding Height}"
    71. Width="{TemplateBinding Width}"
    72. Padding="{TemplateBinding Padding}">
    73. <Grid>
    74. <Grid.ColumnDefinitions>
    75. <ColumnDefinition Width="*"/>
    76. <ColumnDefinition Width=".05*" MinWidth="20"/>
    77. </Grid.ColumnDefinitions>
    79. <Grid.RowDefinitions>
    80. <RowDefinition Height="*"/>
    81. <RowDefinition Height="*"/>
    82. </Grid.RowDefinitions>
    84. <!-- Input TextBox -->
    85. <TextBox Grid.RowSpan="2"
    86. Text="{TemplateBinding Value, Converter={StaticResource StringToDecimalConverter}}"
    87. FontSize="{TemplateBinding FontSize}"
    88. HorizontalContentAlignment="{TemplateBinding HorizontalContentAlignment}"
    89. VerticalContentAlignment="{TemplateBinding VerticalContentAlignment}" />
    91. <!-- NumericUp Button -->
    92. <Button Grid.Column="1" Grid.Row="0"
    93. x:Name="ButtonUp"
    94. Command="{TemplateBinding IncreaseValueCommand}">
    95. <Path Data="M201.4 137.4c12.5-12.5 32.8-12.5 45.3 0l160 160c12.5 12.5 12.5 32.8 0 45.3s-32.8 12.5-45.3 0L224 205.3 86.6 342.6c-12.5 12.5-32.8 12.5-45.3 0s-12.5-32.8 0-45.3l160-160z" Stretch="Fill" />
    96. </Button>
    98. <!-- NumericDown Button -->
    99. <Button Grid.Column="1" Grid.Row="1"
    100. x:Name="ButtonDown"
    101. Command="{TemplateBinding DecreaseValueCommand}">
    102. <Path Data="M201.4 342.6c12.5 12.5 32.8 12.5 45.3 0l160-160c12.5-12.5 12.5-32.8 0-45.3s-32.8-12.5-45.3 0L224 274.7 86.6 137.4c-12.5-12.5-32.8-12.5-45.3 0s-12.5 32.8 0 45.3l160 160z" Stretch="Fill"/>
    103. </Button>
    104. </Grid>
    105. </Border>
    106. </ControlTemplate>
    107. </Setter.Value>
    108. </Setter>
    109. </Style>
    111. </ResourceDictionary>



    XML-Quellcode

    1. <Window x:Class="Foo"
    2. xmlns:customControls="clr-namespace:CustomControls;assembly=CustomControls"
    3. d:DataContext="{d:DesignInstance Type=local:MainViewModel}">
    5. <customControls:NumericUpDown Value="{Binding NumericUpDownValue}"
    6. MinValue="-1" MaxValue="4"
    7. Width="40" Height="20" BorderThickness=".5" BorderBrush="Black"
    8. ButtonMouseOverBackground="Red"
    9. ButtonMouseOverForeground="White"/>

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „Fakiz“ ()

    Fakiz schrieb:

    Geht beides, wenn das Projekt größer ist würde ich mit MVVM-Pattern arbeiten bei kleineren Projekten kann der MVVM Aufwand den Nutzen schnell übersteigen....
    Dem täte ich sehr widersprechen.
    Jedes Projekt - egal wie klein - profitiert vom MVVM-Pattern.
    Ich rate dringend davon ab, es überhaupt zu versuchen, die in der Wpf abgelegten Anti-Pattern wiederzubeleben.
    Merke: Einüben von Anti-Pattern erweitert nicht deine Skills, sondern macht dich letztendlich nur dümmer.

    Ich hatte mich zu früh gefreut.

    Es funktioniert zwar, dass wenn ich meinen Up-Button drücke, meine Werte hoch gezählt werden, aber irgendwann
    läuft der Wert runter, und kurz darauf bleibt das Programm irgendwo (außerhalb meines Codes, aber unterbrechbar) hängen.
    Das ist sehr suspekt. Ich habe noch keine Ahnung, aber ich vermute, das ist irgend ein Timing-Problem
    beim AddHandler-setzen und wieder removen, zwischen meinem Code und WPF.