messageboxbuttons - msgboxresult vb.net ejemplo

¿Leyendas de botones personalizados en el cuadro de mensajes de.NET?

Question

¿Hay alguna manera fácil de mostrar un cuadro de mensaje en VB.NET con títulos de botones personalizados? Me encontré ¿Cuál es una manera fácil de crear un MessageBox con texto de botón personalizado en Managed C ++? , en los archivos Stack Overflow, pero es para Managed C ++ .

Answer 1

No, no hay un método para acceder o redirigir el texto del botón predeterminado del MessageBox.

La única forma de hacerlo es codificar uno o simplemente usar uno de muchos gratuitos de Internet:

¡MsgBoxGo gratis!

Answer 2

Agregue esto al botón del que desea que se muestre el diálogo. Este es un formulario personalizado messageBox;

 private void DGroup_Click(object sender, EventArgs e)
{
messageBox m = new messageBox();
m.ShowDialog();
if (m.DialogResult == DialogResult.Yes)
{
//del(groups.php?opt=del&id=613'',''asdasd'');
String[] asd = new String[2];
asd[0] = "groups.php?opt=del&id=613";
asd[1] = "asdasd";
addgroup.Document.InvokeScript("del",asd);
}
else
if (m.DialogResult == DialogResult.No)
{
MessageBox.Show("App won´t close");
}
}

Agregue este código a messageBox.

 private void deleteGroupOnly_Click(object sender, EventArgs e)
{
this.DialogResult = DialogResult.Yes;
this.Close();
}
private void deleteAll_Click(object sender, EventArgs e)
{
this.DialogResult = DialogResult.No;
this.Close();
}
private void cancel_Click(object sender, EventArgs e)
{
this.DialogResult = DialogResult.Cancel;
this.Close();
}

Answer 3

El código C # para lograr lo mismo se puede encontrar en un artículo en el foro de MSDN, https://forums.microsoft.com/MSDN/ShowPost.aspx?PostID=3087899&SiteID=1 .

Answer 4

Hay una solucion. Mediante la instalación de un gancho CBT es posible ajustar una gran variedad de ajustes visuales de MessageBox sobre la marcha: fuentes de mensaje y botón, fondo de diálogo, posicionamiento de diálogo, iconos, títulos de botones, tiempo de espera e incluso la inserción de controles adicionales.

Solución completa: Extended MessageBox .NET Assembly http://www.news2news.com/vfp/?solution=5

Es una versión de prueba completamente funcional, la versión regular incluye el código fuente completo de C #.

Answer 5

Aquí hay un fragmento de C # que usa un gancho Win32 para alterar los títulos de los botones (originados en http://icodesnip.com/snippet/csharp/custom-messagebox-buttons ):

 [DllImport("kernel32.dll")]
static extern uint GetCurrentThreadId();
[DllImport("user32.dll", CharSet = CharSet.Auto)]
private static extern int CallNextHookEx(int idHook, int nCode, IntPtr wParam, IntPtr lParam);
[DllImport("user32.dll", CharSet = CharSet.Auto)]
private static extern bool UnhookWindowsHookEx(int idHook);
[DllImport("user32.dll", CharSet = CharSet.Auto)]
private static extern int SetWindowsHookEx(int idHook, HookProc lpfn, IntPtr hInstance, int threadId);
[DllImport("user32.dll")]
private static extern bool SetDlgItemText(IntPtr hWnd, int nIDDlgItem, string lpString);
delegate int HookProc(int nCode, IntPtr wParam, IntPtr lParam);
static HookProc dlgHookProc;
private const long WH_CBT = 5;
private const long HCBT_ACTIVATE = 5;
private const int ID_BUT_OK = 1;
private const int ID_BUT_CANCEL = 2;
private const int ID_BUT_ABORT = 3;
private const int ID_BUT_RETRY = 4;
private const int ID_BUT_IGNORE = 5;
private const int ID_BUT_YES = 6;
private const int ID_BUT_NO = 7;
private const string BUT_OK = "Save";
private const string BUT_CANCEL = "Cancel";
private const string BUT_ABORT = "Stop";
private const string BUT_RETRY = "Continue";
private const string BUT_IGNORE = "Ignore";
private const string BUT_YES = "Yeeh";
private const string BUT_NO = "Never";
private static int _hook = 0;
private static int DialogHookProc(int nCode, IntPtr wParam, IntPtr lParam)
{
if (nCode < 0)
{
return CallNextHookEx(_hook, nCode, wParam, lParam);
}
if (nCode == HCBT_ACTIVATE)
{
SetDlgItemText(wParam, ID_BUT_OK, BUT_OK);
SetDlgItemText(wParam, ID_BUT_CANCEL, BUT_CANCEL);
SetDlgItemText(wParam, ID_BUT_ABORT, BUT_ABORT);
SetDlgItemText(wParam, ID_BUT_RETRY, BUT_RETRY);
SetDlgItemText(wParam, ID_BUT_IGNORE, BUT_IGNORE);
SetDlgItemText(wParam, ID_BUT_YES, BUT_YES);
SetDlgItemText(wParam, ID_BUT_NO, BUT_NO);
}
return CallNextHookEx(_hook, nCode, wParam, lParam);
}
private void Button_Click(object sender, EventArgs e)
{
dlgHookProc = new HookProc(DialogHookProc);
_hook = SetWindowsHookEx((int)WH_CBT, dlgHookProc, (IntPtr)0, (int)GetCurrentThreadId());
DialogResult dlgEmptyCheck = MessageBox.Show("Text", "Caption", MessageBoxButtons.AbortRetryIgnore, MessageBoxIcon.Exclamation, MessageBoxDefaultButton.Button3);
if (dlgEmptyCheck == DialogResult.Abort)
{
}
UnhookWindowsHookEx(_hook);
}

