messagebox — `n_pbt_messagebox` #

← Referencia de componentes · Índice de la guía

Cuadro de diálogo modal con tema, de resultado síncrono: el sustituto directo del MessageBox() de PowerBuilder, con texto enriquecido, botones libres, iconos y casilla de verificación.

▶ Verlo en vivo — Aplicación de demostración, mosaico Message box: la vista previa, el código que lo genera y esta página, uno al lado del otro.

De un vistazo #

Objeto	`n_pbt_messagebox` — no visual: nada que colocar en la ventana
Sirve para	Plantear una pregunta o anunciar un resultado, en lugar del `MessageBox()` nativo, rígido y sin tema
Resultado	Síncrono: `of_show()` bloquea y devuelve el índice del botón pulsado

A diferencia de los componentes visuales, este objeto no se inserta en una ventana: se crea, configura, muestra y destruye.

// Variables locales
n_pbt_messagebox lnv_mb

// Crear el objeto de dialogo
lnv_mb = create n_pbt_messagebox

// ... configuracion ...

// Liberar el objeto de dialogo
destroy lnv_mb

Inicio rápido #

// Variables locales
n_pbt_messagebox lnv_mb

// Crear el objeto de dialogo
lnv_mb = create n_pbt_messagebox

// Configurar el cuadro
lnv_mb.is_title   = "Eliminación"
lnv_mb.is_icon    = lnv_mb.ICON_WARNING
lnv_mb.is_message = "¿Eliminar definitivamente [b]12 carpetas[/b]?[br][br]Esta acción es irreversible."

// Agregar los botones : Cancelar es el predeterminado, Intro no elimina nada
lnv_mb.of_add_button(/*text*/ "Eliminar", /*default*/ true,  /*cancel*/ false)   // -> 1
lnv_mb.of_add_button(/*text*/ "Cancelar",   /*default*/ true,  /*cancel*/ true)    // -> 2

// Mostrar en modal y actuar sobre el primer boton
if lnv_mb.of_show(/*hwnd*/ Handle(this)) = 1 then
    of_delete()
end if

// Liberar el objeto de dialogo
destroy lnv_mb

of_show espera la respuesta del usuario: la línea siguiente no se ejecuta hasta después del clic, exactamente igual que con MessageBox().

Propiedades #

Deben establecerse antes de of_show.

