Fazer uma caixa de texto WinForms se comportar como a barra de endereço do navegador

Quando uma caixa de texto C # WinForms recebe foco, quero que ela se comporte como a barra de endereço do navegador.

Para entender o que quero dizer, clique na barra de endereços do seu navegador. Você notará o seguinte comportamento:

1. Clicar na caixa de texto deve selecionar todo o texto se a caixa de texto não estiver focada anteriormente.
2. O mouse para baixo e arraste na caixa de texto deve selecionar apenas o texto destacado com o mouse.
3. Se a caixa de texto já estiver focada, clicar em não selecionará todo o texto.
4. Focar a caixa de texto de forma programática ou através das guias do teclado deve selecionar todo o texto.

Eu quero fazer exatamente isso no WinForms.

ALERTA MAIS RÁPIDA DA ARMA: leia o seguinte antes de responder! Obrigado rapazes. :-)

Chamar .SelectAll () durante os eventos .Enter ou .GotFocus não funcionará porque se o usuário clicar na caixa de texto, o cursor será colocado onde ele clicou, desmarcando todo o texto.

Chamar .SelectAll () durante o evento .Click não funcionará porque o usuário não poderá selecionar nenhum texto com o mouse; a chamada .SelectAll () continuará substituindo a seleção de texto do usuário.

Chamar BeginInvoke ((Action) textbox.SelectAll) no evento focus / enter enter não funciona porque quebra a regra # 2 acima, continuará substituindo a seleção do usuário no foco.

Primeiro de tudo, obrigado por respostas! 9 respostas no total. Obrigado.

Más notícias: todas as respostas tiveram algumas peculiaridades ou não funcionaram muito bem (ou nada). Adicionei um comentário a cada uma das suas postagens.

Boas notícias: Encontrei uma maneira de fazê-lo funcionar. Essa solução é bastante direta e parece funcionar em todos os cenários (passar o mouse, selecionar texto, tabular o foco etc.)

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

Pelo que sei, isso faz com que uma caixa de texto se comporte exatamente como a barra de endereço de um navegador da web.

Espero que isso ajude o próximo cara que tenta resolver esse problema enganosamente simples.

Mais uma vez obrigado, pessoal, por todas as suas respostas que me ajudaram a seguir o caminho correto.

Encontrei uma solução mais simples para isso. Envolve o lançamento de SelectAll de forma assíncrona, Control.BeginInvokepara que ocorra após a ocorrência dos eventos Enter e Click:

Em c #:

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

No VB.NET (graças a Krishanu Dey )

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

Sua solução é boa, mas falha em um caso específico. Se você focar o TextBox selecionando um intervalo de texto em vez de apenas clicar, o sinalizador jáFocado não será definido como true; portanto, quando você clica no TextBox pela segunda vez, todo o texto é selecionado.

Aqui está a minha versão da solução. Eu também coloquei o código em uma classe que herda TextBox, para que a lógica fique bem escondida.

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

É um pouco arrogante, mas no evento de clique, use SendKeys.Send( "{HOME}+{END}" );.

Clique em evento da caixa de texto? Ou mesmo o evento MouseCaptureChanged funciona para mim. - ESTÁ BEM. não funciona

Então você tem que fazer 2 coisas:

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

Também funciona para tabulação (através de caixas de texto para essa) - chame SelectAll () em Enter apenas no caso de ...

Uma resposta de uma linha que eu uso ... você pode estar se chutando ...

No evento Enter:

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

'Inside the Enter event
TextBox1.SelectAll();

Ok, depois de tentar aqui é o que você deseja:

• No evento Enter, inicie um sinalizador informando que você esteve no evento enter
• No evento Click, se você definir o sinalizador, chame .SelectAll () e redefina o sinalizador.
• No evento MouseMove, defina o sinalizador inserido como false, o que permitirá que você clique em realçar sem precisar inserir a caixa de texto primeiro.

Isso selecionou todo o texto na entrada, mas me permitiu destacar parte do texto posteriormente ou permitir que você realce no primeiro clique.

Por solicitação:

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

Para mim, a tabulação no controle seleciona todo o texto.

Aqui está uma função auxiliar que leva a solução ao próximo nível - reutilize sem herança.

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

