Gdzie jest kontrolka numeryczna UpDown WPF?

124

Wchodzenie w pierwszy poważny projekt WPF. Wygląda na to, że brakuje wielu podstawowych elementów sterujących. W szczególności szukam kontrolki Numeric UpDown. Czy było jakieś wydawnictwo poza zespołem, które przegapiłem? Naprawdę nie mam ochoty pisać własnej kontroli.

Nie chcę używać WindowsFormHost i umieszczać na nim ctl WinForm. Chcę, aby był w pełni WPF bez żadnych starszych śmieci.

Dzięki

AngryHacker
źródło
4
Extented WPF Toolkit ma jeden: NumericUpDown ! tekst alternatywny
Eduardo Molteni
21
Ten pojedynczy komentarz jest największym motorem ruchu na moim blogu wszechczasów. Nawet do dziś. Wesoły.
Kevin Moore,
1
możliwy duplikat odpowiednika Good NumericUpDown w WPF?
J c
3
Pytanie brzmi: „gdzie jest numeryczna kontrolka UpDown WPF”. Żadna z tych odpowiedzi nie odpowiada na to pytanie. Spodziewałbym się, że odpowiedź będzie w formie „postanowili się go pozbyć w wpf, ponieważ ...”. Nie znam jednak tej odpowiedzi
Assimilater
2
Zestaw narzędzi WPF sprawia o wiele więcej problemów niż rozwiązuje, zawiera sporo oczywistych błędów; i nie ma kontroli NumericUpDown firmy Microsoft ... cholera, czy WPF już w ogóle działa?
j00hi

Odpowiedzi:

48

Po prostu użyj IntegerUpDownkontrolki w zestawie narzędzi xtended wpf.Możesz go używać w następujący sposób:

  1. Dodaj do XAML następującą przestrzeń nazw:

    xmlns:xctk="http://schemas.xceed.com/wpf/xaml/toolkit"

  2. W Twoim XAML, gdzie chcesz użyć kontrolki:

    <xctk:IntegerUpDown Name="myUpDownControl" />

Ułożone
źródło
6
Dla tych, którzy zastanawiają się / nie czują się komfortowo z kontrolą zamkniętych źródeł innych firm, zauważ, że bezpłatna wersja tej biblioteki jest udostępniana na licencji Microsoft Public License, co w zasadzie oznacza, że ​​otrzymujesz pełny kod źródłowy za nią (przeczytaj pełny tekst licencji, aby uzyskać szczegółowe informacje). Kontrolki UpDown są częścią darmowej wersji. Istnieje również płatna wersja biblioteki, która zawiera znacznie więcej elementów sterujących / motywów.
jrh
Czy istnieje sposób, aby te niestandardowe kontrolki WPF były wyświetlane w VS Toolbox dla wygody? Nie mogłem ich znaleźć w „Narzędzia -> Wybierz elementy zestawu narzędzi”.
lotnik
2
Należy zauważyć, że począwszy od wersji v3.7.0, otwarta wersja wpftoolkit jest udostępniana na zastrzeżonej, niekomercyjnej licencji, a nie na MS-PL ( odniesienie )
Jordoff
46

Zrobiłem własne;

plik xaml

<StackPanel Orientation="Horizontal">
    <TextBox x:Name="txtNum" x:FieldModifier="private" Margin="5,5,0,5" Width="50" Text="0" TextChanged="txtNum_TextChanged" />
    <Button x:Name="cmdUp" x:FieldModifier="private" Margin="5,5,0,5" Content="˄" Width="20" Click="cmdUp_Click" />
    <Button x:Name="cmdDown" x:FieldModifier="private" Margin="0,5,0,5"  Content="˅" Width="20" Click="cmdDown_Click" />
</StackPanel>

i kod

private int _numValue = 0;

public int NumValue
{
    get {  return _numValue; }
    set
    {
        _numValue = value;
        txtNum.Text = value.ToString();
    }
}

public NumberUpDown()
{
    InitializeComponent();
    txtNum.Text = _numValue.ToString();
}

private void cmdUp_Click(object sender, RoutedEventArgs e)
{
    NumValue++;
}

private void cmdDown_Click(object sender, RoutedEventArgs e)
{
    NumValue--;
}