Answer 6

No.
Deberá crear un formulario personalizado con FormBorderType = FixedDialog .
Aquí hay un pequeño tutorial:

Crear cuadros de diálogo en .NET

por James D. Murray el 12 de junio de 2007, bajo 70-526

Examen de certificación de Microsoft: 70-526 (MCTS)
Objetivo: Crear y usar cuadros de diálogo personalizados en las aplicaciones de Windows Forms.
Idioma: Visual Basic 2005 (haga clic aquí para ver la versión C # de esta entrada)

Recuerdo la primera vez que necesité crear un cuadro de diálogo en una aplicación .NET que estaba escribiendo en C #. Siendo un programador de Visual Basic desde hace mucho tiempo, asumí que esto podría lograrse fácilmente usando una plantilla de cuadro de diálogo incluida con Visual Studio.NET. Para mi sorpresa, no existía ninguna plantilla de ese tipo para C #, aunque sí para Visual Basic 2005. Después de leer varios libros y páginas web llenas de información sobre la programación de Windows Forms 2.0, me resultó evidente un conjunto básico de pasos para convertir manualmente una .NET forma en un cuadro de diálogo de Windows:

Paso 1: Agregue un Formulario a su proyecto .NET y asígnele el nombre "DialogBoxForm".

Paso 2: suelte dos botones en el área inferior derecha del formulario y asígneles el nombre "OKButton" y "CancelButton".

Paso 3: Cambie las siguientes propiedades del Formulario para ajustar su apariencia y comportamiento para que sea como un cuadro de diálogo estándar:

Property Value Description ----------------------------------------------------------------------------------------------------------------------------- AcceptButton OK button instance Causes form to return value DialogResult.OK. Only used on modal dialog boxes. CancelButton Cancel button instance Causes form to return value DialogResult.Cancel. Only used on modal dialog boxes. FormBorderStyle FixedDialog Create a non-sizable form with no control box on the title bar. HelpButton True The Help button appears in the caption bar next to the Close button. The ControlBox property must be True for these buttons to be visible. MaximizeBox False Hide the Maximize button in the title bar. MinimizeBox False Hide the Minimize button in the title bar. ShowIcon False The title bar icon is not visible in a dialog box. ShowInTaskBar False Do not indicate the presence of the form on the Windows Task Bar. Start Position CenterParent The initial position of a dialog box is over its parent form. Size As Needed The fixed size needed for the dialog box.

Estas propiedades se pueden configurar usando la ventana Propiedades para el formulario, o usando el código colocado en el evento Carga del formulario:

 Me.AcceptButton = OKButton
Me.CancelButton = CancelButton
Me.FormBorderStyle = Windows.Forms.FormBorderStyle.FixedDialog
Me.HelpButton = True
Me.MaximizeBox = False
Me.MinimizeBox = False
Me.ShowInTaskbar = False
Me.ShowIcon = False
Me.StartPosition = FormStartPosition.CenterParent

Paso 4: agregue el siguiente botón, haga clic en los manejadores de eventos en el formulario:

Private Sub OKButton_Click(ByVal sender As Object, _ByVal e As EventArgs) '' User clicked the OK button Me.DialogResult = Windows.Forms.DialogResult.OK End Sub Private Sub CancelButton_Click(ByVal sender As Object, _ByVal e As EventArgs) '' User clicked the Cancel button Me.DialogResult = Windows.Forms.DialogResult.Cancel End Sub

Paso 5: agregue las propiedades que necesita para mover datos dentro y fuera del cuadro de diálogo como lo haría para cualquier formulario:

Private _LoginName As String Private _LoginPassword As String Public Property LoginName() As String Get Return _LoginName End Get Set(ByVal value As String) _LoginName = value End Set End Property Public Property LoginPassword() As String Get Return _LoginPassword End Get Set(ByVal value As String) _LoginPassword = value End Set End Property

Paso 6: muestre el cuadro de diálogo de manera modal llamando al ShowDialog () del formulario:

Public Sub ShowDialogBox() Dim dialog As New DialogBoxForm dialog.LoginName = "JDMurray" dialog.LoginPassword = String.Empty If dialog.ShowDialog() = Windows.Forms.DialogResult.OK Then Debug.WriteLine("Login Name: " & dialog.LoginName) Debug.WriteLine("Password: " & dialog.LoginPassword) Else '' User clicked the Cancel button End If End Sub

Paso 7: para mostrar el cuadro de diálogo sin moderadamente, llame al método Show () de DialogBoxForm en su lugar. Deberá agregar un controlador de eventos al evento Close de DialogBoxForm para saber cuándo el usuario cierra el cuadro de diálogo:

Public Sub ShowDialogBox() Dim dialog As DialogBoxForm = New DialogBoxForm dialog.LoginName = "JDMurray" dialog.Password = String.Empty AddHandler dialog.FormClosed, AddressOf dialog_FormClosed dialog.Show() '' The Show() method returns immediately End Sub Private Sub dialog_FormClosed(ByVal sender As Object, _ ByVal e As FormClosedEventArgs) '' This method is called when the user closes the dialog box End Sub

Answer 7

MessageBox usa una ventana simple que se puede alterar como cualquier otra ventana. Esto ha sido posible en Windows durante mucho tiempo, más de 20 años. Sin embargo, las técnicas se vuelven oscuras, demasiadas capas de clase amigables que ocultan los winapi nativos y no exponen todo lo que puedes hacer con él. Tanto es así que los programadores ahora automáticamente suponen que esto no es posible, como se puede ver en las respuestas subidas de tono. Es el tipo de programación que Petzold nos enseñó en su libro seminal de "Programación de Windows". Reemplazar MessageBox con un Formulario o Ventana personalizado es realmente bastante difícil de hacer, tiene un diseño automático no trivial para adaptarse al texto y admite la localización sin ayuda. Aunque eso es exactamente lo que no te gusta :)