Propiedad	Tipo	Predeterminado	Función
`is_title`	string	`""`	Título mostrado en el encabezado del cuadro
`is_message`	string	`""`	Cuerpo del mensaje. Acepta el texto enriquecido con etiquetas (`[b]`, `[i]`, `[br]`, `[accent]`, `[picture=…]`…). El texto del mensaje y de la instrucción se puede seleccionar y copiar. Un valor que viene de sus datos pasa antes por `of_escape_markup`: si no, un corchete se leería como una etiqueta — un `[action=x]` en el nombre de un cliente cerraría el cuadro
`is_instruction`	string	`""`	Instrucción principal: la pregunta en sí, mostrada más grande encima del mensaje. Título / instrucción / mensaje es la anatomía que hace un diálogo legible de un vistazo — «¿Eliminar 42 filas?» y luego «Esta acción es definitiva» — en lugar de un bloque uniforme. Acepta el marcado
`is_icon`	string	`""`	Icono: una constante `ICON_`, o su propia imagen* (ruta de archivo, o recurso de DLL `mi.dll:NOMBRE`)
`is_details`	string	`""`	Detalles plegados bajo el mensaje tras un botón « Mostrar detalles »: un informe, una pila de llamadas, una sentencia SQL. Texto plano en una zona de ancho fijo que se desplaza — un corchete sigue siendo un corchete. Ctrl+C lo copia incluso plegado: es lo que pide el soporte
`is_details_label`	string	`""`	Etiqueta del botón que despliega `is_details` (`""` = « Mostrar / Ocultar detalles », traducido)
`is_footer`	string	`""`	Una nota al pie bajo los botones: un enlace de ayuda, un recordatorio. Marcado; un `[hyperlink]` abre el navegador y deja el cuadro abierto
`is_footer_icon`	string	`""`	Pequeño icono delante de la nota: una constante `ICON_*` o su propia imagen (`""` = ninguno)
`is_checkbox`	string	`""`	Texto de una casilla de verificación opcional, del estilo «no volver a preguntar» (`""` = sin casilla)
`ib_checked`	boolean	`false`	Estado inicial de la casilla (el estado final se lee con `of_checked()`)
`ib_input`	boolean	`false`	Añade un campo de entrada con el tema aplicado (renombrar, motivo, comentario), de modo que una aplicación ya no necesita una ventana hecha a mano que no sigue ni el tema ni el sentido de lectura. Se relee con `of_input_value()` tras `of_show`. Todo en una llamada: `of_prompt` — respeta los ajustes del campo puestos antes (etiqueta, máscara, obligatorio, varias líneas, longitud, patrón)
`is_input_label`	string	`""`	Etiqueta encima del campo (`""` = ninguna). Necesita `ib_input` . Nombra el campo para un lector de pantalla, y un clic en ella da el foco al campo; se acepta el marcado, una zona `[action]` responde como una elección
`is_input_value`	string	`""`	Contenido inicial del campo. Está seleccionado al abrirse: escribir lo sustituye, como en todo diálogo de renombrado
`is_input_placeholder`	string	`""`	Indicación mostrada mientras el campo está vacío. No es un valor: si el usuario no escribe nada, no se devuelve nada
`ib_input_password`	boolean	`false`	Enmascara los caracteres escritos . Un ojo al final del campo los muestra — con el ratón, o Alt+F8 desde el teclado. El valor nunca se copia con Ctrl+C ni se ofrece al gestor de contraseñas
`ib_input_required`	boolean	`false`	El botón predeterminado permanece desactivado mientras el campo esté vacío. Dejar enviar para reprender después no sirve a nadie; el botón de cancelar sigue accesible. Una cuenta atrás en ese botón (`of_add_button_timed`) no lo pulsa mientras el campo esté vacío: se agota y el botón espera una mano. Un botón a la vez predeterminado y de cancelación también queda fuera de alcance: Esc y Alt+F4 cierran entonces el cuadro sin elección (`0`) . Solo espacios no rellenan el campo (el valor vuelve tal como se escribió)
`ib_input_multiline`	boolean	`false`	El campo admite varias líneas (un comentario, una dirección): Intro pasa a la línea siguiente, Ctrl+Intro responde con el botón predeterminado. Un campo enmascarado se queda en una línea
`il_input_max_length`	long	`0`	Número máximo de caracteres (`0` = sin límite); un valor inicial más largo se corta
`is_input_pattern`	string	`""`	Una expresión regular que el valor entero debe cumplir (`[0-9]{4}`: cuatro cifras). Mientras no la cumple, aparece un mensaje bajo el campo y el botón predeterminado queda fuera de alcance. Un campo vacío corresponde a `ib_input_required`
`is_input_error`	string	`""`	El mensaje mostrado bajo un valor que `is_input_pattern` rechaza (`""` = « Este valor no es válido. », traducido)
`ib_buttons_reverse`	boolean	`false`	Orden de los botones: `false` = de izquierda a derecha en el orden de adición; `true` = invertido
`ib_movable`	boolean	`true`	¿Se puede mover el cuadro? No tiene barra de título — pinta su propia tarjeta — así que Windows no tiene agarre sobre él: se lo damos, la tarjeta arrastra la ventana salvo lo que ya responde a un clic y el texto del mensaje, que se puede seleccionar. Verdadera por defecto, porque una modal que tapa justo lo que hay que leer para responder es una trampa. Póngala a falso para un cuadro que debe quedarse donde está . Un atajo como `of_info` conserva este ajuste
`ib_closable`	boolean	`false`	Esc y Alt+F4 en un cuadro sin botón de cancelación. `false` sigue a Windows: un cuadro con un solo botón se cierra por ese botón (`of_info` devuelve `1`), uno con varios (Sí / No) debe recibir respuesta — ninguna de las dos teclas lo cierra. `true` lo cierra sin elección: `of_show` devuelve `0`
`ib_sound`	boolean	`true`	El sonido de Windows del icono al abrirse (información, advertencia, error, pregunta). `false` = un cuadro silencioso. Un cuadro sin icono, o con su propia imagen, no suena
`is_position`	string	`POSITION_OWNER`	Centrado: `POSITION_OWNER` (sobre la ventana llamante) o `POSITION_SCREEN` (sobre la pantalla)
`il_min_width`	long	`0`	Anchura mínima en píxeles (`0` = automática, 320); nunca menos de 200
`il_max_width`	long	`0`	Anchura máxima en píxeles (`0` = automática): el texto se ajusta dentro de este límite; nunca menos de 200
`il_max_height`	long	`0`	Altura máxima en píxeles (`0` = automática): más allá, el cuerpo del mensaje se desplaza en lugar de agrandar la ventana
`il_accent`	long	`-1`	Color de acento de este cuadro: el botón predeterminado y la casilla lo toman, y el color de texto legible se deriva de él. `-1` (el valor por defecto) sigue a la aplicación. Un error en rojo, un éxito en verde, sin tocar el tema . Un atajo como `of_error` lo conserva: póngalo y luego llame al atajo