private void txtNum_TextChanged(object sender, TextChangedEventArgs e)
{
    if (txtNum == null)
    {
        return;
    }

    if (!int.TryParse(txtNum.Text, out _numValue))
        txtNum.Text = _numValue.ToString();
}
Michael
źródło
zdarzenie textChanged nie istnieje dla pola tekstowego w WPF .net 4
AliR
Ta metoda ma pewne ograniczenia, 1) TextBox nie rozciąga się w poziomie z kontrolką, jak robi to Winforms, i co mniej ważne, 2) w przeciwieństwie do Winforms NumericUpDown, ta kontrolka umożliwia rozciąganie w pionie, co jest nieszkodliwe, ale wygląda trochę głupio . Zwróć uwagę, że rozwiązanie w odpowiedzi Sonorx nie ma tych problemów.
jrh
2
NumValue powinna być właściwością zależności, aby umożliwić wiązanie, również inne właściwości, takie jak MinValue i MaxValue, byłyby fajne.
Konrad,
To rozwiązanie jest kiepskie. Jest to niestandardowa kontrolka bez obsługi wiązania danych WPF, kierowanych zdarzeń i poleceń.
Xam
18

To jest przykład mojego własnego UserControl z przechwytywaniem klawiszy w górę iw dół.

Kod XAML:

<Grid>
    <Grid.ColumnDefinitions>
        <ColumnDefinition Width="*" />
        <ColumnDefinition Width="13" />
    </Grid.ColumnDefinitions>
    <Grid.RowDefinitions>
        <RowDefinition Height="13" />
        <RowDefinition Height="13" />
    </Grid.RowDefinitions>
    <TextBox Name="NUDTextBox"  Grid.Column="0" Grid.Row="0" Grid.RowSpan="2" TextAlignment="Right" PreviewKeyDown="NUDTextBox_PreviewKeyDown" PreviewKeyUp="NUDTextBox_PreviewKeyUp" TextChanged="NUDTextBox_TextChanged"/>
    <RepeatButton Name="NUDButtonUP"  Grid.Column="1" Grid.Row="0" FontSize="8" FontFamily="Marlett" VerticalContentAlignment="Center" HorizontalContentAlignment="Center" Click="NUDButtonUP_Click">5</RepeatButton>
    <RepeatButton Name="NUDButtonDown"  Grid.Column="1" Grid.Row="1" FontSize="8"  FontFamily="Marlett" VerticalContentAlignment="Center" HorizontalContentAlignment="Center" Height="13" VerticalAlignment="Bottom" Click="NUDButtonDown_Click">6</RepeatButton>
</Grid>

A kod:

public partial class NumericUpDown : UserControl
{
    int minvalue = 0, 
        maxvalue = 100,
        startvalue = 10;
    public NumericUpDown()
    {
        InitializeComponent();
        NUDTextBox.Text = startvalue.ToString();
    }

    private void NUDButtonUP_Click(object sender, RoutedEventArgs e)
    {
        int number;
        if (NUDTextBox.Text != "") number = Convert.ToInt32(NUDTextBox.Text);
        else number = 0;
        if (number < maxvalue)
            NUDTextBox.Text = Convert.ToString(number + 1); 
    }

    private void NUDButtonDown_Click(object sender, RoutedEventArgs e)
    {
        int number;
        if (NUDTextBox.Text != "") number = Convert.ToInt32(NUDTextBox.Text);
        else number = 0;
        if (number > minvalue)
            NUDTextBox.Text = Convert.ToString(number - 1); 
    }

    private void NUDTextBox_PreviewKeyDown(object sender, KeyEventArgs e)
    {

        if (e.Key == Key.Up)
        {
            NUDButtonUP.RaiseEvent(new RoutedEventArgs(Button.ClickEvent));
            typeof(Button).GetMethod("set_IsPressed", BindingFlags.Instance | BindingFlags.NonPublic).Invoke(NUDButtonUP, new object[] { true }); 
        }


        if (e.Key == Key.Down)
        {
            NUDButtonDown.RaiseEvent(new RoutedEventArgs(Button.ClickEvent));
            typeof(Button).GetMethod("set_IsPressed", BindingFlags.Instance | BindingFlags.NonPublic).Invoke(NUDButtonDown, new object[] { true }); 
        }
    }

