messagebox — `n_pbt_messagebox` #

← Référence des composants · Sommaire du guide

Boîte de dialogue modale thémée, à retour synchrone : le remplaçant direct du MessageBox() de PowerBuilder, avec texte riche, boutons libres, icônes et case à cocher.

▶ Le voir en vrai — Application de démonstration, tuile Message box : l'aperçu, le code qui le produit et cette page, côte à côte.

En bref #

Objet	`n_pbt_messagebox` — non visuel : rien à poser dans la fenêtre
Sert à	Poser une question ou annoncer un résultat, à la place du `MessageBox()` natif figé et non thémé
Retour	Synchrone : `of_show()` bloque et renvoie l'indice du bouton cliqué

Contrairement aux composants visuels, cet objet ne s'insère pas dans une fenêtre : on le crée, configure, affiche, détruit.

// Variables locales
n_pbt_messagebox lnv_mb

// Creer l'objet de dialogue
lnv_mb = create n_pbt_messagebox

// ... configuration ...

// Liberer l'objet de dialogue
destroy lnv_mb

Démarrage rapide #

// Variables locales
n_pbt_messagebox lnv_mb

// Creer l'objet de dialogue
lnv_mb = create n_pbt_messagebox

// Configurer la boite
lnv_mb.is_title   = "Suppression"
lnv_mb.is_icon    = lnv_mb.ICON_WARNING
lnv_mb.is_message = "Supprimer definitivement [b]12 dossiers[/b] ?[br][br]Cette action est irreversible."

// Ajouter les boutons : Annuler est le bouton par defaut, Entree ne supprime rien
lnv_mb.of_add_button(/*text*/ "Supprimer", /*default*/ true,  /*cancel*/ false)   // -> 1
lnv_mb.of_add_button(/*text*/ "Annuler",   /*default*/ true,  /*cancel*/ true)    // -> 2

// Afficher en modal, puis agir sur le premier bouton
if lnv_mb.of_show(/*hwnd*/ Handle(this)) = 1 then
    of_delete()
end if

// Liberer l'objet de dialogue
destroy lnv_mb

of_show attend la réponse de l'utilisateur : la ligne suivante ne s'exécute qu'après le clic, exactement comme avec MessageBox().

Propriétés #

À poser avant of_show.