Constantes #

Constante	Valor	Uso
`ICON_INFORMATION`	`"information"`	Información neutra
`ICON_WARNING`	`"warning"`	Advertencia, acción arriesgada
`ICON_ERROR`	`"error"`	Fallo, error
`ICON_QUESTION`	`"question"`	Pregunta cerrada
`ICON_SUCCESS`	`"success"`	Confirmación de un éxito
`ICON_NONE`	`"none"`	Ningún icono
`POSITION_OWNER`	`"owner"`	Centrado sobre la ventana llamante
`POSITION_SCREEN`	`"screen"`	Centrado sobre la pantalla
`BUTTONS_OK`	`"ok"`	`of_messagebox`: Aceptar
`BUTTONS_OK_CANCEL`	`"okcancel"`	Aceptar / Cancelar
`BUTTONS_YES_NO`	`"yesno"`	Sí / No
`BUTTONS_YES_NO_CANCEL`	`"yesnocancel"`	Sí / No / Cancelar
`BUTTONS_RETRY_CANCEL`	`"retrycancel"`	Reintentar / Cancelar
`BUTTONS_ABORT_RETRY_IGNORE`	`"abortretryignore"`	Anular / Reintentar / Omitir

Métodos #

Método	Función
`of_add_button (string as_text)` → long	Añade un botón simple. Devuelve su índice a partir de 1
`of_add_button (string as_text, boolean ab_default, boolean ab_cancel)` → long	Lo mismo, marcando el botón como predeterminado (Intro) y/o de cancelación (Esc). Devuelve su índice, a partir de `1`
`of_add_button (string as_text, string as_icon, boolean ab_default, boolean ab_cancel)` → long	Lo mismo, con un icono en el botón. Devuelve su índice, a partir de `1`
`of_add_button_timed (string as_text, boolean ab_default, boolean ab_cancel, long al_enable_secs, long al_click_secs)` → long	Botón con cuenta atrás: permanece desactivado `al_enable_secs` segundos (con contador visible), y luego se pulsa solo al cabo de `al_click_secs` segundos (`0` = temporizador inactivo). Mientras un botón de cancelación siga en cuenta atrás, ni Esc ni Alt+F4 cierran el cuadro: la espera está para hacer leer. Devuelve su índice, a partir de `1`
`of_count ( )` → `long`	Devuelve el número de botones que lleva el cuadro. Se designan por su posición — la que devuelve `of_add_button` y la que devuelve `of_show` — por lo que no tienen clave: aquí no hay `of_keys_at` ni `of_has`
`of_show (long al_hwnd)` → long	Muestra el cuadro modal y devuelve el índice del botón pulsado. `0` = cerrado sin botón: una zona `[action]` o una elección (`of_action`), o Esc / Alt+F4 con `ib_closable`. Sin botón de cancelación, Esc y Alt+F4 responden con el único botón de un cuadro de un botón, y no cierran un cuadro que tiene varios — como Windows. Un valor negativo indica que no se pudo mostrar ningún cuadro: `-4`, o `-6` si falta el runtime de WebView2 — `of_get_last_error()` dice por qué. Si la ventana propietaria se cierra mientras el cuadro está abierto (un temporizador, un evento), el cuadro se va con ella y `of_show` devuelve `0`
`of_get_last_error ( )` → string	Por qué no se pudo abrir el último cuadro — cadena vacía si se abrió. Se lee tras un `of_show` (o un atajo como `of_info`) que devolvió un valor negativo, o tras un `of_choose` o un `of_prompt` que devolvió una cadena vacía
`of_checked ( )` → boolean	Estado de la casilla de verificación en el momento del último `of_show`
`of_input_value ( )` → string	Texto escrito en el último `of_show` (vacío si `ib_input` estaba desactivado)
`of_action ( )` → string	Id de la zona `[action=id]` pulsada — en el mensaje, el título, la instrucción, una etiqueta o la nota al pie — o clave de la elección pulsada; cadena vacía en caso contrario. Tal zona es una elección ofrecida en el propio texto: cierra el diálogo y `of_show` devuelve `0`. Una zona `[hyperlink=url]`, en cambio, se abre en el navegador y deja el diálogo abierto — el llamante está bloqueado en `of_show`, así que un enlace no puede ser una respuesta
`of_info (long al_hwnd, string as_title, string as_message)` → long	Diálogo de una línea, como lo es `MessageBox()`: icono de información y un solo botón Aceptar, devuelve `1`. Las etiquetas vienen de las traducciones de la biblioteca (6 idiomas) en lugar de escribirse en cada aplicación — esa es toda la razón de ser de estos atajos (negativo: ningún cuadro mostrado, ver `of_get_last_error`) Esc también devuelve `1`, como `MessageBox(…, OK!)`.
`of_warning (long al_hwnd, string as_title, string as_message)` → long	Icono de advertencia, un botón Aceptar. Devuelve `1` (negativo: ningún cuadro mostrado, ver `of_get_last_error`)
`of_error (long al_hwnd, string as_title, string as_message)` → long	Icono de error, un botón Aceptar. Devuelve `1` (negativo: ningún cuadro mostrado, ver `of_get_last_error`)
`of_success (long al_hwnd, string as_title, string as_message)` → long	Icono de éxito, un botón Aceptar. Devuelve `1` (negativo: ningún cuadro mostrado, ver `of_get_last_error`)
`of_confirm (long al_hwnd, string as_title, string as_message { , long al_default })` → long	Pregunta + Aceptar / Cancelar. Devuelve `1` = Aceptar, `2` = Cancelar (también Esc). `al_default` elige el botón predeterminado: `2` pone Intro en Cancelar, el valor seguro de una acción destructiva (`-5` fuera de rango) (negativo: ningún cuadro mostrado, ver `of_get_last_error`)
`of_yes_no (long al_hwnd, string as_title, string as_message { , long al_default })` → long	Pregunta + Sí / No. Devuelve `1` = Sí, `2` = No. Como un cuadro Sí / No de Windows, Esc y Alt+F4 no lo cierran: hay que responder (`ib_closable` = `true` les hace devolver `0`). `al_default` elige el botón predeterminado (`-5` fuera de rango) (negativo: ningún cuadro mostrado, ver `of_get_last_error`)
`of_yes_no_cancel (long al_hwnd, string as_title, string as_message { , long al_default })` → long	Pregunta + Sí / No / Cancelar. Devuelve `1`, `2`, `3` (Cancelar, también Esc). `al_default` elige el botón predeterminado (`-5` fuera de rango) (negativo: ningún cuadro mostrado, ver `of_get_last_error`)
`of_retry_cancel (long al_hwnd, string as_title, string as_message)` → long	Error + Reintentar / Cancelar, Reintentar predeterminado. Devuelve `1` = Reintentar, `2` = Cancelar (también Esc) (negativo: ningún cuadro mostrado, ver `of_get_last_error`)
`of_messagebox (long al_hwnd, string as_title, string as_text { , icon ae_icon { , button ae_buttons { , long al_default } } })` → long	El `MessageBox()` de PowerBuilder, argumento por argumento: ponga `lnv_mb.of_messagebox(Handle(this),` delante de una llamada `MessageBox(` y compila — `Question!`, `YesNo!` y el botón predeterminado tal como los había escrito. Devuelve el número del botón pulsado, como `MessageBox()` (Anular `1` / Reintentar `2` / Omitir `3`). Los textos se muestran tal cual: un corchete sigue siendo un corchete, `~r~n` pasa a la línea siguiente. Esc sigue a Windows: el botón Cancelar, el Aceptar de un botón solo, nada en Sí / No y Anular / Reintentar / Omitir. Las etiquetas están traducidas. `-5` con un botón predeterminado fuera de rango (no se muestra nada); otro valor negativo: ningún cuadro mostrado (`of_get_last_error`)
`of_messagebox (long al_hwnd, string as_title, string as_text, string as_icon { , string as_buttons { , long al_default } })` → long	Lo mismo, con cadenas: una constante `ICON_` (o su imagen) y una constante `BUTTONS_`. `-5` con un juego de botones desconocido. Devuelve el mismo número de botón (`1` para el primero).
`of_add_choice (string as_key, string as_title, string as_description { , boolean ab_enabled })` → long	Añade una opción bajo el mensaje — un título y una descripción, como los vínculos de comando de un cuadro de tareas de Windows. El clic cierra el cuadro y `of_action()` da su clave (`of_show` devuelve 0). Devuelve el rango de la opción (1 para la primera), `-5` con una clave vacía, ya usada o que contiene `/` o `	`— entonces no se añade nada . Con` ab_enabled `=` false`, la elección aparece atenuada y no se puede elegir (las flechas la saltan)
`of_choose (long al_hwnd)` → string	Muestra las opciones con un único botón Cancelar (traducido) y devuelve la clave de la opción pulsada, o una cadena vacía si el usuario canceló. La lista se desplaza cuando desborda la pantalla. Cadena vacía también cuando no se pudo mostrar ningún cuadro: `of_get_last_error` dice entonces por qué. Sin ninguna opción no se muestra nada: cadena vacía, y `of_get_last_error` dice «no choice to show» . Una zona `[action]` de los textos responde como una elección: vuelve su id
`of_prompt (long al_hwnd, string as_title, string as_message, string as_default { , boolean ab_password, boolean ab_required })` → string	Pide un valor y devuelve lo escrito, o una cadena vacía si el usuario canceló. Para distinguir una respuesta vacía de una cancelación, use `of_show` + `of_input_value`. Cadena vacía también cuando no se pudo mostrar ningún cuadro: `of_get_last_error` dice entonces por qué . Se respetan los ajustes del campo puestos antes (`is_input_label`, `ib_input_password`, `ib_input_multiline`, `is_input_pattern`…); la sobrecarga enmascara (`ab_password`) y exige (`ab_required`) solo para esa llamada
`of_reset ( )` → long	Borra todas las propiedades, los botones y elecciones añadidos y la respuesta del último diálogo (`of_checked`, `of_action`, `of_input_value`, `of_get_last_error`): la misma instancia vuelve a empezar de cero. Los atajos (`of_info`, `of_confirm`, `of_prompt`…) solo sustituyen el contenido: conservan el aspecto (acento, posición, desplazamiento, tamaños, orden de los botones, `ib_closable`, `ib_sound`) y los ajustes del campo Devuelve `0` una vez hecho.

