Tri-State-Checkbox - so ändern Sie die Reihenfolge der Staaten

Ich habe eine CheckBox in meine Anwendung, die die TriState-Modus. Das normale Verhalten bei diesem Modus zu sein scheint, Radfahren zwischen null, false, true.

Möchte ich dieses Verhalten so ändern, dass es Zyklen zwischen null, true, false.

Was ist der beste Weg, dies zu tun?

Ich habe versucht, indem Sie einen click-handler, ähnlich wie diese:

void cb_Click(object sender, RoutedEventArgs e)
{
    if (((CheckBox)e.Source).IsChecked.HasValue == false)
    {
        ((CheckBox)e.Source).IsChecked = true;
        return;
    }

    if (((CheckBox)e.Source).IsChecked == true)
    {
        ((CheckBox)e.Source).IsChecked = false;
        return;
    }

    if (((CheckBox)e.Source).IsChecked == false)
    {
        ((CheckBox)e.Source).IsChecked = null;
        return;
    }

}

Aber das scheint zu deaktivieren Sie das Markierungsfeld vollständig. Ich bin mir ziemlich sicher, dass ich ' m fehlt etwas, das sollte klar sein.

InformationsquelleAutor Jason | 2009-08-27

checkbox wpf

Ich denke, der event-handler und das Standard-Verhalten sind einfach stornieren der jeweils anderen Effekte, so dass die checkbox scheint deaktiviert...

Eigentlich ich hatte vor kurzem das gleiche zu tun. Ich hatte zu Erben aus CheckBox und überschreiben OnToggle :

public class MyCheckBox : CheckBox
{


    public bool InvertCheckStateOrder
    {
        get { return (bool)GetValue(InvertCheckStateOrderProperty); }
        set { SetValue(InvertCheckStateOrderProperty, value); }
    }

    //Using a DependencyProperty as the backing store for InvertCheckStateOrder.  This enables animation, styling, binding, etc...
    public static readonly DependencyProperty InvertCheckStateOrderProperty =
        DependencyProperty.Register("InvertCheckStateOrder", typeof(bool), typeof(MyCheckBox), new UIPropertyMetadata(false));

    protected override void OnToggle()
    {
        if (this.InvertCheckStateOrder)
        {
            if (this.IsChecked == true)
            {
                this.IsChecked = false;
            }
            else if (this.IsChecked == false)
            {
                this.IsChecked = this.IsThreeState ? null : (bool?)true;
            }
            else
            {
                this.IsChecked = true;
            }
        }
        else
        {
            base.OnToggle();
        }
    }
}

InformationsquelleAutor Thomas Levesque

Nur der Vollständigkeit halber hier noch die Lösung für Windows-Forms. Wir haben das überschreiben der OnClick Methode überschreiben OnStateChanged Ergebnisse in der Anzeige-bug (und stackoverflow, wenn Sie nicht ordnungsgemäß durchgeführt).

///<summary>
///A <see cref="System.Windows.Forms.CheckBox"/> with the ability to reverse the checkstate order.
///</summary>
///<seealso cref="System.Windows.Forms.CheckBox" />
public class CheckBoxReversible : CheckBox
{
    private bool FInvertCheckStateOrder;

    ///<summary>
    ///Gets or sets a value indicating whether to invert the check state order from [Indeterminate->Unchecked->Checked] to [Indeterminate->Checked->Unchecked].
    ///</summary>
    ///<value>
    ///  <c>true</c> to invert the check state order; otherwise, <c>false</c>.
    ///</value>
    public bool InvertCheckStateOrder
    {
        get { return FInvertCheckStateOrder; }
        set { FInvertCheckStateOrder = value; }
    }

    ///<summary>
    ///Löst das <see cref="E:System.Windows.Forms.Control.Click" />-Ereignis aus.
    ///</summary>
    ///<param name="e">Eine Instanz der <see cref="T:System.EventArgs" />-Klasse, die die Ereignisdaten enthält.</param>
    protected override void OnClick(EventArgs e)
    {
        if (this.InvertCheckStateOrder)
        {
            if (this.CheckState == CheckState.Indeterminate)
                this.CheckState = CheckState.Checked;
            else
                if (this.CheckState == CheckState.Checked)
                    this.CheckState = CheckState.Unchecked;
                else
                    if (this.CheckState == CheckState.Unchecked)
                        this.CheckState = this.ThreeState ? CheckState.Indeterminate : CheckState.Checked;
        }
        else
            base.OnClick(e);
    }
}