    private void NUDTextBox_PreviewKeyUp(object sender, KeyEventArgs e)
    {
        if (e.Key == Key.Up)
            typeof(Button).GetMethod("set_IsPressed", BindingFlags.Instance | BindingFlags.NonPublic).Invoke(NUDButtonUP, new object[] { false });

        if (e.Key == Key.Down)
            typeof(Button).GetMethod("set_IsPressed", BindingFlags.Instance | BindingFlags.NonPublic).Invoke(NUDButtonDown, new object[] { false });
    }

    private void NUDTextBox_TextChanged(object sender, TextChangedEventArgs e)
    {
        int number = 0;
        if (NUDTextBox.Text!="")
            if (!int.TryParse(NUDTextBox.Text, out number)) NUDTextBox.Text = startvalue.ToString();
        if (number > maxvalue)  NUDTextBox.Text = maxvalue.ToString();
        if (number < minvalue) NUDTextBox.Text = minvalue.ToString();
        NUDTextBox.SelectionStart = NUDTextBox.Text.Length;

    }

}
Sonorx
źródło
2
Czy czcionka „Marlett” na pewno istnieje w systemie użytkownika?
Qwertie,
@Qwertie Jest domyślnie w systemie Windows od 3.11, AFAIR.
Spook
To jest dobre rozwiązanie i wydaje się, że działa również z UWP XAML. Po prostu miałem problem z metodami PreviewKeyDown / PreviewKeyUP.
raddevus
10
<ResourceDictionary
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="clr-namespace:numericButton2">


    <Style TargetType="{x:Type local:NumericUpDown}">
        <Setter Property="Template">
            <Setter.Value>
                <ControlTemplate TargetType="{x:Type local:NumericUpDown}">              
                        <Grid>
                            <Grid.RowDefinitions>
                                <RowDefinition Height="*"/>
                                <RowDefinition Height="*"/>
                                <RowDefinition Height="*"/>
                            </Grid.RowDefinitions>
                            <RepeatButton Grid.Row="0" Name="Part_UpButton"/>
                            <ContentPresenter Grid.Row="1"></ContentPresenter>
                            <RepeatButton Grid.Row="2" Name="Part_DownButton"/>
                        </Grid>                  
                </ControlTemplate>
            </Setter.Value>
        </Setter>
    </Style>
</ResourceDictionary>

    <Window x:Class="numericButton2.MainWindow"
            xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
            xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
            xmlns:local="clr-namespace:numericButton2"
            Title="MainWindow" Height="350" Width="525">
        <Grid>
            <local:NumericUpDown Margin="181,94,253,161" x:Name="ufuk" StepValue="4" Minimum="0" Maximum="20">            
            </local:NumericUpDown>
            <TextBlock Margin="211,112,279,0" Text="{Binding ElementName=ufuk, Path=Value}" Height="20" VerticalAlignment="Top"></TextBlock>
        </Grid>
    </Window>
public class NumericUpDown : Control
{
    private RepeatButton _UpButton;
    private RepeatButton _DownButton;
    public readonly static DependencyProperty MaximumProperty;
    public readonly static DependencyProperty MinimumProperty;
    public readonly static DependencyProperty ValueProperty;
    public readonly static DependencyProperty StepProperty;   
    static NumericUpDown()
    {
        DefaultStyleKeyProperty.OverrideMetadata(typeof(NumericUpDown), new FrameworkPropertyMetadata(typeof(NumericUpDown)));
        MaximumProperty = DependencyProperty.Register("Maximum", typeof(int), typeof(NumericUpDown), new UIPropertyMetadata(10));
        MinimumProperty = DependencyProperty.Register("Minimum", typeof(int), typeof(NumericUpDown), new UIPropertyMetadata(0));
        StepProperty = DependencyProperty.Register("StepValue", typeof(int), typeof(NumericUpDown), new FrameworkPropertyMetadata(5));
        ValueProperty = DependencyProperty.Register("Value", typeof(int), typeof(NumericUpDown), new FrameworkPropertyMetadata(0));
    }
    #region DpAccessior
    public int Maximum
    {
        get { return (int)GetValue(MaximumProperty); }
        set { SetValue(MaximumProperty, value); }
    }
    public int Minimum
    {
        get { return (int)GetValue(MinimumProperty); }
        set { SetValue(MinimumProperty, value); }
    }
    public int Value
    {
        get { return (int)GetValue(ValueProperty); }
        set { SetCurrentValue(ValueProperty, value); }
    }
    public int StepValue
    {
        get { return (int)GetValue(StepProperty); }
        set { SetValue(StepProperty, value); }
    }
    #endregion
    public override void OnApplyTemplate()
    {
        base.OnApplyTemplate();
        _UpButton = Template.FindName("Part_UpButton", this) as RepeatButton;
        _DownButton = Template.FindName("Part_DownButton", this) as RepeatButton;
        _UpButton.Click += _UpButton_Click;
        _DownButton.Click += _DownButton_Click;
    }