La etiqueta de un botón acepta el texto enriquecido con etiquetas y el mnemotécnico & ("&Guardar" subraya la G y lo activa con Alt+G); && muestra un ampersand literal.

El teclado #

Tecla	Efecto
Intro	Activa el botón marcado como predeterminado — salvo cuando el foco está en otro botón o una elección: responde ese. En un campo de varias líneas, Intro pasa a la línea siguiente y Ctrl+Intro responde
Esc	Activa el botón marcado como cancelación; sin él, el único botón de un cuadro de un botón (`of_info` devuelve `1`), y nada en un cuadro con varios botones (Sí / No): hay que responder, como en Windows — salvo `ib_closable` = `true`, que lo cierra y devuelve `0`. Alt+F4 hace lo mismo. Mientras el botón de cancelación sigue en cuenta atrás (`of_add_button_timed`), ninguno de los dos cierra
Alt + letra	Activa el botón cuya etiqueta lleva ese acceso. Si varios lo llevan, el foco pasa de uno a otro sin responder (como en Windows): Intro elige
Tab	Mueve el foco de un elemento al siguiente: elecciones, campo, botón « Detalles », casilla, botones
Ctrl + C	Copia el cuadro (título, instrucción, mensaje, detalles, elecciones con su descripción, « etiqueta: valor » del campo — nunca una contraseña —, casilla con su estado `[x]` o `[ ]`, nota al pie, etiquetas de los botones) al portapapeles, como todo cuadro de Windows — práctico cuando un error debe remitirse al soporte. Con texto seleccionado en el mensaje, copia solo la selección
↑ ↓ Inicio Fin RePág AvPág	Recorren la lista de elecciones (una elección desactivada se salta); Intro elige la que tiene el foco
Alt + F8	Muestra u oculta una contraseña, desde el campo

