Das Erstellen einer WinForms-Textbox verhält sich wie die Adressleiste Ihres Browsers

Wenn ein C # WinForms-Textfeld den Fokus erhält, soll es sich wie die Adressleiste Ihres Browsers verhalten.

Um zu sehen, was ich meine, klicken Sie in die Adressleiste Ihres Webbrowsers. Sie werden das folgende Verhalten bemerken:

1. Durch Klicken in das Textfeld sollte der gesamte Text ausgewählt werden, wenn das Textfeld zuvor nicht fokussiert war.
2. Wenn Sie mit der Maus nach unten und in das Textfeld ziehen, sollte nur der Text ausgewählt werden, den ich mit der Maus hervorgehoben habe.
3. Wenn das Textfeld bereits fokussiert ist, wird durch Klicken nicht der gesamte Text ausgewählt.
4. Wenn Sie das Textfeld programmgesteuert oder über die Tastatur tippen, sollte der gesamte Text ausgewählt werden.

Ich möchte genau dies in WinForms tun.

SCHNELLSTER GEWEHRWARNUNG: Bitte lesen Sie Folgendes, bevor Sie antworten! Danke Leute. :-)

Das Aufrufen von .SelectAll () während der Ereignisse .Enter oder .GotFocus funktioniert nicht, da beim Klicken auf das Textfeld das Caret dort platziert wird, wo er geklickt hat, wodurch die Auswahl des gesamten Texts aufgehoben wird .

Das Aufrufen von .SelectAll () während des .Click-Ereignisses funktioniert nicht, da der Benutzer keinen Text mit der Maus auswählen kann. Der Aufruf von .SelectAll () überschreibt weiterhin die Textauswahl des Benutzers.

Das Aufrufen von BeginInvoke ((Action) textbox.SelectAll) bei focus / enter event enter funktioniert nicht, da es gegen Regel 2 oben verstößt und die Auswahl des Benutzers bei focus weiterhin überschreibt.

Zunächst einmal vielen Dank für die Antworten! 9 Antworten insgesamt. Danke dir.

Schlechte Nachrichten: Alle Antworten hatten einige Macken oder funktionierten nicht ganz richtig (oder überhaupt nicht). Ich habe jedem Ihrer Beiträge einen Kommentar hinzugefügt.

Gute Nachricht: Ich habe einen Weg gefunden, damit es funktioniert. Diese Lösung ist ziemlich unkompliziert und scheint in allen Szenarien zu funktionieren (Mauszeiger, Textauswahl, Tabulatorfokus usw.).

bool alreadyFocused;

...

textBox1.GotFocus += textBox1_GotFocus;
textBox1.MouseUp += textBox1_MouseUp;
textBox1.Leave += textBox1_Leave;

...

void textBox1_Leave(object sender, EventArgs e)
{
    alreadyFocused = false;
}


void textBox1_GotFocus(object sender, EventArgs e)
{
    // Select all text only if the mouse isn't down.
    // This makes tabbing to the textbox give focus.
    if (MouseButtons == MouseButtons.None)
    {
        this.textBox1.SelectAll();
        alreadyFocused = true;
    }
}

void textBox1_MouseUp(object sender, MouseEventArgs e)
{
    // Web browsers like Google Chrome select the text on mouse up.
    // They only do it if the textbox isn't already focused,
    // and if the user hasn't selected all text.
    if (!alreadyFocused && this.textBox1.SelectionLength == 0)
    {
        alreadyFocused = true;
        this.textBox1.SelectAll();
    }
}

Soweit ich das beurteilen kann, verhält sich ein Textfeld genau so wie die Adressleiste eines Webbrowsers.

Hoffentlich hilft dies dem nächsten Mann, der versucht, dieses täuschend einfache Problem zu lösen.

Nochmals vielen Dank, Jungs, für all Ihre Antworten, die mir geholfen haben, den richtigen Weg zu finden.