    void _DownButton_Click(object sender, RoutedEventArgs e)
    {
        if (Value > Minimum)
        {
            Value -= StepValue;
            if (Value < Minimum)
                Value = Minimum;
        }
    }

    void _UpButton_Click(object sender, RoutedEventArgs e)
    {
        if (Value < Maximum)
        {
            Value += StepValue;
            if (Value > Maximum)
                Value = Maximum;
        }
    }

}
vercin
źródło
9

Podane odpowiedzi są OK. Chciałem jednak, aby przyciski automatycznie się ukrywały, gdy mysz opuszcza sterowanie. Oto mój kod oparty na Vercin odpowiedzi :

Styl

<Style TargetType="{x:Type v:IntegerTextBox}">
        <Setter Property="Template">
            <Setter.Value>
                <ControlTemplate TargetType="{x:Type v:IntegerTextBox}">
                    <Grid Background="Transparent">
                        <Grid.RowDefinitions>
                            <RowDefinition Height="*"/>
                            <RowDefinition Height="*"/>
                        </Grid.RowDefinitions>
                        <Grid.ColumnDefinitions>
                            <ColumnDefinition Width="*"/>
                            <ColumnDefinition Width="Auto"/>
                        </Grid.ColumnDefinitions>
                        <TextBox Name="tbmain" Grid.ColumnSpan="2" Grid.RowSpan="2"
                                 Text="{Binding Value, Mode=TwoWay, NotifyOnSourceUpdated=True, 
                            NotifyOnValidationError=True, RelativeSource={RelativeSource Mode=FindAncestor, AncestorType={x:Type v:IntegerTextBox}}}" 
                                               Style="{StaticResource ValidationStyle}" />
                        <RepeatButton Name="PART_UpButton" BorderThickness="0" Grid.Column="1" Grid.Row="0"
                                      Width="13" Background="Transparent">
                            <Path Fill="Black" Data="M 0 3 L 6 3 L 3 0 Z"/>
                        </RepeatButton>
                        <RepeatButton Name="PART_DownButton" BorderThickness="0" Grid.Column="1" Grid.Row="1"
                                      Width="13" Background="Transparent">
                            <Path Fill="Black" Data="M 0 0 L 3 3 L 6 0 Z"/>
                        </RepeatButton>

                    </Grid>
                    <ControlTemplate.Triggers>
                        <Trigger Property="IsMouseOver"  Value="False">
                            <Setter Property="Visibility" TargetName="PART_UpButton" Value="Collapsed"/>
                            <Setter Property="Visibility" TargetName="PART_DownButton" Value="Collapsed"/>
                        </Trigger>
                    </ControlTemplate.Triggers>
                </ControlTemplate>
            </Setter.Value>
        </Setter>
    </Style>

Kod

public partial class IntegerTextBox : UserControl
{
    public IntegerTextBox()
    {
        InitializeComponent();
    }

    public int Maximum
    {
        get { return (int)GetValue(MaximumProperty); }
        set { SetValue(MaximumProperty, value); }
    }
    public readonly static DependencyProperty MaximumProperty = DependencyProperty.Register(
        "Maximum", typeof(int), typeof(IntegerTextBox), new UIPropertyMetadata(int.MaxValue));



    public int Minimum
    {
        get { return (int)GetValue(MinimumProperty); }
        set { SetValue(MinimumProperty, value); }
    }
    public readonly static DependencyProperty MinimumProperty = DependencyProperty.Register(
        "Minimum", typeof(int), typeof(IntegerTextBox), new UIPropertyMetadata(int.MinValue));