Al abrirse, ningún botón tiene contorno de foco: es intencionado, y es el comportamiento de los cuadros de diálogo modernos de Windows. El borde solo aparece tras una primera pulsación de Tab, es decir, cuando el usuario pasa explícitamente al teclado. Intro y Esc permanecen activos desde el primer segundo, incluso sin foco visible.

Ejemplos #

Pregunta cerrada con botón predeterminado #

// Variables locales
n_pbt_messagebox lnv_mb
long ll_answer

// Crear el objeto de dialogo
lnv_mb = create n_pbt_messagebox

// Configurar el cuadro
lnv_mb.is_title   = "Guardar los cambios"
lnv_mb.is_icon    = lnv_mb.ICON_QUESTION
lnv_mb.is_message = "La carpeta se ha modificado. ¿Desea guardar antes de cerrar?"

// Agregar los botones
lnv_mb.of_add_button(/*text*/ "&Guardar",     /*default*/ true,  /*cancel*/ false)  // 1
lnv_mb.of_add_button(/*text*/ "&No guardar", /*default*/ false, /*cancel*/ false) // 2
lnv_mb.of_add_button(/*text*/ "Cancelar",          /*default*/ false, /*cancel*/ true)   // 3

// Mostrar en modal y liberar el objeto de dialogo
ll_answer = lnv_mb.of_show(/*hwnd*/ Handle(this))
destroy lnv_mb