Ich habe eine einfachere Lösung dafür gefunden. Es beinhaltet das asynchrone Starten von SelectAll mit, Control.BeginInvokedamit es auftritt, nachdem die Enter- und Click-Ereignisse aufgetreten sind:

In C #:

private void MyTextBox_Enter(object sender, EventArgs e)
{
    // Kick off SelectAll asyncronously so that it occurs after Click
    BeginInvoke((Action)delegate
    {
        MyTextBox.SelectAll();
    });
}

In VB.NET (danke an Krishanu Dey )

Private Sub MyTextBox_Enter(sender As Object, e As EventArgs) Handles MyTextBox.Enter 
    BeginInvoke(DirectCast(Sub() MyTextBox.SelectAll(), Action)) 
End Sub

Ihre Lösung ist gut, schlägt jedoch in einem bestimmten Fall fehl. Wenn Sie den TextBox-Fokus festlegen, indem Sie einen Textbereich auswählen, anstatt nur zu klicken, wird das Flag "bereits fokussiert" nicht auf "true" gesetzt. Wenn Sie also ein zweites Mal in die TextBox klicken, wird der gesamte Text ausgewählt.

Hier ist meine Version der Lösung. Ich habe den Code auch in eine Klasse eingefügt, die TextBox erbt, sodass die Logik gut versteckt ist.

public class MyTextBox : System.Windows.Forms.TextBox
{
    private bool _focused;

    protected override void OnEnter(EventArgs e)
    {
        base.OnEnter(e);
        if (MouseButtons == MouseButtons.None)
        {
            SelectAll();
            _focused = true;
        }
    }

    protected override void OnLeave(EventArgs e)
    {
        base.OnLeave(e);
        _focused = false;
    }

    protected override void OnMouseUp(MouseEventArgs mevent)
    {
        base.OnMouseUp(mevent);
        if (!_focused)
        {
            if (SelectionLength == 0)
                SelectAll();
            _focused = true;
        }
    }
}

Es ist ein bisschen kludgey, aber in Ihrem Klick-Ereignis verwenden SendKeys.Send( "{HOME}+{END}" );.

Ereignis der Textbox anklicken? Oder sogar das MouseCaptureChanged-Ereignis funktioniert für mich. - OK. funktioniert nicht

Sie müssen also zwei Dinge tun:

private bool f = false;

private void textBox_MouseClick(object sender, MouseEventArgs e)
{ 
  if (this.f) { this.textBox.SelectAll(); }
  this.f = false;
}

private void textBox_Enter(object sender, EventArgs e)
{
  this.f = true;
  this.textBox.SelectAll();
}
private void textBox_MouseMove(object sender, MouseEventArgs e) // idea from the other answer
{
  this.f = false; 
}

Funktioniert auch zum Tabulieren (über Textfelder zu dem einen) - rufen Sie SelectAll () in Enter auf, nur für den Fall ...

Eine einzeilige Antwort, die ich benutze ... Sie könnten sich selbst treten ...

Im Enter-Ereignis:

txtFilter.BeginInvoke (neuer MethodInvoker (txtFilter.SelectAll));

'Inside the Enter event
TextBox1.SelectAll();

Ok, nachdem du es hier ausprobiert hast, ist was du willst:

• Starten Sie auf dem Enter-Ereignis ein Flag, das angibt, dass Sie am Enter-Ereignis teilgenommen haben
• Wenn Sie beim Click-Ereignis das Flag setzen, rufen Sie .SelectAll () auf und setzen Sie das Flag zurück.
• Setzen Sie beim MouseMove-Ereignis das eingegebene Flag auf false, damit Sie auf Hervorheben klicken können, ohne zuerst das Textfeld eingeben zu müssen.

Dadurch wurde der gesamte Text bei der Eingabe ausgewählt, aber ich konnte anschließend einen Teil des Textes hervorheben oder beim ersten Klick hervorheben.