Para usar isso, basta chamar a função que passa por um TextBox e ele cuida de todos os bits confusos para você. Sugiro ligar todas as suas caixas de texto no evento Form_Load. Você pode colocar essa função em seu formulário ou, se gostar de mim, em algum lugar de uma classe de utilitário para ainda mais reutilização.

Isso funcionou para um TextBox WPF / XAML.

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

Isso é semelhante à resposta popular de nzhenry , mas acho mais fácil não precisar subclassificar:

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 nunca funcionou para mim.

Isso funciona.

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

Encontrei uma solução ainda mais simples:

Para garantir que todo o texto seja selecionado ao clicar em uma caixa de texto, verifique se o manipulador de Click chama o manipulador Enter. Não há necessidade de variáveis ​​extras!

Exemplo:

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

Curiosamente, uma ComboBox com DropDownStyle = Simple tem exatamente o comportamento que você está procurando, eu acho.

(Se você reduzir a altura do controle para não mostrar a lista - e depois mais alguns pixels - não haverá diferença efetiva entre a ComboBox e a TextBox.)

Por que você simplesmente não usa o MouseDown-Event da caixa de texto? Funciona bem para mim e não precisa de um booleano adicional. Muito limpo e simples, por exemplo:

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

Liguei para SelectAll dentro do evento MouseUp e funcionou bem para mim.

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

Basta derivar uma classe de TextBox ou MaskedTextBox:

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

E use-o em seus formulários.

Você já tentou a solução sugerida no Fórum do MSDN "Windows Forms General", que simplesmente subclasse o TextBox?

Na verdade, o GotFocus é o evento certo (mensagem realmente) em que você está interessado, pois não importa como você obtenha o controle, você conseguirá isso eventualmente. A questão é quando você chama SelectAll ().

Tente o seguinte:

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

Para um grupo de caixas de texto em um formulário:

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

Sei que isso já foi resolvido, mas tenho uma sugestão de que acho que é realmente bastante simples.

No evento mouse up, tudo o que você precisa fazer é colocar

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

Parece funcionar para mim no VB.NET (eu sei que essa é uma pergunta em C # ... infelizmente, sou forçada a usar o VB no meu trabalho .. e eu estava tendo esse problema, e foi isso que me trouxe aqui ... )

Ainda não encontrei nenhum problema com ele .. exceto pelo fato de não selecionar imediatamente ao clicar, mas estava tendo problemas com isso ....

A seguinte solução funciona para mim. Eu adicionei OnKeyDowne OnKeyUpeventos override para manter o texto TextBox sempre selecionado.

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

Defina a seleção quando você sair do controle. Estará lá quando você voltar. Guia ao redor do formulário e quando você retornar ao controle, todo o texto será selecionado.

Se você entrar com o mouse, o cursor será colocado corretamente no ponto em que você clicou.

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

Solução muito simples:

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

EDITAR: O OP original estava particularmente preocupado com a seqüência de mouse para baixo / seleção de texto / mouse para cima; nesse caso, a solução simples acima acabaria com o texto sendo parcialmente selecionado.

Isso deve resolver * o problema (na prática, intercepto WM_SETCURSOR):

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

* Na verdade, a sequência a seguir termina com a seleção parcial de texto, mas se você mover o mouse sobre a caixa de texto, todo o texto será selecionado novamente:

mouse-down / seleção-de-texto / mouse-move-out-textbox / mouse-up

Acho esse trabalho melhor quando o mouse clica e não é liberado imediatamente:

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

Minha solução é bastante primitiva, mas funciona bem para o meu propósito

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

O abaixo parece funcionar. O evento enter lida com as guias do controle e o MouseDown funciona quando o controle é clicado.

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

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

A resposta pode ser realmente muito mais simples do que TODAS as opções acima, por exemplo (no WPF):

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

é claro que não sei como você deseja usar esse código, mas a parte principal a ser examinada aqui é: Primeira chamada .Focus () e depois chamada .SelectAll ();

basta usar selectall () em inserir e clicar em eventos

private void textBox1_Enter(object sender, EventArgs e)
        {

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

Eu criei um novo projeto VB.Net Wpf. Criei um TextBox e usei o seguinte para o codebehind:

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