// Actuar segun el boton pulsado (rango desde 1)
choose case ll_answer
    case 1 ; of_save() ; Close(parent)
    case 2 ; Close(parent)
    case else ; // 3 o 0 : no se cierra
end choose

Mensaje enriquecido e icono #

// Configurar el cuadro
lnv_mb.is_title   = "Importación finalizada"
lnv_mb.is_icon    = lnv_mb.ICON_SUCCESS
lnv_mb.is_message = "[b]1 240 líneas[/b] integradas.[br][br]" &
                  + "[accent]18 duplicados[/accent] se han ignorado."

// Agregar su boton y mostrar el cuadro
lnv_mb.of_add_button(/*text*/ "Aceptar", /*default*/ true, /*cancel*/ false)
lnv_mb.of_show(/*hwnd*/ Handle(this))

Un valor de sus datos en el mensaje #

El mensaje es texto enriquecido: un corchete es una etiqueta. El nombre de un cliente, un texto escrito por un usuario pasan por of_escape_markup (de n_pbt_utils) antes de entrar — si no, «García [action=x]» cerraría el cuadro como una opción.

// Variables locales
n_pbt_utils lnv_utils
string ls_name

// El nombre viene de la base de datos (aqui escrito a mano)
ls_name = "Smith [action=x] & Co"

// Escapar el nombre : se muestra tal cual
lnv_mb.is_title   = "Delete customer"
lnv_mb.is_message = "Delete the customer [b]" + lnv_utils.of_escape_markup(/*text*/ ls_name) + "[/b] ?"

// Agregar los botones, Cancelar predeterminado, y mostrar el cuadro
lnv_mb.of_add_button(/*text*/ "Delete", /*default*/ false, /*cancel*/ false)
lnv_mb.of_add_button(/*text*/ "Cancel", /*default*/ true, /*cancel*/ true)
lnv_mb.of_show(/*hwnd*/ Handle(this))

Casilla «no volver a preguntar» #

// Variables locales
n_pbt_messagebox lnv_mb

// Crear el objeto de dialogo
lnv_mb = create n_pbt_messagebox

// Configurar el cuadro
lnv_mb.is_title    = "Eliminación"
lnv_mb.is_icon     = lnv_mb.ICON_WARNING
lnv_mb.is_message  = "¿Eliminar las líneas seleccionadas? Esta acción es irreversible."
lnv_mb.is_checkbox = "No volver a preguntar"
lnv_mb.ib_checked  = false

// Agregar los botones
lnv_mb.of_add_button(/*text*/ "Eliminar", /*default*/ true,  /*cancel*/ false)
lnv_mb.of_add_button(/*text*/ "Cancelar",   /*default*/ false, /*cancel*/ true)

// Mostrar en modal y actuar sobre el primer boton
if lnv_mb.of_show(/*hwnd*/ Handle(this)) = 1 then
    of_delete()

    // Memorizar la eleccion del usuario
    ib_confirm_delete = not lnv_mb.of_checked()
end if

// Liberar el objeto de dialogo
destroy lnv_mb

Botón con cuenta atrás #

// Configurar el cuadro
lnv_mb.is_title   = "Reinicio"
lnv_mb.is_icon    = lnv_mb.ICON_INFORMATION
lnv_mb.is_message = "La aplicación se va a reiniciar para aplicar la actualización."

// "Continuar" permanece atenuado 3 segundos (se muestra un contador)
lnv_mb.of_add_button_timed(/*text*/ "Continuar", /*default*/ true, /*cancel*/ false, /*enable_secs*/ 3, /*click_secs*/ 0)