Auf Anfrage:

    bool entered = false;
    private void textBox1_Enter(object sender, EventArgs e)
    {
        entered = true;
        textBox1.SelectAll();   //From Jakub's answer.
    }

    private void textBox1_Click(object sender, EventArgs e)
    {
        if (entered) textBox1.SelectAll();
        entered = false;
    }

    private void textBox1_MouseMove(object sender, MouseEventArgs e)
    {
        if (entered) entered = false;
    }

Für mich wählt das Tabulieren in das Steuerelement den gesamten Text aus.

Hier ist eine Hilfsfunktion, die die Lösung auf die nächste Ebene bringt - Wiederverwendung ohne Vererbung.

    public static void WireSelectAllOnFocus( TextBox aTextBox )
    {
        bool lActive = false;
        aTextBox.GotFocus += new EventHandler( ( sender, e ) =>
        {
            if ( System.Windows.Forms.Control.MouseButtons == MouseButtons.None )
            {
                aTextBox.SelectAll();
                lActive = true;
            }
        } );

        aTextBox.Leave += new EventHandler( (sender, e ) => {
            lActive = false;
        } );

        aTextBox.MouseUp += new MouseEventHandler( (sender, e ) => {
            if ( !lActive )
            {
                lActive = true;
                if ( aTextBox.SelectionLength == 0 ) aTextBox.SelectAll();
            }   
        });
    }

Um dies zu verwenden, rufen Sie einfach die Funktion auf, die eine TextBox übergibt, und sie kümmert sich um alle unordentlichen Teile für Sie. Ich schlage vor, alle Ihre Textfelder im Form_Load-Ereignis zu verkabeln. Sie können diese Funktion in Ihrem Formular oder, wenn Sie mich mögen, irgendwo in einer Utility-Klasse platzieren, um sie noch besser wiederzuverwenden.

Dies funktionierte für eine WPF / XAML-TextBox.

    private bool initialEntry = true;
    private void TextBox_SelectionChanged(object sender, RoutedEventArgs e)
    {
        if (initialEntry)
        {
            e.Handled = true;
            initialEntry = false;
            TextBox.SelectAll();
        }
    }
    private void TextBox_GotFocus(object sender, RoutedEventArgs e)
    {
        TextBox.SelectAll();
        initialEntry = true;      
    }

Dies ähnelt der populären Antwort von nzhenry , aber ich finde es einfacher, keine Unterklasse zu haben:

Private LastFocused As Control = Nothing

Private Sub TextBox1_Enter(sender As Object, e As System.EventArgs) Handles TextBox1.Enter, TextBox2.Enter, TextBox3.Enter
    If MouseButtons = Windows.Forms.MouseButtons.None Then LastFocused = sender
End Sub

Private Sub TextBox1_Leave(sender As Object, e As System.EventArgs) Handles TextBox1.Leave, TextBox2.Leave, TextBox3.Leave
    LastFocused = Nothing
End Sub

Private Sub TextBox1_MouseUp(sender As Object, e As System.Windows.Forms.MouseEventArgs) Handles TextBox1.MouseUp, TextBox2.MouseUp, TextBox3.MouseUp
    With CType(sender, TextBox)
        If LastFocused IsNot sender AndAlso .SelectionLength = 0 Then .SelectAll()
    End With
    LastFocused = sender
End Sub

SelectAll hat bei mir nie funktioniert.

Das funktioniert.

ActiveControl = textBox1;
textBox1->SelectionStart = 0;
textBox1->SelectionLength = textBox1->Text->Length;

Ich habe eine noch einfachere Lösung gefunden:

Stellen Sie sicher, dass der Click-Handler den Enter-Handler aufruft, um sicherzustellen, dass beim Klicken auf ein Textfeld der gesamte Text ausgewählt ist. Keine zusätzlichen Variablen erforderlich!

Beispiel:

private void textBox1_Click(object sender, EventArgs e){
        textBox1_Enter(sender, e);
    }

private void textBox1_Enter(object sender, EventArgs e){
        TextBox tb = ((TextBox)sender);
        tb.SelectAll();
    }