InformationsquelleAutor casiosmu

Vielen Dank, es war sehr nützlich zu lösen, die ein ähnliches Verhalten mit ToggleButton.

class InvertedToggleButton : ToggleButton
{
    public bool InvertCheckStateOrder
    {
        get { return (bool)GetValue(InvertCheckStateOrderProperty); }
        set { SetValue(InvertCheckStateOrderProperty, value); }
    }

    //Using a DependencyProperty as the backing store for InvertCheckStateOrder.  This enables animation, styling, binding, etc...
    public static readonly DependencyProperty InvertCheckStateOrderProperty = DependencyProperty.Register("InvertCheckStateOrder", typeof(bool), typeof(ToggleButtonInvertido), new UIPropertyMetadata(false));

    protected override void OnToggle()
    {
        if (this.InvertCheckStateOrder)
        {
            if (this.IsChecked == true)
            {
                this.IsChecked = false;
            }
            else if (this.IsChecked == false)
            {
                this.IsChecked = this.IsThreeState ? null : (bool?)true;
            }
            else
            {
                this.IsChecked = true;
            }
        }
        else
        {
            if (!this.IsChecked.HasValue)
                this.IsChecked = true;
            else
                base.OnToggle();
        }
    }
}

InformationsquelleAutor Iñigo Panera

Als wies darauf hin, es gibt keine CheckBox.OnToggle() überschreiben in WinForms, so dass in diesem Fall CheckBox.OnClick() ist, wo man den Kopf für.

Hier ist eine minimale Implementierung der WinForms-checkbox, die Zyklen nicht aktiviert -> Unbestimmt -> Aktiviert -> Deaktiviert..., anstelle der standardmäßig nicht aktiviert -> Aktiviert -> Unbestimmt -> Deaktiviert...

using System;
using System.Windows.Forms;

public class MyCheckBox : CheckBox
{
    protected override void OnClick(EventArgs e)
    {
        switch(this.CheckState)
        {
            case CheckState.Indeterminate:
                this.CheckState = CheckState.Checked;
                break;
            case CheckState.Checked:
                this.CheckState = CheckState.Unchecked;
                break;
            case CheckState.Unchecked:
                this.CheckState = this.ThreeState ? CheckState.Indeterminate : CheckState.Checked;
                break;
            default:
                throw new ApplicationException("Unexpected CheckState: " + this.CheckState.ToString());
        }
    }
}

Oder wenn Sie glücklich sind, über die Einführung einer Abhängigkeit, welche int-Werte Windows zugewiesen, was Staaten von CheckState, das funktioniert auch:

using System;
using System.Windows.Forms;

public class MyCheckBox : CheckBox
{
    protected override void OnClick(EventArgs e)
    {
        CheckState newState = this.CheckState - 1;
        if (newState < 0) 
        {
            newState = this.ThreeState ? CheckState.Indeterminate : CheckState.Checked;
        }
        this.CheckState = newState;
    }
}

InformationsquelleAutor Jinlye

Akzeptierte Lösung ist die beste, aber wenn Sie nicht wollen, erstellen Sie eine Unterklasse erstellen, tun Sie einfach etwas wie:

void chkbokHeader_Click(object sender, RoutedEventArgs e)
{
  CheckBox senderChk = sender as CheckBox;
  bool bCheck = false;
  //here, the status is already changed, so rechange:
  if (senderChk.IsChecked == true) //from UNCHECKED
    bCheck = true;
  else if (senderChk.IsChecked == false) //from INDETERMINATE
    bCheck = true;
  else //from CHECKED
    bCheck = false;

  senderChk.IsChecked = bCheck;
  e.Handled = true;
}

Es schaffen (geprüft) Sequenz: unbestimmt -> wahr -> falsch> true -> falsch> true -> ...

InformationsquelleAutor Roberto

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.