// "Mas tarde" se pulsa solo al cabo de 10 segundos
lnv_mb.of_add_button_timed(/*text*/ "Más tarde", /*default*/ false, /*cancel*/ true, /*enable_secs*/ 0, /*click_secs*/ 10)

// Mostrar en modal
lnv_mb.of_show(/*hwnd*/ Handle(this))

Mensaje largo: limitar el tamaño #

// Variables locales
string ls_notes

// Un texto voluminoso : el cuadro esta limitado y el cuerpo se desplaza
ls_notes = Fill("Lorem ipsum dolor sit amet. ", 200)
lnv_mb.is_title      = "Notas de la versión"
lnv_mb.is_message    = ls_notes
lnv_mb.il_max_width  = 480
lnv_mb.il_max_height = 320

// Agregar su boton y mostrar el cuadro
lnv_mb.of_add_button(/*text*/ "Cerrar", /*default*/ true, /*cancel*/ true)
lnv_mb.of_show(/*hwnd*/ Handle(this))

Reutilizar una instancia #

// Una instancia de ventana, varios dialogos : of_reset entre cada llamada
inv_mb.of_reset()      // borra las propiedades Y los botones anteriores

// Configurar el nuevo cuadro y mostrarlo
inv_mb.is_title   = "Segundo diálogo"
inv_mb.is_message = "Cada of_reset vuelve a empezar con un cuadro en blanco."
inv_mb.of_add_button(/*text*/ "Aceptar", /*default*/ true, /*cancel*/ false)
inv_mb.of_show(/*hwnd*/ Handle(this))

Migrar una llamada a `MessageBox()` #

of_messagebox toma los argumentos de MessageBox() en el mismo orden, con la ventana delante: un buscar y reemplazar migra una llamada, y los valores devueltos son los mismos.

// Variables locales
n_pbt_messagebox lnv_mb
long ll_answer

// Crear el objeto de dialogo
lnv_mb = create n_pbt_messagebox

// Los argumentos de MessageBox, la ventana delante : No es el boton predeterminado
ll_answer = lnv_mb.of_messagebox(/*hwnd*/ Handle(this), /*title*/ "Delete", /*text*/ "Delete the customer ?", /*icon*/ Question!, /*buttons*/ YesNo!, /*default*/ 2)

// Liberar el objeto de dialogo
destroy lnv_mb

// Los mismos numeros que MessageBox : 1 = Si, 2 = No
if ll_answer = 1 then
    of_delete()
end if

Una lista de elecciones #

// Variables locales
n_pbt_messagebox lnv_mb
string ls_format

// Crear el objeto de dialogo
lnv_mb = create n_pbt_messagebox

// La pregunta, y una eleccion por respuesta : una clave, un titulo, una descripcion
lnv_mb.is_title       = "Export"
lnv_mb.is_instruction = "How should the report leave ?"
lnv_mb.of_add_choice(/*key*/ "pdf", /*title*/ "PDF document", /*description*/ "One file, ready to send.")
lnv_mb.of_add_choice(/*key*/ "xlsx", /*title*/ "Excel workbook", /*description*/ "Figures stay figures.")

// Una eleccion que el usuario no puede tomar por ahora : atenuada
lnv_mb.of_add_choice(/*key*/ "fax", /*title*/ "Fax", /*description*/ "No fax line is configured.", /*enabled*/ false)

// Mostrar las elecciones con un solo boton Cancelar : vuelve la clave, "" si se cancela
ls_format = lnv_mb.of_choose(/*hwnd*/ Handle(this))

// Liberar el objeto de dialogo
destroy lnv_mb

// Actuar segun la clave
choose case ls_format
    case "pdf"
        of_export_pdf()
    case "xlsx"
        of_export_xlsx()
end choose

Pedir un valor #

// Variables locales
n_pbt_messagebox lnv_mb
string ls_name
long ll_answer

// Crear el objeto de dialogo
lnv_mb = create n_pbt_messagebox

// Una linea : devuelve lo escrito, "" si el usuario cancela
ls_name = lnv_mb.of_prompt(/*hwnd*/ Handle(this), /*title*/ "Rename", /*message*/ "New name of the report :", /*default*/ "Sales 2026")
if ls_name <> "" then
    of_rename(ls_name)
end if