private bool _isSelected = false;
private void textBox_Validated(object sender, EventArgs e)
{
    _isSelected = false;
}

private void textBox_MouseClick(object sender, MouseEventArgs e)
{
    SelectAllText(textBox);
}

private void textBox_Enter(object sender, EventArgs e)
{
    SelectAllText(textBox);
}

private void SelectAllText(TextBox text)
{
    if (!_isSelected)
    {
        _isSelected = true;
        textBox.SelectAll();
    }
}

Interessanterweise hat eine ComboBox mit DropDownStyle = Simple ziemlich genau das Verhalten, das Sie suchen, denke ich.

(Wenn Sie die Höhe des Steuerelements verringern, um die Liste nicht anzuzeigen - und dann um einige Pixel mehr -, gibt es keinen effektiven Unterschied zwischen der ComboBox und der TextBox.)

Warum verwenden Sie nicht einfach das MouseDown-Ereignis des Textfelds? Es funktioniert gut für mich und benötigt keinen zusätzlichen Booleschen Wert. Sehr sauber und einfach, zB:

private void textbox_MouseDown(object sender, MouseEventArgs e) {
    if (textbox != null && !string.IsNullOrEmpty(textbox.Text))
    {
        textbox.SelectAll();
    } }

Ich habe SelectAll innerhalb des MouseUp-Ereignisses aufgerufen und es hat gut funktioniert.

    private bool _tailTextBoxFirstClick = false;

    private void textBox1_MouseUp(object sender, MouseEventArgs e)
    {
        if(_textBoxFirstClick)           
            textBox1.SelectAll();

        _textBoxFirstClick = false;
    }  

    private void textBox1_Leave(object sender, EventArgs e)
    {
        _textBoxFirstClick = true;
        textBox1.Select(0, 0);
    }

Leiten Sie einfach eine Klasse von TextBox oder MaskedTextBox ab:

public class SMaskedTextBox : MaskedTextBox
{
    protected override void OnGotFocus(EventArgs e)
    {
        base.OnGotFocus(e);
        this.SelectAll();
    }
}

Und verwenden Sie es auf Ihren Formularen.

Haben Sie die im MSDN-Forum "Windows Forms General" vorgeschlagene Lösung ausprobiert , bei der TextBox einfach untergeordnet wird?

Tatsächlich ist GotFocus das richtige Ereignis (Nachricht wirklich), an dem Sie interessiert sind, da Sie dies sogar irgendwann erhalten, egal wie Sie zur Steuerung gelangen. Die Frage ist, wann Sie SelectAll () aufrufen.

Versuche dies:

public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();
        this.textBox1.GotFocus += new EventHandler(textBox1_GotFocus);
    }

    private delegate void SelectAllDelegate();    
    private IAsyncResult _selectAllar = null; //So we can clean up afterwards.

    //Catch the input focus event
    void textBox1_GotFocus(object sender, EventArgs e)
    {
        //We could have gotten here many ways (including mouse click)
        //so there could be other messages queued up already that might change the selection.
        //Don't call SelectAll here, since it might get undone by things such as positioning the cursor.
        //Instead use BeginInvoke on the form to queue up a message
        //to select all the text after everything caused by the current event is processed.
        this._selectAllar = this.BeginInvoke(new SelectAllDelegate(this._SelectAll));
    }

    private void _SelectAll()
    {
        //Clean-up the BeginInvoke
        if (this._selectAllar != null)
        {
            this.EndInvoke(this._selectAllar);
        }
        //Now select everything.
        this.textBox1.SelectAll();
    }
}

Für eine Gruppe von Textfeldern in einem Formular:

private System.Windows.Forms.TextBox lastFocus;   

private void textBox_GotFocus(object sender, System.Windows.Forms.MouseEventArgs e)   
{
    TextBox senderTextBox = sender as TextBox;
    if (lastFocus!=senderTextBox){
        senderTextBox.SelectAll();
    }
    lastFocus = senderTextBox;   
}