    public int Value
    {
        get { return (int)GetValue(ValueProperty); }
        set { SetCurrentValue(ValueProperty, value); }
    }
    public readonly static DependencyProperty ValueProperty = DependencyProperty.Register(
        "Value", typeof(int), typeof(IntegerTextBox), new UIPropertyMetadata(0, (o,e)=>
        {
            IntegerTextBox tb = (IntegerTextBox)o;
            tb.RaiseValueChangedEvent(e);
        }));

    public event EventHandler<DependencyPropertyChangedEventArgs> ValueChanged;
    private void RaiseValueChangedEvent(DependencyPropertyChangedEventArgs e)
    {
        ValueChanged?.Invoke(this, e);
    }


    public int Step
    {
        get { return (int)GetValue(StepProperty); }
        set { SetValue(StepProperty, value); }
    }
    public readonly static DependencyProperty StepProperty = DependencyProperty.Register(
        "Step", typeof(int), typeof(IntegerTextBox), new UIPropertyMetadata(1));



    RepeatButton _UpButton;
    RepeatButton _DownButton;
    public override void OnApplyTemplate()
    {
        base.OnApplyTemplate();
        _UpButton = Template.FindName("PART_UpButton", this) as RepeatButton;
        _DownButton = Template.FindName("PART_DownButton", this) as RepeatButton;
        _UpButton.Click += btup_Click;
        _DownButton.Click += btdown_Click;
    }


    private void btup_Click(object sender, RoutedEventArgs e)
    {
        if (Value < Maximum)
        {
            Value += Step;
            if (Value > Maximum)
                Value = Maximum;
        }
    }

    private void btdown_Click(object sender, RoutedEventArgs e)
    {
        if (Value > Minimum)
        {
            Value -= Step;
            if (Value < Minimum)
                Value = Minimum;
        }
    }

}
Ron
źródło
Najlepsza odpowiedź tutaj. Właściwe użycie właściwości zależności.
Konrad,
5

Użyj VerticalScrollBarz TextBlockformantem w WPF. W swoim kodzie z tyłu dodaj następujący kod:

W konstruktorze zdefiniuj procedurę obsługi zdarzeń dla paska przewijania:

scrollBar1.ValueChanged += new RoutedPropertyChangedEventHandler<double>(scrollBar1_ValueChanged);
scrollBar1.Minimum = 0;
scrollBar1.Maximum = 1;
scrollBar1.SmallChange = 0.1;

Następnie w module obsługi zdarzeń dodaj:

void scrollBar1_ValueChanged(object sender, RoutedPropertyChangedEventArgs<double> e)
{
    FteHolderText.Text = scrollBar1.Value.ToString();
}

Oto oryginalny fragment mojego kodu ... wprowadź niezbędne zmiany .. :)

public NewProjectPlan()
{
    InitializeComponent();

    this.Loaded += new RoutedEventHandler(NewProjectPlan_Loaded);

    scrollBar1.ValueChanged += new RoutedPropertyChangedEventHandler<double>(scrollBar1_ValueChanged);
    scrollBar1.Minimum = 0;
    scrollBar1.Maximum = 1;
    scrollBar1.SmallChange = 0.1;

    // etc...
}

void scrollBar1_ValueChanged(object sender, RoutedPropertyChangedEventArgs<double> e)
{
    FteHolderText.Text = scrollBar1.Value.ToString();
}
Abhinav Wase
źródło
1
Twoje rozwiązanie jest bardzo sprytne, jednak przyciski działają w odwrotnej kolejności (przycisk w górę zmniejsza wartość, a przycisk w dół zwiększa ją). Znalazłem inny wątek, który może być pomocny w rozwiązaniu tego problemu: stackoverflow.com/a/27246296/637968 - po prostu obróć pasek przewijania
Mike
5

Możesz użyć kontrolki NumericUpDown dla WPF napisanej przeze mnie jako część biblioteki WPFControls .

Alex Titarenko
źródło
Ładna mała biblioteka, która pokazuje, jak należy pisać numeryczne kontrolki w górę / w dół. Jedynym problemem, jaki miałem, było ponowne odwołanie się do zestawu formantów w wersji demonstracyjnej i zainstalowanie MSHTML z nuget. Dzięki!
sierżantKK
Świetna robota z biblioteką. Bardzo przydatne. Dzięki.
namg_engr
5