// Un campo con una regla : cuatro cifras, si no Aceptar queda fuera de alcance
lnv_mb.of_reset()
lnv_mb.is_title         = "PIN"
lnv_mb.ib_input         = true
lnv_mb.is_input_label   = "PIN code"
lnv_mb.is_input_pattern = "[0-9]{4}"
lnv_mb.is_input_error   = "Four digits, please."
lnv_mb.of_add_button(/*text*/ "OK", /*default*/ true, /*cancel*/ false)
lnv_mb.of_add_button(/*text*/ "Cancel", /*default*/ false, /*cancel*/ true)

// of_show y luego of_input_value distinguen una respuesta vacia de una cancelacion
ll_answer = lnv_mb.of_show(/*hwnd*/ Handle(this))
if ll_answer = 1 then
    of_check_pin(lnv_mb.of_input_value())
end if

// Liberar el objeto de dialogo
destroy lnv_mb

Un informe de error: instrucción, detalles, nota al pie #

// Variables locales
n_pbt_messagebox lnv_mb
long ll_answer

// Crear el objeto de dialogo
lnv_mb = create n_pbt_messagebox

// La historia corta : la pregunta en grande, su consecuencia debajo
lnv_mb.is_title       = "Save failed"
lnv_mb.is_icon        = n_pbt_messagebox.ICON_ERROR
lnv_mb.is_instruction = "The order could not be saved"
lnv_mb.is_message     = "Another order already carries the number 4152."

// La historia larga, plegada : texto plano que el soporte copia con Ctrl+C
lnv_mb.is_details = "SQLSTATE = 23000~r~nViolation of PRIMARY KEY constraint 'pk_order'."

// Un enlace de ayuda bajo los botones, y el cuadro en rojo
lnv_mb.is_footer = "Read [hyperlink=https://example.com/help]what to do[/hyperlink]."
lnv_mb.il_accent = RGB(/*red*/ 196, /*green*/ 43, /*blue*/ 28)

// Agregar los botones y mostrar el cuadro
lnv_mb.of_add_button(/*text*/ "&Retry", /*default*/ true, /*cancel*/ false)
lnv_mb.of_add_button(/*text*/ "Cancel", /*default*/ false, /*cancel*/ true)
ll_answer = lnv_mb.of_show(/*hwnd*/ Handle(this))

// Un valor negativo : no se pudo mostrar ningun cuadro, el motivo se conserva
if ll_answer < 0 then
    of_log(lnv_mb.of_get_last_error())
end if

// Liberar el objeto de dialogo
destroy lnv_mb

Una elección en la frase #

// Variables locales
n_pbt_messagebox lnv_mb

// Crear el objeto de dialogo
lnv_mb = create n_pbt_messagebox

// Una zona [action] es una respuesta ofrecida en el propio texto
lnv_mb.is_title   = "Disk full"
lnv_mb.is_icon    = n_pbt_messagebox.ICON_WARNING
lnv_mb.is_message = "The folder is full. [action=folder]Open the folder[/action] to make room."
lnv_mb.of_add_button(/*text*/ "Cancel", /*default*/ false, /*cancel*/ true)

// La zona cierra el cuadro : of_show devuelve 0 y of_action su id
if lnv_mb.of_show(/*hwnd*/ Handle(this)) = 0 and lnv_mb.of_action() = "folder" then
    of_open_folder()
end if

// Liberar el objeto de dialogo
destroy lnv_mb

Buenas prácticas #

Llame siempre a of_reset() antes de reconfigurar una instancia reutilizada: sin ello, los botones del diálogo anterior se suman a los nuevos.
Marque sistemáticamente un botón predeterminado y un botón de cancelación: quien usa el teclado espera Intro y Esc.
Compruebe el botón positivo (= 1), nunca el negativo: if of_yes_no(…) = 1 then elimina solo con un « Sí ». El cuadro no tiene cruz; sin botón de cancelación, Esc no cierra un cuadro Sí / No. Con ib_closable, el valor 0 (cerrado sin elección) se trata como la cancelación.
En una acción destructiva, ponga el botón predeterminado en Cancelar (of_confirm(…, 2), o /*default*/ true en Cancelar): un Intro maquinal no elimina nada.
Un atajo (of_info, of_error…) conserva el aspecto puesto antes: un il_accent rojo y luego of_error da un error en rojo.
Pase Handle(this) (o Handle(parent)) como ventana llamante: el cuadro se centra sobre ella y la modalidad afecta a la ventana correcta.
Reserve el rojo e ICON_ERROR para los errores reales; una confirmación corriente merece ICON_QUESTION.
Para una información que no requiere ninguna respuesta, prefiera una notificación no bloqueante: véase toaster.