Où est le contrôle UpDown numérique WPF?


124

Entrer dans le premier projet WPF sérieux. Il semble qu'il manque beaucoup de contrôles de base. Plus précisément, je recherche le contrôle numérique UpDown. Y a-t-il eu une sortie hors groupe que j'ai ratée? Je n'ai vraiment pas envie d'écrire mon propre contrôle.

Je ne veux pas utiliser WindowsFormHost et y placer un ctl WinForm. Je veux que ce soit entièrement WPF sans aucun élément indésirable hérité.

Merci


4
La boîte à outils WPF étendue en a un: NumericUpDown ! texte
Eduardo Molteni

21
Ce seul commentaire est le plus gros moteur de trafic vers mon blog de tous les temps. Même à ce jour. Hilarant.
Kevin Moore

1
duplication possible de l' équivalent Good NumericUpDown dans WPF?
J c

3
La question est "où est le contrôle numérique UpDown WPF". Aucune de ces réponses ne répond à cette question. Je m'attendrais à ce que le genre de réponse soit de la forme "ils ont décidé de s'en débarrasser dans wpf car ...". Je ne connais pas cette réponse, cependant
Assimilateur

2
La boîte à outils WPF crée bien plus de problèmes qu'elle n'en résout, elle contient pas mal de bogues évidents; et il n'y a pas de contrôle NumericUpDown de Microsoft ... bon sang, WPF est-il encore vivant?
j00hi

Réponses:


48

Utilisez simplement le IntegerUpDowncontrôle dans la boîte à outils xtended wpf Vous pouvez l'utiliser comme ceci:

  1. Ajoutez à votre XAML l'espace de noms suivant:

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

  2. Dans votre XAML où vous voulez que le contrôle utilise:

    <xctk:IntegerUpDown Name="myUpDownControl" />


6
Pour ceux qui se demandent / ne sont pas à l'aise avec les contrôles de source fermée tiers, notez que la version gratuite de cette bibliothèque est publiée sous la licence publique Microsoft, ce qui signifie essentiellement que vous obtenez le code source complet derrière elle (lisez le texte complet de la licence pour plus de détails). Les contrôles UpDown font partie de la version gratuite. Il existe également une version payante de la bibliothèque qui contient beaucoup plus de contrôles / thèmes.
jrh

Existe-t-il un moyen d'afficher ces contrôles WPF personnalisés dans la boîte à outils VS pour plus de commodité? Je ne les ai pas trouvés sous «Outils -> Choisir les éléments de la boîte à outils».
aviator

2
Il est à noter qu'à partir de la version v3.7.0, la version open source de wpftoolkit est fournie sous une licence propriétaire non commerciale plutôt que MS-PL ( référence )
Jordoff

46

J'ai fait le mien;

le 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>

et le code derrière

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();
}

l'événement textChanged n'existe pas pour une zone de texte dans WPF .net 4
AliR

Cette méthode a quelques limitations, 1) la TextBox ne s'étire pas horizontalement avec le contrôle comme le fait Winforms, et moins important, 2) contrairement au Winforms NumericUpDown, ce contrôle permet l'étirement vertical, ce qui est inoffensif mais cela semble un peu idiot . Notez que la solution dans la réponse de Sonorx n'a pas ces problèmes.
jrh

2
NumValue doit être une propriété de dépendance pour permettre la liaison, d'autres propriétés telles que MinValue et MaxValue seraient également utiles.
Konrad

Cette solution est boiteuse. Il s'agit d'un contrôle personnalisé sans prise en charge de la liaison de données wpf, des événements routés et des commandes.
Xam

18

Ceci est un exemple de mon propre UserControl avec capture de touches Haut et Bas.

Code 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>

Et le code:

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;

    }

}

2
La police "Marlett" est-elle garantie d'exister sur le système de l'utilisateur?
Qwertie

@Qwertie C'est par défaut dans Windows depuis 3.11, AFAIR.
Spook

C'est une bonne solution et semble également fonctionner avec UWP XAML. J'ai juste eu un problème avec les méthodes PreviewKeyDown / PreviewKeyUP.
raddevus le

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;
        }
    }

}

9

Les réponses données sont OK. Cependant, je voulais que les boutons se masquent automatiquement lorsque la souris quitte le contrôle. Voici mon code basé sur la réponse vercin ci-dessus:

Style

<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>

Code

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;
        }
    }

}

La meilleure réponse ici. Utilisation appropriée des propriétés de dépendance.
Konrad le

5