Przeproś za dalsze odpowiadanie na pytania przez 9 lat.

Śledziłem odpowiedź @ Micheal i działa.

Robię to jako UserControl, gdzie mogę przeciągać i upuszczać jak elementy Controls. Używam motywu MaterialDesign firmy Nuget, aby uzyskać ikonę Chevron i efekt tętnienia przycisku.

Uruchomiony NumericUpDown z Micheal z modyfikacją będzie następujący: -

wprowadź opis obrazu tutaj

Kod do kontroli użytkownika: -

TemplateNumericUpDown.xaml

<UserControl x:Class="UserControlTemplate.TemplateNumericUpDown"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
             xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
             xmlns:local="clr-namespace:UserControlTemplate"
             xmlns:materialDesign="http://materialdesigninxaml.net/winfx/xaml/themes"
             mc:Ignorable="d" MinHeight="48">
    <Grid Background="{DynamicResource {x:Static SystemColors.WindowFrameBrushKey}}">
        <Grid.ColumnDefinitions>
            <ColumnDefinition/>
            <ColumnDefinition Width="60"/>
        </Grid.ColumnDefinitions>
        <TextBox x:Name="txtNum" x:FieldModifier="private" Text="{Binding Path=NumValue}" TextChanged="TxtNum_TextChanged" FontSize="36" BorderThickness="0" VerticalAlignment="Center" Padding="5,0"/>
        <Grid Grid.Column="1">
            <Grid.RowDefinitions>
                <RowDefinition Height="30*"/>
                <RowDefinition Height="30*"/>
            </Grid.RowDefinitions>
            <Grid Background="#FF673AB7">
                <Viewbox HorizontalAlignment="Stretch" VerticalAlignment="Stretch" Height="Auto" Width="Auto">
                    <materialDesign:PackIcon Kind="ChevronUp" Foreground="White" Height="32.941" Width="32"/>
                </Viewbox>
                <Button x:Name="cmdUp" x:FieldModifier="private" Click="CmdUp_Click" Height="Auto" BorderBrush="{x:Null}" Background="{x:Null}"/>
            </Grid>
            <Grid Grid.Row="1" Background="#FF673AB7">
                <Viewbox HorizontalAlignment="Stretch" VerticalAlignment="Stretch" Height="Auto" Width="Auto">
                    <materialDesign:PackIcon Kind="ChevronDown" Foreground="White" Height="32.942" Width="32"/>
                </Viewbox>
                <Button x:Name="cmdDown" x:FieldModifier="private" Click="CmdDown_Click" Height="Auto" BorderBrush="{x:Null}" Background="{x:Null}"/>
            </Grid>
        </Grid>
    </Grid>
</UserControl>

TemplateNumericUpDown.cs

using System.Windows;
using System.Windows.Controls;

namespace UserControlTemplate
{
    /// <summary>
    /// Interaction logic for TemplateNumericUpDown.xaml
    /// </summary>
    public partial class TemplateNumericUpDown : UserControl
    {
        private int _numValue = 0;
        public TemplateNumericUpDown()
        {
            InitializeComponent();
            txtNum.Text = _numValue.ToString();
        }
        public int NumValue
        {
            get { return _numValue; }
            set
            {
                if (value >= 0)
                {
                    _numValue = value;
                    txtNum.Text = value.ToString();
                }
            }
        }

        private void CmdUp_Click(object sender, RoutedEventArgs e)
        {
            NumValue++;
        }

        private void CmdDown_Click(object sender, RoutedEventArgs e)
        {
            NumValue--;
        }

        private void TxtNum_TextChanged(object sender, TextChangedEventArgs e)
        {
            if (txtNum == null)
            {
                return;
            }

            if (!int.TryParse(txtNum.Text, out _numValue))
                txtNum.Text = _numValue.ToString();
        }
    }
}

Na MyPageDesign.xaml przeciągnij i upuść utworzony usercontrol będzie miał <UserControlTemplate:TemplateNumericUpDown HorizontalAlignment="Left" Height="100" VerticalAlignment="Top" Width="100"/>

wprowadź opis obrazu tutaj

Aby uzyskać wartość z szablonu, używam

string Value1 = JournalNumStart.NumValue;
string Value2 = JournalNumEnd.NumValue;