Propriété	Type	Défaut	Rôle
`is_title`	string	`""`	Titre affiché dans l'en-tête de la boîte
`is_message`	string	`""`	Corps du message. Accepte le balisage riche (`[b]`, `[i]`, `[br]`, `[accent]`, `[picture=…]`…). Le texte du message et de l'instruction se sélectionne et se copie. Une valeur qui vient de vos données passe d'abord par `of_escape_markup` : sinon un crochet y serait lu comme une balise — un `[action=x]` dans un nom de client fermerait la boîte
`is_instruction`	string	`""`	Instruction principale : la question elle-même, affichée plus grande au-dessus du message. Titre / instruction / message est l'anatomie qui rend un dialogue lisible d'un coup d'œil — « Supprimer 42 lignes ? » puis « Cette action est définitive » — au lieu d'un bloc uniforme. Accepte le balisage riche
`is_icon`	string	`""`	Icône : une constante `ICON_`, ou votre propre image* (chemin de fichier, ou ressource de DLL `ma.dll:NOM`)
`is_details`	string	`""`	Détails repliés sous le message derrière un bouton « Afficher les détails » : un rapport, une pile d'appels, une requête SQL. Texte brut dans une zone à chasse fixe qui défile — un crochet reste un crochet. Ctrl+C le copie même replié : c'est ce que demande le support
`is_details_label`	string	`""`	Libellé du bouton qui déplie `is_details` (`""` = « Afficher / Masquer les détails », traduit)
`is_footer`	string	`""`	Une note de pied sous les boutons : un lien d'aide, un rappel. Balisage riche ; un `[hyperlink]` y ouvre le navigateur et laisse la boîte ouverte
`is_footer_icon`	string	`""`	Petite icône devant le pied : une constante `ICON_*` ou votre image (`""` = aucune)
`is_checkbox`	string	`""`	Texte d'une case à cocher optionnelle, style « ne plus me demander » (`""` = pas de case)
`ib_checked`	boolean	`false`	État initial de la case (l'état final se lit avec `of_checked()`)
`ib_input`	boolean	`false`	Ajoute un champ de saisie thématisé (renommer, motif, commentaire), pour qu'une application n'ait plus à bricoler une fenêtre qui ne suit ni le thème ni le sens de lecture. La saisie se relit avec `of_input_value()` après `of_show`. Le tout en un appel : `of_prompt` — il respecte les réglages du champ posés avant (libellé, masque, obligation, multiligne, longueur, motif)
`is_input_label`	string	`""`	Libellé au-dessus du champ (`""` = aucun). Nécessite `ib_input` . Il nomme le champ pour un lecteur d'écran, et un clic dessus donne le focus au champ ; balisage riche accepté, une zone `[action]` y répond comme un choix
`is_input_value`	string	`""`	Contenu initial du champ. Il est sélectionné à l'ouverture : taper le remplace, comme dans tout dialogue de renommage
`is_input_placeholder`	string	`""`	Indication affichée tant que le champ est vide. Ce n'est pas une valeur : rien n'est renvoyé si l'utilisateur ne tape rien
`ib_input_password`	boolean	`false`	Masque les caractères saisis . Un œil au bout du champ les dévoile — à la souris, ou Alt+F8 au clavier. La valeur n'est jamais copiée par Ctrl+C ni proposée au gestionnaire de mots de passe
`ib_input_required`	boolean	`false`	Le bouton par défaut reste désactivé tant que le champ est vide. Laisser soumettre pour se faire rabrouer ensuite ne sert personne ; le bouton d'annulation, lui, reste accessible. Un compte à rebours posé sur ce bouton (`of_add_button_timed`) ne le clique pas tant que le champ est vide : il s'épuise et le bouton attend une main. Un bouton à la fois par défaut et d'annulation est hors de portée lui aussi : Échap et Alt+F4 ferment alors la boîte sans choix (`0`) . Des espaces seuls ne remplissent pas le champ (la valeur revient telle que tapée)
`ib_input_multiline`	boolean	`false`	Le champ prend plusieurs lignes (un commentaire, une adresse) : Entrée passe à la ligne, Ctrl+Entrée répond par le bouton par défaut. Un champ masqué reste sur une ligne
`il_input_max_length`	long	`0`	Nombre maximal de caractères (`0` = sans limite) ; une valeur initiale plus longue est coupée
`is_input_pattern`	string	`""`	Expression régulière que la valeur entière doit respecter (`[0-9]{4}` : quatre chiffres). Tant qu'elle ne la respecte pas, un message s'affiche sous le champ et le bouton par défaut reste hors de portée. Un champ vide relève de `ib_input_required`
`is_input_error`	string	`""`	Message affiché sous une valeur que `is_input_pattern` refuse (`""` = « Cette valeur n'est pas valide. », traduit)
`ib_buttons_reverse`	boolean	`false`	Ordre des boutons : `false` = de gauche à droite dans l'ordre d'ajout ; `true` = inversé
`ib_movable`	boolean	`true`	La boîte se déplace-t-elle ? Elle n'a pas de barre de titre — elle peint sa propre carte — donc Windows n'a aucune prise sur elle : on la lui donne, la carte tire la fenêtre sauf ce qui répond déjà au clic et le texte du message, qui se sélectionne. Vraie par défaut, parce qu'une modale qui recouvre justement ce qu'il faut lire pour répondre est un piège. Mettez-la à faux pour une boîte qui doit rester où elle est . Un raccourci comme `of_info` garde ce réglage
`ib_closable`	boolean	`false`	Échap et Alt+F4 sur une boîte sans bouton d'annulation. `false` suit Windows : une boîte à un seul bouton se ferme par ce bouton (`of_info` rend `1`), une boîte à plusieurs (Oui / Non) doit recevoir une réponse — aucune des deux touches ne la ferme. `true` la ferme sans choix : `of_show` rend `0`
`ib_sound`	boolean	`true`	Le son Windows de l'icône à l'ouverture (information, avertissement, erreur, question). `false` = une boîte silencieuse. Une boîte sans icône, ou avec votre propre image, ne joue rien
`is_position`	string	`POSITION_OWNER`	Centrage : `POSITION_OWNER` (sur la fenêtre appelante) ou `POSITION_SCREEN` (sur l'écran)
`il_min_width`	long	`0`	Largeur minimale en pixels (`0` = automatique, 320) ; jamais moins de 200
`il_max_width`	long	`0`	Largeur maximale en pixels (`0` = automatique) : le texte revient à la ligne dans cette limite ; jamais moins de 200
`il_max_height`	long	`0`	Hauteur maximale en pixels (`0` = automatique) : au-delà, le corps du message défile au lieu d'agrandir la fenêtre
`il_accent`	long	`-1`	Couleur d'accent de cette boîte : le bouton par défaut et la case à cocher la prennent, et la couleur de texte lisible en est tirée. `-1` (le défaut) suit l'application. Une erreur en rouge, un succès en vert, sans toucher au thème . Un raccourci comme `of_error` le garde : posez-le, puis appelez le raccourci

Constantes #

Constante	Valeur	Usage
`ICON_INFORMATION`	`"information"`	Information neutre
`ICON_WARNING`	`"warning"`	Avertissement, action risquée
`ICON_ERROR`	`"error"`	Échec, erreur
`ICON_QUESTION`	`"question"`	Question fermée
`ICON_SUCCESS`	`"success"`	Confirmation d'un succès
`ICON_NONE`	`"none"`	Aucune icône
`POSITION_OWNER`	`"owner"`	Centré sur la fenêtre appelante
`POSITION_SCREEN`	`"screen"`	Centré sur l'écran
`BUTTONS_OK`	`"ok"`	`of_messagebox` : OK
`BUTTONS_OK_CANCEL`	`"okcancel"`	OK / Annuler
`BUTTONS_YES_NO`	`"yesno"`	Oui / Non
`BUTTONS_YES_NO_CANCEL`	`"yesnocancel"`	Oui / Non / Annuler
`BUTTONS_RETRY_CANCEL`	`"retrycancel"`	Réessayer / Annuler
`BUTTONS_ABORT_RETRY_IGNORE`	`"abortretryignore"`	Abandonner / Réessayer / Ignorer

Méthodes #

Méthode	Rôle
`of_add_button (string as_text)` → long	Ajoute un bouton simple. Renvoie son indice à partir de 1
`of_add_button (string as_text, boolean ab_default, boolean ab_cancel)` → long	Idem, en marquant le bouton par défaut (Entrée) et/ou d'annulation (Échap). Renvoie son indice à partir de `1`
`of_add_button (string as_text, string as_icon, boolean ab_default, boolean ab_cancel)` → long	Idem, avec une icône sur le bouton. Renvoie son indice à 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	Bouton à compte à rebours : reste désactivé `al_enable_secs` secondes (compteur visible), puis se clique tout seul au bout de `al_click_secs` secondes (`0` = minuteur inactif). Tant qu'un bouton d'annulation compte encore à rebours, ni Échap ni Alt+F4 ne ferment la boîte : le délai est là pour faire lire. Renvoie son indice à partir de `1`
`of_count ( )` → `long`	Rend le nombre de boutons que la boîte porte. Ils se désignent par leur rang — celui que rend `of_add_button`, celui que rend `of_show` — donc ils n'ont pas de clé : il n'y a ici ni `of_keys_at` ni `of_has`
`of_show (long al_hwnd)` → long	Affiche la boîte modale et renvoie l'indice du bouton cliqué. `0` = fermée sans bouton : une zone `[action]` ou un choix (`of_action`), ou Échap / Alt+F4 avec `ib_closable`. Sans bouton d'annulation, Échap et Alt+F4 répondent par le seul bouton d'une boîte à un bouton, et ne ferment pas une boîte qui en a plusieurs — comme Windows. Une valeur négative dit qu'aucune boîte n'a pu s'afficher : `-4`, ou `-6` si le runtime WebView2 manque — `of_get_last_error()` dit pourquoi. Si la fenêtre propriétaire se ferme pendant la boîte (un minuteur, un événement), la boîte part avec elle et `of_show` rend `0`
`of_get_last_error ( )` → string	Pourquoi la dernière boîte n'a pas pu s'ouvrir — chaîne vide si elle s'est ouverte. À lire après un `of_show` (ou un raccourci comme `of_info`) qui a rendu une valeur négative, ou après un `of_choose` ou un `of_prompt` qui a rendu une chaîne vide
`of_checked ( )` → boolean	État de la case à cocher au moment du dernier `of_show`
`of_input_value ( )` → string	Texte saisi lors du dernier `of_show` (vide si `ib_input` était inactif)
`of_action ( )` → string	Identifiant de la zone `[action=id]` cliquée — dans le message, le titre, l'instruction, un libellé ou le pied de page — ou clé du choix cliqué ; chaîne vide sinon. Une telle zone est un choix proposé dans le texte même : elle ferme le dialogue et `of_show` renvoie `0`. Une zone `[hyperlink=url]`, elle, s'ouvre dans le navigateur et laisse le dialogue ouvert — l'appelant est bloqué dans `of_show`, un lien ne peut donc pas être une réponse
`of_info (long al_hwnd, string as_title, string as_message)` → long	Dialogue en une ligne, comme l'est `MessageBox()` : icône d'information et un seul bouton OK, renvoie `1`. Les libellés des boutons viennent des traductions de la bibliothèque (6 langues) au lieu d'être écrits dans chaque application — c'est toute la raison d'être de ces raccourcis (négatif : aucune boîte affichée, voir `of_get_last_error`) Échap aussi rend `1`, comme `MessageBox(…, OK!)`.
`of_warning (long al_hwnd, string as_title, string as_message)` → long	Icône d'avertissement, un bouton OK. Renvoie `1` (négatif : aucune boîte affichée, voir `of_get_last_error`)
`of_error (long al_hwnd, string as_title, string as_message)` → long	Icône d'erreur, un bouton OK. Renvoie `1` (négatif : aucune boîte affichée, voir `of_get_last_error`)
`of_success (long al_hwnd, string as_title, string as_message)` → long	Icône de réussite, un bouton OK. Renvoie `1` (négatif : aucune boîte affichée, voir `of_get_last_error`)
`of_confirm (long al_hwnd, string as_title, string as_message { , long al_default })` → long	Question + OK / Annuler. Renvoie `1` = OK, `2` = Annuler (Échap aussi). `al_default` choisit le bouton par défaut : `2` met Entrée sur Annuler, le défaut sûr d'une action destructrice (`-5` hors limites) (négatif : aucune boîte affichée, voir `of_get_last_error`)
`of_yes_no (long al_hwnd, string as_title, string as_message { , long al_default })` → long	Question + Oui / Non. Renvoie `1` = Oui, `2` = Non. Comme une boîte Oui / Non de Windows, Échap et Alt+F4 ne la ferment pas : il faut répondre (`ib_closable` = `true` leur fait rendre `0`). `al_default` choisit le bouton par défaut (`-5` hors limites) (négatif : aucune boîte affichée, voir `of_get_last_error`)
`of_yes_no_cancel (long al_hwnd, string as_title, string as_message { , long al_default })` → long	Question + Oui / Non / Annuler. Renvoie `1`, `2`, `3` (Annuler, Échap aussi). `al_default` choisit le bouton par défaut (`-5` hors limites) (négatif : aucune boîte affichée, voir `of_get_last_error`)
`of_retry_cancel (long al_hwnd, string as_title, string as_message)` → long	Erreur + Réessayer / Annuler, Réessayer par défaut. Renvoie `1` = Réessayer, `2` = Annuler (Échap aussi) (négatif : aucune boîte affichée, voir `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	Le `MessageBox()` de PowerBuilder, argument pour argument : placez `lnv_mb.of_messagebox(Handle(this),` devant un appel `MessageBox(` et il compile — `Question!`, `YesNo!` et le bouton par défaut tels que vous les aviez écrits. Renvoie le numéro du bouton pressé, comme `MessageBox()` (Abandonner `1` / Réessayer `2` / Ignorer `3`). Les textes s'affichent tels quels : un crochet reste un crochet, `~r~n` passe à la ligne. Échap suit Windows : le bouton Annuler, le OK d'un bouton seul, rien sur Oui / Non et Abandonner / Réessayer / Ignorer. Les libellés sont traduits. `-5` sur un bouton par défaut hors limites (rien ne s'affiche) ; une autre valeur négative : aucune boîte affichée (`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	La même, avec des chaînes : une constante `ICON_` (ou votre image) et une constante `BUTTONS_`. `-5` sur un jeu de boutons inconnu. Renvoie le même numéro de bouton (`1` pour le premier).
`of_add_choice (string as_key, string as_title, string as_description { , boolean ab_enabled })` → long	Ajoute un choix sous le message — un titre et une description, comme les liens de commande d'une boîte de tâche Windows. Le clic ferme la boîte et `of_action()` donne sa clé (`of_show` rend 0). Rend le rang du choix (1 pour le premier), `-5` sur une clé vide, déjà prise, ou qui contient `/` ou `	`— rien n'est alors ajouté . Avec` ab_enabled `=` false`, le choix s'affiche grisé et ne se choisit pas (les flèches le sautent)
`of_choose (long al_hwnd)` → string	Montre les choix avec un seul bouton Annuler (traduit) et rend la clé du choix cliqué, ou une chaîne vide si l'utilisateur a annulé. La liste défile quand elle dépasse l'écran. Chaîne vide aussi quand aucune boîte n'a pu s'afficher : `of_get_last_error` dit alors pourquoi. Sans aucun choix, rien ne s'affiche : chaîne vide, et `of_get_last_error` dit « no choice to show » . Une zone `[action]` des textes répond comme un choix : son identifiant revient
`of_prompt (long al_hwnd, string as_title, string as_message, string as_default { , boolean ab_password, boolean ab_required })` → string	Demande une valeur et renvoie ce qui a été saisi, ou une chaîne vide si l'utilisateur a annulé. Pour distinguer une réponse vide d'un abandon, utilisez plutôt `of_show` + `of_input_value`. Chaîne vide aussi quand aucune boîte n'a pu s'afficher : `of_get_last_error` dit alors pourquoi . Les réglages du champ posés avant sont respectés (`is_input_label`, `ib_input_password`, `ib_input_multiline`, `is_input_pattern`…) ; la surcharge masque (`ab_password`) et exige (`ab_required`) pour cet appel seulement
`of_reset ( )` → long	Efface toutes les propriétés, les boutons et les choix ajoutés et la réponse de la dernière boîte (`of_checked`, `of_action`, `of_input_value`, `of_get_last_error`) : la même instance repart d'une page blanche. Les raccourcis (`of_info`, `of_confirm`, `of_prompt`…) ne remplacent que le contenu : ils gardent l'apparence (accent, position, déplacement, tailles, ordre des boutons, `ib_closable`, `ib_sound`) et les réglages du champ Rend `0` une fois fait.

Le libellé d'un bouton accepte le balisage riche et le mnémonique & ("&Enregistrer" souligne le E et l'active par Alt+E) ; && affiche une esperluette littérale.

Le clavier #

Touche	Effet
Entrée	Déclenche le bouton marqué par défaut — sauf quand le focus est sur un autre bouton ou un choix : c'est lui qui répond. Dans un champ multiligne, Entrée passe à la ligne et Ctrl+Entrée répond
Échap	Déclenche le bouton marqué annulation ; sans lui, le seul bouton d'une boîte à un bouton (`of_info` rend `1`), et rien sur une boîte à plusieurs boutons (Oui / Non) : il faut répondre, comme sous Windows — sauf `ib_closable` = `true`, qui ferme et rend `0`. Alt+F4 fait de même. Tant que le bouton d'annulation décompte encore (`of_add_button_timed`), ni l'un ni l'autre ne ferme
Alt + lettre	Déclenche le bouton dont le libellé porte ce mnémonique. Si plusieurs le portent, le focus passe de l'un à l'autre sans répondre (comme sous Windows) : Entrée choisit
Tab	Passe le focus d'un élément au suivant : choix, champ, bouton « Détails », case à cocher, boutons
Ctrl + C	Copie la boîte (titre, instruction, message, détails, choix avec leur description, « libellé : valeur » du champ — jamais un mot de passe —, case avec son état `[x]` ou `[ ]`, pied de page, libellés des boutons) dans le presse-papiers, comme toute boîte Windows — pratique quand une erreur doit être transmise au support. Avec du texte sélectionné dans le message, copie la sélection seule
↑ ↓ Début Fin Pg.préc Pg.suiv	Parcourent la liste des choix (un choix désactivé est sauté) ; Entrée choisit celui qui a le focus
Alt + F8	Dévoile ou masque un mot de passe, depuis le champ

À l'ouverture, aucun bouton n'a de contour de focus : c'est voulu, et c'est le comportement des dialogues Windows modernes. Le liseré n'apparaît qu'après une première pression sur Tab, c'est-à-dire quand l'utilisateur passe explicitement au clavier. Entrée et Échap restent actifs dès la première seconde, même sans focus visible.

Exemples #

Question fermée avec bouton par défaut #

// Variables locales
n_pbt_messagebox lnv_mb
long ll_answer

// Creer l'objet de dialogue
lnv_mb = create n_pbt_messagebox

// Configurer la boite
lnv_mb.is_title   = "Enregistrer les modifications"
lnv_mb.is_icon    = lnv_mb.ICON_QUESTION
lnv_mb.is_message = "Le dossier a ete modifie. Voulez-vous enregistrer avant de fermer ?"

// Ajouter les boutons
lnv_mb.of_add_button(/*text*/ "&Enregistrer",     /*default*/ true,  /*cancel*/ false)  // 1
lnv_mb.of_add_button(/*text*/ "&Ne pas enregistrer", /*default*/ false, /*cancel*/ false) // 2
lnv_mb.of_add_button(/*text*/ "Annuler",          /*default*/ false, /*cancel*/ true)   // 3

// Afficher en modal, puis liberer l'objet de dialogue
ll_answer = lnv_mb.of_show(/*hwnd*/ Handle(this))
destroy lnv_mb

// Agir selon le bouton clique (son rang, a partir de 1)
choose case ll_answer
    case 1 ; of_save() ; Close(parent)
    case 2 ; Close(parent)
    case else ; // 3 ou 0 : on ne ferme pas
end choose

Message enrichi et icône #

// Configurer la boite
lnv_mb.is_title   = "Import termine"
lnv_mb.is_icon    = lnv_mb.ICON_SUCCESS
lnv_mb.is_message = "[b]1 240 lignes[/b] integrees.[br][br]" &
                  + "[accent]18 doublons[/accent] ont ete ignores."

// Ajouter son bouton, puis afficher la boite
lnv_mb.of_add_button(/*text*/ "OK", /*default*/ true, /*cancel*/ false)
lnv_mb.of_show(/*hwnd*/ Handle(this))

Une valeur de vos données dans le message #

Le message est du texte riche : un crochet y est une balise. Un nom de client, un libellé saisi par un utilisateur passent par of_escape_markup (de n_pbt_utils) avant d'y entrer — sinon « Dupont [action=x] » fermerait la boîte comme un choix.

// Variables locales
n_pbt_utils lnv_utils
string ls_name

// Le nom vient de la base de donnees (ici ecrit a la main)
ls_name = "Smith [action=x] & Co"

// Echapper le nom : il s'affiche tel quel
lnv_mb.is_title   = "Delete customer"
lnv_mb.is_message = "Delete the customer [b]" + lnv_utils.of_escape_markup(/*text*/ ls_name) + "[/b] ?"

// Ajouter les boutons, Annuler par defaut, puis afficher la boite
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))

Case « ne plus me demander » #

// Variables locales
n_pbt_messagebox lnv_mb

// Creer l'objet de dialogue
lnv_mb = create n_pbt_messagebox

// Configurer la boite
lnv_mb.is_title    = "Suppression"
lnv_mb.is_icon     = lnv_mb.ICON_WARNING
lnv_mb.is_message  = "Supprimer les lignes selectionnees ? Cette action est irreversible."
lnv_mb.is_checkbox = "Ne plus me demander"
lnv_mb.ib_checked  = false

// Ajouter les boutons
lnv_mb.of_add_button(/*text*/ "Supprimer", /*default*/ true,  /*cancel*/ false)
lnv_mb.of_add_button(/*text*/ "Annuler",   /*default*/ false, /*cancel*/ true)

// Afficher en modal, puis agir sur le premier bouton
if lnv_mb.of_show(/*hwnd*/ Handle(this)) = 1 then
    of_delete()

    // Memoriser le choix de l'utilisateur
    ib_confirm_delete = not lnv_mb.of_checked()
end if

// Liberer l'objet de dialogue
destroy lnv_mb

Bouton à compte à rebours #

// Configurer la boite
lnv_mb.is_title   = "Redemarrage"
lnv_mb.is_icon    = lnv_mb.ICON_INFORMATION
lnv_mb.is_message = "L'application va redemarrer pour appliquer la mise a jour."

// "Continuer" reste grise 3 secondes (un compteur s'affiche)
lnv_mb.of_add_button_timed(/*text*/ "Continuer", /*default*/ true, /*cancel*/ false, /*enable_secs*/ 3, /*click_secs*/ 0)

// "Plus tard" se clique tout seul au bout de 10 secondes
lnv_mb.of_add_button_timed(/*text*/ "Plus tard", /*default*/ false, /*cancel*/ true, /*enable_secs*/ 0, /*click_secs*/ 10)

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

Message long : limiter la taille #

// Variables locales
string ls_notes

// Un texte volumineux : la boite est plafonnee et le corps defile
ls_notes = Fill("Lorem ipsum dolor sit amet. ", 200)
lnv_mb.is_title      = "Notes de version"
lnv_mb.is_message    = ls_notes
lnv_mb.il_max_width  = 480
lnv_mb.il_max_height = 320

// Ajouter son bouton, puis afficher la boite
lnv_mb.of_add_button(/*text*/ "Fermer", /*default*/ true, /*cancel*/ true)
lnv_mb.of_show(/*hwnd*/ Handle(this))

Réutiliser une instance #

// Une instance de fenetre, plusieurs dialogues : of_reset entre chaque appel
inv_mb.of_reset()      // efface les proprietes ET les boutons precedents

// Configurer la nouvelle boite, puis l'afficher
inv_mb.is_title   = "Second dialogue"
inv_mb.is_message = "Chaque of_reset repart d'une boite vierge."
inv_mb.of_add_button(/*text*/ "OK", /*default*/ true, /*cancel*/ false)
inv_mb.of_show(/*hwnd*/ Handle(this))

Migrer un appel à `MessageBox()` #

of_messagebox prend les arguments de MessageBox() dans le même ordre, la fenêtre en tête : un rechercher-remplacer migre un appel, et les valeurs rendues sont les mêmes.

// Variables locales
n_pbt_messagebox lnv_mb
long ll_answer

// Creer l'objet de dialogue
lnv_mb = create n_pbt_messagebox

// Les arguments de MessageBox, la fenetre en tete : Non est le bouton par defaut
ll_answer = lnv_mb.of_messagebox(/*hwnd*/ Handle(this), /*title*/ "Delete", /*text*/ "Delete the customer ?", /*icon*/ Question!, /*buttons*/ YesNo!, /*default*/ 2)

// Liberer l'objet de dialogue
destroy lnv_mb

// Les memes nombres que MessageBox : 1 = Oui, 2 = Non
if ll_answer = 1 then
    of_delete()
end if

Une liste de choix #

// Variables locales
n_pbt_messagebox lnv_mb
string ls_format

// Creer l'objet de dialogue
lnv_mb = create n_pbt_messagebox

// La question, puis un choix par reponse : une cle, un titre, une description
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.")

// Un choix que l'utilisateur ne peut pas prendre pour l'instant : grise
lnv_mb.of_add_choice(/*key*/ "fax", /*title*/ "Fax", /*description*/ "No fax line is configured.", /*enabled*/ false)

// Montrer les choix avec un seul bouton Annuler : la cle revient, "" si annule
ls_format = lnv_mb.of_choose(/*hwnd*/ Handle(this))

// Liberer l'objet de dialogue
destroy lnv_mb

// Agir selon la cle
choose case ls_format
    case "pdf"
        of_export_pdf()
    case "xlsx"
        of_export_xlsx()
end choose

Demander une valeur #

// Variables locales
n_pbt_messagebox lnv_mb
string ls_name
long ll_answer

// Creer l'objet de dialogue
lnv_mb = create n_pbt_messagebox

// Une ligne : rend ce qui a ete tape, "" si l'utilisateur annule
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 champ avec une regle : quatre chiffres, sinon OK reste hors de portee
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 puis of_input_value distinguent une reponse vide d'une annulation
ll_answer = lnv_mb.of_show(/*hwnd*/ Handle(this))
if ll_answer = 1 then
    of_check_pin(lnv_mb.of_input_value())
end if

// Liberer l'objet de dialogue
destroy lnv_mb

Un rapport d'erreur : instruction, détails, pied de page #

// Variables locales
n_pbt_messagebox lnv_mb
long ll_answer

// Creer l'objet de dialogue
lnv_mb = create n_pbt_messagebox

// L'histoire courte : la question en grand, sa consequence dessous
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."

// L'histoire longue, repliee : du texte brut que le support copie par Ctrl+C
lnv_mb.is_details = "SQLSTATE = 23000~r~nViolation of PRIMARY KEY constraint 'pk_order'."

// Un lien d'aide sous les boutons, et la boite en rouge
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)

// Ajouter les boutons, puis afficher la boite
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))