Ich weiß, dass dies bereits gelöst wurde, aber ich habe einen Vorschlag, den ich eigentlich für ziemlich einfach halte.

Im Mouse-Up-Ereignis müssen Sie nur platzieren

if(textBox.SelectionLength = 0)
{
    textBox.SelectAll();
}

Es scheint für mich in VB.NET zu funktionieren (ich weiß, dass dies eine C # -Frage ist ... leider bin ich gezwungen, VB bei meiner Arbeit zu verwenden ... und ich hatte dieses Problem, was mich hierher gebracht hat ... )

Ich habe noch keine Probleme damit gefunden .. außer der Tatsache, dass es nicht sofort beim Klicken ausgewählt wird, aber ich hatte Probleme damit ....

Die folgende Lösung funktioniert für mich. Ich habe hinzugefügt OnKeyDownund das OnKeyUpEreignis überschrieben, damit der TextBox-Text immer ausgewählt bleibt.

    public class NumericTextBox : TextBox
{
    private bool _focused;
    protected override void OnGotFocus(EventArgs e)
    {
        base.OnGotFocus(e);
        if (MouseButtons == MouseButtons.None)
        {
            this.SelectAll();
            _focused = true;
        }
    }
    protected override void OnEnter(EventArgs e)
    {
        base.OnEnter(e);
        if (MouseButtons == MouseButtons.None)
        {
            SelectAll();
            _focused = true;
        }
    }

    protected override void OnLeave(EventArgs e)
    {
        base.OnLeave(e);
        _focused = false;
    }

    protected override void OnMouseUp(MouseEventArgs mevent)
    {
        base.OnMouseUp(mevent);
        if (!_focused)
        {
            if (SelectionLength == 0)
                SelectAll();
            _focused = true;
        }
    }

    protected override void OnKeyUp(KeyEventArgs e)
    {
        base.OnKeyUp(e);

        if (SelectionLength == 0)
            SelectAll();
        _focused = true;
    }
    protected override void OnKeyDown(KeyEventArgs e)
    {
       base.OnKeyDown(e);
       if (SelectionLength == 0)
            SelectAll();
        _focused = true;
    }
}

Stellen Sie die Auswahl ein, wenn Sie die Steuerung verlassen. Es wird da sein, wenn Sie zurückkommen. Tabulator um das Formular und wenn Sie zum Steuerelement zurückkehren, wird der gesamte Text ausgewählt.

Wenn Sie mit der Maus hineingehen, wird das Caret zu Recht an der Stelle platziert, an der Sie geklickt haben.

private void maskedTextBox1_Leave(object sender, CancelEventArgs e)
    {
        maskedTextBox1.SelectAll();
    }

Sehr einfache Lösung:

    private bool _focusing = false;

    protected override void OnEnter( EventArgs e )
    {
        _focusing = true;
        base.OnEnter( e );
    }

    protected override void OnMouseUp( MouseEventArgs mevent )
    {
        base.OnMouseUp( mevent );

        if( _focusing )
        {
            this.SelectAll();
            _focusing = false;
        }
    }

BEARBEITEN: Das ursprüngliche OP war insbesondere besorgt über die Sequenz Maus-Ab / Textauswahl / Maus-Auf. In diesem Fall würde die obige einfache Lösung dazu führen, dass Text teilweise ausgewählt wird.

Dies sollte * das Problem lösen (in der Praxis fange ich WM_SETCURSOR ab):

    protected override void WndProc( ref Message m )
    {
        if( m.Msg == 32 ) //WM_SETCURSOR=0x20
        {
              this.SelectAll(); // or your custom logic here                
        }

        base.WndProc( ref m );
    }

* Eigentlich endet die folgende Sequenz mit einer teilweisen Textauswahl, aber wenn Sie die Maus über das Textfeld bewegen, wird der gesamte Text erneut ausgewählt:

Mouse-Down / Textauswahl / Mouse-Move-Out-Textbox / Mouse-Up

Ich finde diese Arbeit am besten, wenn Sie mit der Maus klicken und nicht sofort loslassen:

    private bool SearchBoxInFocusAlready = false;
    private void SearchBox_LostFocus(object sender, RoutedEventArgs e)
    {
        SearchBoxInFocusAlready = false;
    }

    private void SearchBox_PreviewMouseUp(object sender, MouseButtonEventArgs e)
    {
        if (e.ButtonState == MouseButtonState.Released && e.ChangedButton == MouseButton.Left &&
            SearchBox.SelectionLength == 0 && SearchBoxInFocusAlready == false)
        {
            SearchBox.SelectAll();
        }

        SearchBoxInFocusAlready = true;
    }

Meine Lösung ist ziemlich primitiv, funktioniert aber gut für meinen Zweck

private async void TextBox_GotFocus(object sender, RoutedEventArgs e)
{
    if (sender is TextBox)
    {
        await Task.Delay(100);
        (sender as TextBox).SelectAll();
    }
}

Das Folgende scheint zu funktionieren. Das Enter-Ereignis behandelt das Tabulieren des Steuerelements und MouseDown funktioniert, wenn auf das Steuerelement geklickt wird.

    private ########### void textBox1_Enter(object sender, EventArgs e)
    {
        textBox1.SelectAll();
    }

    private void textBox1_MouseDown(object sender, MouseEventArgs e)
    {
        if (textBox1.Focused)
            textBox1.SelectAll();
    }

Die Antwort kann tatsächlich ganz einfach sein als ALLE oben genannten, zum Beispiel (in WPF):

public void YourTextBox_MouseEnter(object sender, MouseEventArgs e)
    {
        YourTextBox.Focus();
        YourTextBox.SelectAll();
    }

Natürlich kann ich nicht wissen, wie Sie diesen Code verwenden möchten, aber der Hauptteil, den Sie hier betrachten sollten, ist: Rufen Sie zuerst .Focus () und dann .SelectAll () auf;

Verwenden Sie einfach selectall (), um Ereignisse einzugeben und darauf zu klicken

private void textBox1_Enter(object sender, EventArgs e)
        {

            textBox1.SelectAll();
        }
        private void textBox1_Click(object sender, EventArgs e)
        {
            textBox1.SelectAll();
        }

Ich habe ein neues VB.Net Wpf-Projekt erstellt. Ich habe eine TextBox erstellt und Folgendes für das Codebehind verwendet:

Class MainWindow 

    Sub New()

        ' This call is required by the designer.
        InitializeComponent()

        ' Add any initialization after the InitializeComponent() call.
        AddHandler PreviewMouseLeftButtonDown, New MouseButtonEventHandler(AddressOf SelectivelyIgnoreMouseButton)
        AddHandler GotKeyboardFocus, New KeyboardFocusChangedEventHandler(AddressOf SelectAllText)
        AddHandler MouseDoubleClick, New MouseButtonEventHandler(AddressOf SelectAllText)
    End Sub

    Private Shared Sub SelectivelyIgnoreMouseButton(ByVal sender As Object, ByVal e As MouseButtonEventArgs)
        ' Find the TextBox
        Dim parent As DependencyObject = TryCast(e.OriginalSource, UIElement)
        While parent IsNot Nothing AndAlso Not (TypeOf parent Is TextBox)
            parent = VisualTreeHelper.GetParent(parent)
        End While

        If parent IsNot Nothing Then
            Dim textBox As Object = DirectCast(parent, TextBox)
            If Not textBox.IsKeyboardFocusWithin Then
                ' If the text box is not yet focussed, give it the focus and
                ' stop further processing of this click event.
                textBox.Focus()
                e.Handled = True
            End If
        End If
    End Sub

    Private Shared Sub SelectAllText(ByVal sender As Object, ByVal e As RoutedEventArgs)
        Dim textBox As Object = TryCast(e.OriginalSource, TextBox)
        If textBox IsNot Nothing Then
            textBox.SelectAll()
        End If
    End Sub

End Class