À utiliser VerticalScrollBaravec le TextBlockcontrôle dans WPF. Dans votre code derrière, ajoutez le code suivant:

Dans le constructeur, définissez un gestionnaire d'événements pour la barre de défilement:

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

Ensuite, dans le gestionnaire d'événements, ajoutez:

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

Voici l'extrait de code original de mon code ... apportez les modifications nécessaires .. :)

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();
}

1
votre solution est très intelligente, cependant les boutons fonctionnent dans l'ordre inverse (le bouton vers le haut diminue la valeur tandis que le bouton vers le bas l'augmente). J'ai trouvé un autre fil qui pourrait aider à résoudre ce problème: stackoverflow.com/a/27246296/637968 - il suffit de faire pivoter la barre de défilement
Mike

5

Vous pouvez utiliser le contrôle NumericUpDown pour WPF écrit par moi dans le cadre de la bibliothèque WPFControls .


Une jolie petite bibliothèque et montre comment un contrôle numérique haut / bas doit être écrit. Le seul problème que j'ai eu était de devoir re-référencer l'assemblage des contrôles dans la démo et d'installer MSHTML à partir de nuget. Merci!
sergeantKK

Excellent travail avec la bibliothèque. Très utile. Merci.
namg_engr

5

Excusez-vous de continuer à répondre aux questions depuis 9 ans

J'ai suivi la réponse de @ Micheal et ça marche.

Je le fais en tant que UserControl où je peux faire glisser et déposer comme des éléments de contrôle. J'utilise le thème MaterialDesign de Nuget pour obtenir l'icône Chevron et l'effet d'ondulation du bouton.

Le NumericUpDown en cours d'exécution de Micheal avec modification sera comme ci-dessous: -

entrez la description de l'image ici

Le code de contrôle utilisateur: -

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();
        }
    }
}

Sur MyPageDesign.xaml, le glisser-déposer créé usercontrol aura <UserControlTemplate:TemplateNumericUpDown HorizontalAlignment="Left" Height="100" VerticalAlignment="Top" Width="100"/>

entrez la description de l'image ici

Pour obtenir la valeur du modèle, j'utilise

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

Je ne suis pas encore en mesure de lier la hauteur du contrôle basé sur l'élément FontSize, j'ai donc défini manuellement la taille de la police de ma page dans usercontrol.

** Remarque: - J'ai changé le nom "Archieve" en Archive sur mon programme =)


La convivialité des boutons haut / bas est horrible: ils sont trop petits pour être pratiques. Ils doivent avoir AU MOINS la même hauteur que la zone de texte (et être carrés). Je sais que cela prend un peu plus de place, mais cela vous donne AU MOINS des boutons utilisables. Sinon, il n'y a aucune raison de les insérer.
Vincent

3

J'ai une solution naïve mais utile. Voici le code:

<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>  

3

Voici un autre contrôle open source qui a de nombreuses méthodes d'entrée différentes (glissement de la souris, molette de la souris, touches de curseur, édition de zone de texte), prend en charge de nombreux types de données et cas d'utilisation:

https://github.com/Dirkster99/NumericUpDownLib


1

Juste un échantillon pragmatique à faire:

-Cliquez droit sur votre projet (sous Solution), sélectionnez "Gérer les packages nuget ..."

-Dans le menu, cliquez sur l' onglet Parcourir pour rechercher "wpftoolkit", sélectionnez " Extended.Wpf.Toolkit"

-Installez-le!

-Cliquez droit dans votre boîte à outils de contrôle utilisateur , sélectionnez "Ajouter un onglet" et nommez-le "WPF Toolkit"

-Cliquez droit sur le nouvel onglet "WPF Toolkit", sélectionnez "Choisir les éléments ..."

-Dans le menu, cliquez sur le bouton "Parcourir ...", recherchez le dossier DLL de nugets, sélectionnez tout " ...\packages\Extended.Wpf.Toolkit.3.5.0\lib\net40\*.dll"

Ignorer les avertissements concernant certaines DLL peuvent ne pas contenir de contrôles utilisateur!

Prêt :)


0

Accédez au gestionnaire NugetPackage de votre projet-> Parcourir et recherchez mahApps.Metro -> installer le package dans votre projet. Vous verrez Référence ajoutée: MahApps.Metro. Ensuite, dans votre code XAML, ajoutez:

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

Où vous souhaitez utiliser votre objet, ajoutez:

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

Profitez de la pleine extensibilité de l'objet (liaisons, déclencheurs, etc.).

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.