Anyhoo, la ventana del cuadro de mensaje es fácil de encontrar de nuevo. Es propiedad del subproceso de interfaz de usuario y tiene un nombre de clase especial que lo hace único. EnumThreadWindows () enumera las ventanas propiedad de un hilo, GetClassName () le permite verificar el tipo de ventana. Luego, simplemente introduzca el texto en el botón con SetWindowText ().

Agregue una nueva clase a su proyecto y pegue el código que se muestra a continuación. Invocarlo con un código como este:

Nobugz.PatchMsgBox(New String() {"Da", "Njet"})
MsgBox("gack", MsgBoxStyle.YesNo)

Aquí está el código:

Imports System.Text
Imports System.Runtime.InteropServices
Public Class Nobugz
Private Shared mLabels() As String '''' Desired new labels
Private Shared mLabelIndex As Integer '''' Next caption to update
Public Shared Sub PatchMsgBox(ByVal labels() As String)
''''--- Updates message box buttons
mLabels = labels
Application.OpenForms(0).BeginInvoke(New FindWindowDelegate(AddressOf FindMsgBox), GetCurrentThreadId())
End Sub
Private Shared Sub FindMsgBox(ByVal tid As Integer)
''''--- Enumerate the windows owned by the UI thread
EnumThreadWindows(tid, AddressOf EnumWindow, IntPtr.Zero)
End Sub
Private Shared Function EnumWindow(ByVal hWnd As IntPtr, ByVal lp As IntPtr) As Boolean
''''--- Is this the message box?
Dim sb As New StringBuilder(256)
GetClassName(hWnd, sb, sb.Capacity)
If sb.ToString() <> "#32770" Then Return True
''''--- Got it, now find the buttons
mLabelIndex = 0
EnumChildWindows(hWnd, AddressOf FindButtons, IntPtr.Zero)
Return False
End Function
Private Shared Function FindButtons(ByVal hWnd As IntPtr, ByVal lp As IntPtr) As Boolean
Dim sb As New StringBuilder(256)
GetClassName(hWnd, sb, sb.Capacity)
If sb.ToString() = "Button" And mLabelIndex <= UBound(mLabels) Then
''''--- Got one, update text
SetWindowText(hWnd, mLabels(mLabelIndex))
mLabelIndex += 1
End If
Return True
End Function
''''--- P/Invoke declarations
Private Delegate Sub FindWindowDelegate(ByVal tid As Integer)
Private Delegate Function EnumWindowDelegate(ByVal hWnd As IntPtr, ByVal lp As IntPtr) As Boolean
Private Declare Auto Function EnumThreadWindows Lib "user32.dll" (ByVal tid As Integer, ByVal callback As EnumWindowDelegate, ByVal lp As IntPtr) As Boolean
Private Declare Auto Function EnumChildWindows Lib "user32.dll" (ByVal hWnd As IntPtr, ByVal callback As EnumWindowDelegate, ByVal lp As IntPtr) As Boolean
Private Declare Auto Function GetClassName Lib "user32.dll" (ByVal hWnd As IntPtr, ByVal name As StringBuilder, ByVal maxlen As Integer) As Integer
Private Declare Auto Function GetCurrentThreadId Lib "kernel32.dll" () As Integer
Private Declare Auto Function SetWindowText Lib "user32.dll" (ByVal hWnd As IntPtr, ByVal text As String) As Boolean
End Class