// Une valeur negative : aucune boite n'a pu s'afficher, la raison est gardee
if ll_answer < 0 then
    of_log(lnv_mb.of_get_last_error())
end if

// Liberer l'objet de dialogue
destroy lnv_mb

Un choix dans la phrase #

// Variables locales
n_pbt_messagebox lnv_mb

// Creer l'objet de dialogue
lnv_mb = create n_pbt_messagebox

// Une zone [action] est une reponse offerte dans le texte meme
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 zone ferme la boite : of_show rend 0 et of_action donne son identifiant
if lnv_mb.of_show(/*hwnd*/ Handle(this)) = 0 and lnv_mb.of_action() = "folder" then
    of_open_folder()
end if

// Liberer l'objet de dialogue
destroy lnv_mb

Bonnes pratiques #

Toujours of_reset() avant de reconfigurer une instance réutilisée : sans cela les boutons du dialogue précédent s'ajoutent aux nouveaux.
Marquez systématiquement un bouton par défaut et un bouton d'annulation : l'utilisateur au clavier attend Entrée et Échap.
Testez le bouton positif (= 1), jamais le négatif : if of_yes_no(…) = 1 then supprime seulement sur un « Oui ». La boîte n'a pas de croix ; sans bouton d'annulation, Échap ne ferme pas une boîte Oui / Non. Avec ib_closable, la valeur 0 (fermée sans choix) se traite comme l'annulation.
Sur une action destructrice, mettez le bouton par défaut sur Annuler (of_confirm(…, 2), ou /*default*/ true sur Annuler) : un Entrée machinal ne supprime rien.
Un raccourci (of_info, of_error…) garde l'apparence posée avant : un il_accent rouge puis of_error donne une erreur en rouge.
Passez Handle(this) (ou Handle(parent)) comme fenêtre appelante : la boîte se centre dessus et la modalité porte sur la bonne fenêtre.
Réservez le rouge et ICON_ERROR aux vraies erreurs ; une confirmation banale mérite ICON_QUESTION.
Pour une information qui ne demande aucune réponse, préférez une notification non bloquante : voir toaster.