Nie mam jeszcze dobrych umiejętności w zakresie wiązania wysokości kontrolki opartej na elemencie FontSize, więc ustawiam ręcznie rozmiar czcionki z mojej strony w usercontrol.

** Uwaga: - Zmieniłem nazwę „Archieve” na Archive w moim programie =)

Luiey
źródło
Użyteczność przycisków w górę / w dół jest okropna: są zbyt małe, aby były poręczne. Muszą mieć CO NAJMNIEJ taką samą wysokość jak pole tekstowe (i być kwadratowe). Wiem, że zajmuje to trochę więcej miejsca, ale daje PRZYNAJMNIEJ użyteczne przyciski. W przeciwnym razie nie ma żadnego powodu, aby je wstawiać.
Vincent
3

Mam rozwiązanie naiwne, ale przydatne. Oto kod:

<Grid Name="TVGrid" Background="#7F000000">  <ScrollBar Background="Black" Orientation="Vertical" Height="35" HorizontalAlignment="Left" Margin="215,254,0,0" Minimum="0" Maximum="10" LargeChange="10" Value="{Binding ElementName=channeltext2, Path=Text}" x:Name="scroll" VerticalAlignment="Top" Width="12" RenderTransformOrigin="0.5,0.5" ValueChanged="scroll_ValueChanged" >  
        <ScrollBar.RenderTransform>  
            <TransformGroup>  
                <ScaleTransform/>  
                <SkewTransform/>  
                <RotateTransform Angle="-180"/>  
                <TranslateTransform/>  
            </TransformGroup>  
        </ScrollBar.RenderTransform>  
    </ScrollBar>  
    <TextBox Name="channeltext" HorizontalContentAlignment="Center" FontSize="20"  Background="Black" Foreground="White" Height="35" HorizontalAlignment="Left" Margin="147,254,0,0" VerticalAlignment="Top" Width="53" Text="0" />  
    <TextBox Name="channeltext2" Visibility="Hidden" HorizontalContentAlignment="Center" FontSize="20"  Background="Black" Foreground="White" Height="35" HorizontalAlignment="Left" Margin="147,254,0,0" VerticalAlignment="Top" Width="53" Text="0" />  </Grid>  
Liron Harazi
źródło
3

Oto kolejna kontrolka open source, która ma wiele różnych metod wprowadzania (przeciąganie myszą, kółko myszy, klawisze kursora, edycja pola tekstowego), obsługuje wiele typów danych i przypadków użycia:

https://github.com/Dirkster99/NumericUpDownLib

user8276908
źródło
1

Pragmatyczna próbka:

-Kliknij prawym przyciskiem myszy projekt (w obszarze Rozwiązanie), wybierz opcję „Zarządzaj pakietami nuget ...”

-W menu kliknij Przeglądaj Zakładka wyszukaj „wpftoolkit”, wybierz „ Extended.Wpf.Toolkit

-Zainstaluj to!

-Kliknij prawym przyciskiem myszy w przyborniku kontroli użytkownika , wybierz opcję „Dodaj kartę” i nadaj jej nazwę „Zestaw narzędzi WPF”

-Kliknij prawym przyciskiem myszy nową kartę „Zestaw narzędzi WPF”, wybierz opcję „Wybierz elementy ...”

-W menu kliknij przycisk "Przeglądaj ...", poszukaj folderu nugets DLL, wybierz wszystko "...\packages\Extended.Wpf.Toolkit.3.5.0\lib\net40\*.dll "

Ignoruj ​​ostrzeżenia o niektórych bibliotekach DLL mogą nie zawierać elementów sterujących użytkownika!

Gotowy :)

thewhiteambit
źródło
0

Przejdź do menedżera NugetPackage swojego projektu -> Przeglądaj i wyszukaj mahApps.Metro -> zainstaluj pakiet w swoim projekcie. Zobaczysz Dodano odniesienie: MahApps.Metro. Następnie w kodzie XAML dodaj:

"xmlns:mah="http://metro.mahapps.com/winfx/xaml/controls"

Gdzie chcesz użyć swojego obiektu dodaj:

<mah:NumericUpDown x:Name="NumericUpDown" ... /> 

Ciesz się pełną rozszerzalnością obiektu (powiązania, wyzwalacze itp.).

Andre
źródło