Answer 8

La solución de Daniel Nolan, código en VB.Net

<DllImport("kernel32.dll")> _
Private Shared Function GetCurrentThreadId() As UInteger
End Function
<DllImport("user32.dll", CharSet:=CharSet.Auto)> _
Private Shared Function CallNextHookEx(ByVal idHook As Integer, ByVal nCode As Integer, ByVal wParam As IntPtr, ByVal lParam As IntPtr) As Integer
End Function
<DllImport("user32.dll", CharSet:=CharSet.Auto)> _
Private Shared Function UnhookWindowsHookEx(ByVal idHook As Integer) As Boolean
End Function
<DllImport("user32.dll", CharSet:=CharSet.Auto)> _
Private Shared Function SetWindowsHookEx(ByVal idHook As Integer, ByVal lpfn As HookProc, ByVal hInstance As IntPtr, ByVal threadId As Integer) As Integer
End Function
<DllImport("user32.dll")> _
Private Shared Function SetDlgItemText(ByVal hWnd As IntPtr, ByVal nIDDlgItem As Integer, ByVal lpString As String) As Boolean
End Function
Private Delegate Function HookProc(ByVal nCode As Integer, ByVal wParam As IntPtr, ByVal lParam As IntPtr) As Integer
Shared dlgHookProc As HookProc
Private Const WH_CBT As Long = 5
Private Const HCBT_ACTIVATE As Long = 5
Private Const ID_BUT_OK As Integer = 1
Private Const ID_BUT_CANCEL As Integer = 2
Private Const ID_BUT_ABORT As Integer = 3
Private Const ID_BUT_RETRY As Integer = 4
Private Const ID_BUT_IGNORE As Integer = 5
Private Const ID_BUT_YES As Integer = 6
Private Const ID_BUT_NO As Integer = 7
Private Const BUT_OK As String = "Save"
Private Const BUT_CANCEL As String = "Cancelar"
Private Const BUT_ABORT As String = "Stop"
Private Const BUT_RETRY As String = "Continue"
Private Const BUT_IGNORE As String = "Ignore"
Private Const BUT_YES As String = "Si"
Private Const BUT_NO As String = "No"
Private Shared _hook As Integer = 0
Private Shared Function DialogHookProc(ByVal nCode As Integer, ByVal wParam As IntPtr, ByVal lParam As IntPtr) As Integer
If nCode < 0 Then
Return CallNextHookEx(_hook, nCode, wParam, lParam)
End If
If nCode = HCBT_ACTIVATE Then
SetDlgItemText(wParam, ID_BUT_OK, BUT_OK)
SetDlgItemText(wParam, ID_BUT_CANCEL, BUT_CANCEL)
SetDlgItemText(wParam, ID_BUT_ABORT, BUT_ABORT)
SetDlgItemText(wParam, ID_BUT_RETRY, BUT_RETRY)
SetDlgItemText(wParam, ID_BUT_IGNORE, BUT_IGNORE)
SetDlgItemText(wParam, ID_BUT_YES, BUT_YES)
SetDlgItemText(wParam, ID_BUT_NO, BUT_NO)
End If
Return CallNextHookEx(_hook, nCode, wParam, lParam)
End Function
Private Sub btn_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btn.Click
dlgHookProc = New HookProc(AddressOf DialogHookProc)
_hook = SetWindowsHookEx(CInt(WH_CBT), dlgHookProc, IntPtr.op_Explicit(0), CInt(GetCurrentThreadId()))
Dim dlgEmptyCheck As DialogResult = MessageBox.Show("Text", "Caption", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Exclamation, MessageBoxDefaultButton.Button3)
If dlgEmptyCheck = DialogResult.Abort Then
End If
UnhookWindowsHookEx(_hook)
End Sub