Licence CC BY-NC-SA

Les Widgets II : les boîtes de dialogue

Publié :

Nous continuons le chapitre précédent. Cette fois, nous nous attaquons à des widgets plus complexes, à savoir les boîtes de dialogue. Vous savez, toutes ces petites fenêtres qu'un logiciel peut ouvrir pour vous rappeler de sauvegarder avant de quitter, pour vous demander quel fichier vous souhaitez ouvrir ou comment vous allez paramétrer le logiciel. Toutes ces mini-fenêtres, simples ou complexes, s'appellent des boîtes de dialogue. Attention, leur fonctionnement est un peu plus complexe que celui des simples widgets vus jusque là donc je vous conseille d'être attentif.

Message

Fiche d'identité

  • Widget : Gtk_Message_Dialog.
  • Package : Gtk.Message_Dialog
  • Descendance : GTK_Widget >> GTK_Container >> GTK_Bin >> GTK_Window >> GTK_Dialog
  • Description : Cette boîte de dialogue permet l'affichage de messages courts : erreur, avertissement, information…

Boîte de dialogue : message

Méthodes

Contrairement aux widgets précédents, la méthode la plus complexe est ici le constructeur dont voici la spécification :

1
2
3
4
5
6
procedure Gtk_New(Dialog  : out Gtk_Message_Dialog;
                  Parent  : Gtk.Window.Gtk_Window := null;
                  Flags   : Gtk.Dialog.Gtk_Dialog_Flags := 0;
                  Typ     : Gtk_Message_Type := Message_Info;
                  Buttons : Gtk_Buttons_Type := Buttons_Close;
                  Message : String);

Une procédure Gtk_New_With_Markup() identique existe si jamais vous souhaitez utiliser des balises pour la mise en forme. Le paramètre Dialog est bien entendu votre boîte de dialogue. Le paramètre Parent correspond à la fenêtre principale, la fenêtre mère. Le paramètre Message correspond au message indiqué dans la boîte de dialogue. Venons-en maintenant aux trois autres paramètre. Flags peut prendre les valeurs suivantes :

  • Modal : si vous souhaitez désactiver la fenêtre mère le temps que votre boîte de dialogue est active. (la plus utile)
  • Destroy_With_Parent : pour indiquer que la fermeture de la fenêtre mère détruira la boîte de dialogue. Mais par défaut, ce paramètre devrait être actif quoi que vous fassiez.
  • 0 : si vous ne voulez indiquer aucun paramètre.

Ces valeurs sont situées dans le package Gtk.Dialog.

Le paramètre Typ indique le type de boîte de dialogue et donc l'image qui sera affichée (les valeurs possibles sont Message_Info, Message_Warning, Message_Question, Message_Error) ; le paramètres Buttons indique quant à lui le type et le nombre de boutons de la boîte (Buttons_None, Buttons_Ok, Buttons_Close, Buttons_Cancel, Buttons_Yes_No, Buttons_Ok_Cancel). Pour y voir plus clair, voici quelques exemples :

Message_Warning

Message_Error

Message_Question

Message_Info

N'oubliez pas d'afficher votre boîte de dialogue grâce à show_all ! Enfin, pour personnaliser davantage votre boîte de dialogue, vous pouvez modifier le titre de la fenêtre grâce à la méthode set_title() disponible pour les GTK_Window, modifier l'image grâce à set_image() ou ajouter un texte secondaire grâce à Format_Secondary_Text() et Format_Secondary_Markup() :

1
2
3
4
5
6
7
8
procedure Format_Secondary_Markup(Message_Dialog : access Gtk_Message_Dialog_Record ; 
                                  Message        : String); 
procedure Format_Secondary_Text  (Message_Dialog : access Gtk_Message_Dialog_Record ; 
                                  Message        : String); 

function  Get_Image(Dialog : access Gtk_Message_Dialog_Record) return Gtk.Widget.Gtk_Widget ; 
procedure Set_Image(Dialog : access Gtk_Message_Dialog_Record ; 
                    Image  : access Gtk.Widget.Gtk_Widget_Record'Class);

Les signaux

Pour utiliser une boîte de dialogue, nous n'allons pas utiliser de signaux. Nous allons utiliser la fonction run() présente dans le package GTK.Dialog :

1
function Run(Dialog : access Gtk_Dialog_Record) return Gtk_Response_Type;

Cette fonction affiche la boîte de dialogue (comme show ou show_all), crée une sorte de «mini-boucle infinie» et renvoie la réponse de l'utilisateur (a-t-il cliqué sur OK ou Annuler ?). Voici un exemple d'utilisation :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
...
   Win : GTK_Window ; 
   Msg : GTK_Message_Dialog ; 
BEGIN
...
      --Création de la boîte de dialogue Msg
   Gtk_New(Msg, Win, 0, Message_Error, Buttons_Ok_Cancel, "Ceci est un message d'erreur") ;
      --Affichage de la fenêtre prinicpale
   Win.Show_All ;
      --Affichage et attente d'une réponse de la boîte de dialogue
   IF Msg.Run = Gtk_Response_OK
         THEN --écrire ici les instructions 
   END IF ;
...

Le code ci-dessus crée une boîte de dialogue de type Erreur. L'utilisateur a deux boutons accessibles : OK et Cancel. S'il clique sur OK, run() renvoie comme Gtk_Response_Type la valeur suivante : Gtk_Response_OK. Le programme n'a alors plus qu'à gérer cette réponse. Voici une liste de réponses possibles :

  • Gtk_Response_Delete_Event : si l'utilisateur clique sur l'icône de fermeture de la barre de titre ;
  • Gtk_Response_OK : si l'utilisateur appuie sur le bouton Buttons_Ok ;
  • Gtk_Response_Cancel : si l'utilisateur appuie sur le bouton Buttons_Cancel ;
  • Gtk_Response_Close : si l'utilisateur appuie sur le bouton Buttons_Close ;
  • Gtk_Response_Yes : si l'utilisateur appuie sur le bouton Yes de Buttons_Yes_No ;
  • Gtk_Response_No : si l'utilisateur appuie sur le bouton No de Buttons_Yes_No ;

Mais… ma boîte de dialogue ne se ferme pas toute seule ! o_O

Vous devrez donc, lorsque vous traitez les réponses possibles, pensez à ajouter une instruction pour détruire la boîte de dialogue. Cette instruction est présente dans le package GTK.Widget (et est donc disponible pour n'importe quel widget, même les boutons, images ou conteneurs) :

1
procedure Destroy(Widget : access Gtk_Widget_Record);

À propos

Fiche d'identité

  • Widget : Gtk_About_Dialog.
  • Package : Gtk.About_Dialog
  • Descendance : GTK_Widget >> GTK_Container
  • Description : Ce widget est souvent utilisé lorsque l'utilisateur clique sur le menu «À propos» afin d'afficher le nom du logiciel , sa version, son auteur, son logo…

Boîte de dialogue : À propos

Méthodes

Le constructeur des GTK_About_Dialog est simplissime et ne prend qu'un seul paramètre. Concentrons nous donc sur l'apparence de cette boîte de dialogue :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
function Get_Comments (About    : access Gtk_About_Dialog_Record) return UTF8_String;
procedure Set_Comments(About    : access Gtk_About_Dialog_Record;
                       Comments : UTF8_String);

function Get_Copyright (About     : access Gtk_About_Dialog_Record) return UTF8_String;
procedure Set_Copyright(About     : access Gtk_About_Dialog_Record;
                        Copyright : UTF8_String);

function Get_License (About   : access Gtk_About_Dialog_Record) return UTF8_String;
procedure Set_License(About   : access Gtk_About_Dialog_Record;
                      License : UTF8_String);

function Get_Program_Name (About : access Gtk_About_Dialog_Record) return UTF8_String;
procedure Set_Program_Name(About : access Gtk_About_Dialog_Record;
                           Name  : UTF8_String);

function Get_Version (About   : access Gtk_About_Dialog_Record) return UTF8_String;
procedure Set_Version(About   : access Gtk_About_Dialog_Record;
                      Version : UTF8_String);

function Get_Website (About : access Gtk_About_Dialog_Record) return UTF8_String;
procedure Set_Website(About   : access Gtk_About_Dialog_Record;
                      Website : UTF8_String);

function Get_Website_Label (About : access Gtk_About_Dialog_Record) return UTF8_String;
procedure Set_Website_Label(About         : access Gtk_About_Dialog_Record;
                            Website_Label : UTF8_String);

Les méthodes ci-dessus permettent d'obtenir ou de définir les commentaires (description succincte du logiciel), le copyright, la licence, le nom du programme, sa version actuelle, l'adresse du site web correspondant ainsi que le nom du site web (qui sera affiché à la place de l'adresse). Toutes ces méthodes manipulent des UTF8_String et il est possible de les mettre en forme comme nous l'avons vu avec les étiquettes. À noter que la création d'une licence engendre automatiquement la création du bouton du même nom. Si vous cliquez sur celui-ci, une seconde fenêtre de dialogue s'ouvrira. Il est également possible d'ajouter un troisième bouton, en plus des boutons License et Close : le bouton Credits.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
function Get_Artists (About   : access Gtk_About_Dialog_Record) return GNAT.Strings.String_List;
procedure Set_Artists(About   : access Gtk_About_Dialog_Record;
                      Artists : GNAT.Strings.String_List);

function Get_Authors (About   : access Gtk_About_Dialog_Record) return GNAT.Strings.String_List;
procedure Set_Authors(About   : access Gtk_About_Dialog_Record;
                      Authors : GNAT.Strings.String_List);


function Get_Documenters (About       : access Gtk_About_Dialog_Record) return GNAT.Strings.String_List;
procedure Set_Documenters(About       : access Gtk_About_Dialog_Record;
                          Documenters : GNAT.Strings.String_List);

function Get_Translator_Credits (About              : access Gtk_About_Dialog_Record) return UTF8_String;
procedure Set_Translator_Credits(About              : access Gtk_About_Dialog_Record;
                                 Translator_Credits : UTF8_String);

Les méthodes ci-dessus permettront de définir les artistes, les auteurs, les personnes ayant documentés le logiciel ainsi que les éventuels traducteurs. Les trois premières méthodes utilisent des GNAT.Strings.String_List qui ne sont rien de plus que des tableaux de pointeurs vers des strings. Voici par exemple comment renseigner la liste des artistes :

1
2
3
4
5
6
7
8
...
   List : String_List(1..2) ; 
BEGIN
...
   List(1) := NEW String'("Picasso") ;
   List(2) := NEW String'("Rembrandt") ;
   Ma_Boite_De_Dialogue.Set_Artists(List) ;
...

Si vous souhaitez consulter les spécifications du type String_List, ouvrez le package System.String (s-string.ads) car GNAT.String n'est qu'un surnommage. Enfin, vous pouvez également définir un logo à votre boîte de dialogue (en général, le logo du logiciel) :

1
2
3
function Get_Logo (About : access Gtk_About_Dialog_Record) return Gdk.Pixbuf.Gdk_Pixbuf;
procedure Set_Logo(About : access Gtk_About_Dialog_Record;
                   Logo  : access Gdk.Pixbuf.Gdk_Pixbuf_Record'Class);

C'est quoi ces pixbuf ?

Les Gdk_Pixbuf_Record sont en fait des images gérées de façon bas niveau par Gdk. Comme je ne souhaite pas perdre de temps supplémentaire sur les images, nous nous contenterons donc d'utiliser une des méthodes Get() prévues pour les GTK_Image. Celle-ci extrait un Gdk_Pixbuf d'une Gtk_Image :

1
2
3
4
5
6
7
...
   Image : GTK_Image ; 
BEGIN
...
   Gtk_New(Image,"adresse/du/fichier/image") ; 
   Ma_Boite_De_Dialogue.set_logo(img.get) ; 
...

Sélection de fichier

Fiche d'identité

  • Widget : Gtk_File_Chooser_Dialog et Gtk_File_Chooser_Dialog.
  • Package : Gtk.File_Chooser_Dialog et Gtk.File_Chooser_Dialog
  • Descendance : GTK_Widget >> GTK_Container >> GTK_Bin >> GTK_Window >> GTK_Dialog
  • Description : Ce widget permet de sélectionner un fichier ou un répertoire pour l'ouvrir ou l'enregistrer.

Boîte de dialogue : Sélection de fichier

Méthodes des GTK_File_Chooser_Dialog

Les GTK_File_Chooser_Dialog ne sont pas compliqués à créer :

1
2
3
4
procedure Gtk_New (Dialog : out Gtk_File_Chooser_Dialog;
                   Title  : String;
                   Parent : access Gtk.Window.Gtk_Window_Record'Class;
                   Action : Gtk.File_Chooser.File_Chooser_Action);

Le paramètre Title est bien entendu le titre de votre boîte de dialogue ("ouverture du fichier de sauvegarde" par exemple), Parent est le nom de la fenêtre parente, la fenêtre principale. Quant au paramètre Action, il indique le type de fenêtre désiré. Il peut prendre l'une des valeurs suivantes :

  • Action_Open : fenêtre pour ouvrir un fichier.
  • Action_Save : fenêtre pour sauvegarder un fichier. Elle comporte une ligne pour indiquer le nom du fichier à créer ainsi qu'un bouton pour créer un sous-répertoire.
  • Action_Select_Folder : fenêtre pour ouvrir un répertoire. Les fichiers sont automatiquement grisés.
  • Action_Create_Folder : fenêtre pour créer un répertoire.

Et c'est à peu près tout ce que vous pouvez faire avec une GTK_File_Chooser_Dialog.

Les GTK_File_Chooser (sans le Dialog)

Mais… il n'y a aucun bouton Ouvrir, Annuler ou Enregistrer ! À quoi ça sert ?

Les méthodes des GTK_File_Chooser_Dialog sont quelque peu limitées. Pour la personnaliser un peu (notamment en ajoutant quelques boutons), vous devrez récupérer le GTK_File_Chooser de votre GTK_File_Chooser_Dialog, car c'est lui que vous pourrez personnaliser. Pour effectuer la récupération, une méthode "+" est disponible dans le package GTK.File_Chooser_Dialog. Par exemple :

1
2
3
4
5
6
7
...
   Chooser : GTK_File_Chooser ; 
   Dialog  : GTK_File_Chooser_Dialog ; 
BEGIN
...
   Chooser := + Dialog ;   --Chooser pointera vers le GTK_File_Chooser contenu dans Dialog
...

Passons maintenant aux méthodes liées aux GTK_File_Chooser. Pour commencer, nous voudrions ajouter au moins un bouton à notre boîte de dialogue.

1
2
procedure Set_Extra_Widget (Chooser : Gtk_File_Chooser;
                            Extra_Widget : access Gtk_Widget_Record'Class);

La méthode Set_Extra_Widget() permet d'ajouter n'importe quel type de widget au bas de votre fenêtre : un bouton ou mieux ! Une boîte à boutons ! Maintenant voyons comment paramétrer notre boîte de dialogue :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
procedure Set_Action(Chooser : Gtk_File_Chooser;
                      Action : File_Chooser_Action);
function Get_Action (Chooser : Gtk_File_Chooser) return File_Chooser_Action;
                     ---------------
procedure Set_Select_Multiple(Chooser : Gtk_File_Chooser;
                              Select_Multiple : Boolean);
function Get_Select_Multiple (Chooser : Gtk_File_Chooser) return Boolean;
                     ---------------
procedure Set_Show_Hidden(Chooser : Gtk_File_Chooser;
                          Show_Hidden : Boolean);
function Get_Show_Hidden (Chooser : Gtk_File_Chooser) return Boolean;
                     ---------------
procedure Set_Current_Name(Chooser : Gtk_File_Chooser;
                           Name : UTF8_String);
function Set_Current_Folder(Chooser : Gtk_File_Chooser;
                            Filename : String) return Boolean;
function Get_Current_Folder(Chooser : Gtk_File_Chooser) return String;
function Get_Filename (Chooser : Gtk_File_Chooser) return String;

La méthode Set_Action() vous permet de redéfinir le type de fenêtre (sauvegarde, ouverture de fichier ou de répertoire) si jamais vous ne l'aviez pas déjà fait. La méthode Set_Select_Multiple() permet de définir si l'utilisateur peut sélectionner un unique fichier (le paramètre select_multiple valant FALSE) ou bien plusieurs (select_multiple valant TRUE).

De la même manière, Set_Show_Hidden() permet d'afficher les fichiers cachés (si Show_Hidden = TRUE) ou pas. La méthode Set_Current_Name() n'est utile que pour des boîtes de dialogue de sauvegarde car elle permet de définir un nom par défaut à votre sauvegarde. Cette méthode peut vous être très utile pour des sauvegardes de partie en fournissant un titre par défaut, par exemple du genre "Nomdujoueur-jour-mois-annee.sav". De la même manière, Set_Current_Folder() permet de définir un répertoire par défaut à l'ouverture de la boîte de dialogue ; très utile notamment si vous souhaitez que l'utilisateur enregistre ses sauvegardes dans un même répertoire prévu à cet effet.

Enfin, la méthode Get_Filename() permettra à vos callbacks d'obtenir l'adresse du fichier sélectionné afin de pouvoir l'ouvrir. Attention, il s'agit de l'adresse absolue et non relative du fichier, c'est à dire du chemin complet.

Et si je veux ouvrir plusieurs fichiers en même temps ?

Là, les choses se compliquent un petit peu. Vous utiliserez la méthode suivante :

1
function Get_Filenames(Chooser : Gtk_File_Chooser) return Gtk.Enums.String_SList.GSlist;

Vous aurez sûrement remarqué le S supplémentaire dans le nom de la méthode ainsi que le type du résultat : Gtk.Enums.String_SList.GSlist. Cela signifie que vous devrez utiliser le package Gtk.Enums et ajouter une clause « USE Gtk.Enums.String_SList » (car il s'agit d'un sous-package interne à Gtk.Enums) pour utiliser ces GSList. Qu'est-ce qu'une GSList ? C'est la contraction de «generic single-linked list», soit «liste générique simplement chaînée» (vous devriez comprendre ce que cela signifie désormais).

Vous trouverez les méthodes associées dans le package Glib.GSlist. Notamment, vous aurez besoin des méthodes ci-dessous. La première, Length() renvoie la longueur de la chaîne (celles-ci étant indexées de 0 à «Longueur-1») tandis que la seconde renvoie la donnée numéro N de la GSList.

1
2
3
4
5
function Length (List : in GSlist)
                 return Guint;
function Nth_Data (List : in GSlist;
                   N : in Guint)
                   return Gpointer;

Voici un exemple d'utilisation de ces méthodes avec un callback appelé lorsque l'utilisateur appuie sur le bouton OK :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
PROCEDURE Ok_Action(Emetteur : ACCESS GTK_Button_Record'Class ; 
                    F : Gtk_File_Chooser_Dialog) IS
   PRAGMA Unreferenced(Emetteur) ;
   USE Gtk.Enums.String_SList ;
   L : Gslist ;
BEGIN
   L := Get_Filenames(+F);         --On récupère les noms de fichiers du File_chooser de F
   FOR I IN 0..Length(L)-1 LOOP    --On affiche les noms de la liste. 
      Put_Line(Nth_data(L,I)) ;    --Attention, elle est indexée à partir de 0 ! Il y a donc
   END LOOP ;                      --Un décalage dans les indices
   F.destroy ;                     --Enfin on détruit la boîte de dialogue
END Ok_Action ;

Deux widgets supplémentaires

Enfin, il est possible d'ajouter deux derniers widgets : un prévisualiseur de fichier et un filtre. Le prévisualiseur est un widget de votre cru affichant une miniature du contenu du fichier sélectionné. Par exemple, certains logiciels de graphisme affichent une miniature de vos photos avant que vous ne les ouvriez pour de bon. Cela peut facilement s'ajouter à l'aide des méthodes :

1
2
3
procedure Set_Preview_Widget(Chooser : Gtk_File_Chooser;
                             Preview_Widget : access Gtk.Widget.Gtk_Widget_Record'Class);
function Get_Preview_Widget (Chooser : Gtk_File_Chooser) return Gtk.Widget.Gtk_Widget;

Les filtres, quant à eux permettent de filtrer les fichiers, de n'en afficher qu'une partie seulement selon des critères :

Des filtres

Pour cela vous devrez créer un filtre, c'est-à-dire un widget de type Gtk_File_Filter disponible via le package Gtk.File_Filter. Vous y trouverez les méthodes ci-dessous :

1
2
3
4
5
6
7
--le constructeur, sans commentaires
procedure Gtk_New(Filter : out Gtk_File_Filter);
   --pour définir le texte à afficher
procedure Set_Name(Filter : access Gtk_File_Filter_Record; Name : String);
   --pour définir les critères, nous allons voir celui-ci plus en détail
procedure Add_Pattern(Filter  : access Gtk_File_Filter_Record;
                      Pattern : String);

Je ne m'attarde pas sur les deux premières méthodes, plutôt évidentes. En revanche, la troisième est importante : c'est elle qui fixe la règle d'affichage. Ces règles correspondent aux règles utilisées sous la console. Exemple :

1
2
Filtre1.Add_Pattern("*") ;     --affiche tous les fichiers (* signifie n'importe quels caractères)
Filtre2.Add_Pattern("*.txt") ; --n'affiche que les fichiers se finissant par ".txt"

Une fois vos filtres créés, vous pourrez les ajouter ou les supprimer de vos Gtk_File_Chooser grâce aux méthodes :

1
2
3
4
procedure Add_Filter   (Chooser : Gtk_File_Chooser;
                        Filter : access Gtk.File_Filter.Gtk_File_Filter_Record'Class);
procedure Remove_Filter(Chooser : Gtk_File_Chooser;
                        Filter : access Gtk.File_Filter.Gtk_File_Filter_Record'Class);

Signaux des Gtk_File_Chooser

Les Gtk_File_Chooser_Dialog n'apportent pas de nouveaux signaux. En revanche, les Gtk_File_Chooser ont quelques signaux utiles :

  • Signal_Current_Folder_Changed / "current-folder-changed" : émis lorsque l'utilisateur change de dossier ;
  • Signal_File_Activated / "file-activated" : émis lorsque l'utilisateur double-clique sur un fichier ou presse la touche entrée ;
  • Signal_Selection_Changed / "selection-changed" : émis lorsque l'utilisateur modifie sa sélection ;
  • Signal_Update_Preview / "update-preview" : émis lorsque le prévisualiseur doit être mis à jour.

Sélection de police

Fiche d'identité

  • Widget : Gtk_Font_Selection_Dialog et Gtk_Font_Selection.
  • Package : Gtk.Font_Selection_Dialog ou plus directement Gtk.Font_Selection.
  • Descendance : GTK_Widget >> GTK_Container >> GTK_Bin >> GTK_Window >> GTK_Dialog.
  • Description : Cette boîte de dialogue permet de sélectionner une police, une taille et un style. Elle affiche également un aperçu de la mise en forme obtenue.

Boîte de dialogue : Sélection de police

Méthodes

Les Gtk_Font_Selection_Dialog présentent assez peu de méthodes. Elles peuvent se résumer à ceci :

1
2
3
4
5
procedure Gtk_New(Widget : out Gtk_Font_Selection_Dialog; 
                  Title : UTF8_String);
function Set_Font_Name(Fsd      : access Gtk_Font_Selection_Dialog_Record;
                       Fontname : String) return Boolean;
function Get_Font_Name(Fsd : access Gtk_Font_Selection_Dialog_Record) return String;

Le constructeur n'exige rien de plus qu'un titre pour votre fenêtre. Ensuite, la méthode Get_Font_Name() vous permet de récupérer une chaîne de caractères contenant le nom de la police suivi éventuellement du style (gras, italique…) puis de la taille.

À noter que les Gtk_Font_Selection_Dialog définis dans le même package ont des méthodes identiques. La différence réside dans le fait qu'ils peuvent être insérés dans des fenêtres plus complexes.

Sélection de couleur

Fiche d'identité

  • Widget : Gtk_Color_Selection_Dialog et Gtk_Color_Selection.
  • Package : Gtk.Color_Selection_Dialog et Gtk.Color_Selection.
  • Descendance : GTK_Widget >> GTK_Container >> GTK_Bin >> GTK_Window >> GTK_Dialog.
  • Description : Cette boîte de dialogue permet de sélectionner une couleur.

Boîte de dialogue : Sélection de couleur

Méthodes

Là encore, les méthodes sont très limitées. Le constructeur ne demande qu'un titre pour votre boîte de dialogue. En revanche, pour manipuler ce widget, vous devrez récupérer son Gtk_Color_Selection à l'aide de la méthode Get_Colorsel() :

1
2
function Get_Colorsel(Color_Selection_Dialog : access Gtk_Color_Selection_Dialog_Record) 
   return Gtk.Color_Selection.Gtk_Color_Selection;

Une fois le Gtk_Color_Selection récupéré, vous pourrez connaître ou fixer la couleur actuelle à l'aide des deux méthodes suivantes :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
--Fixer ou obtenir la couleur actuelle
procedure Set_Current_Color(Colorsel : access Gtk_Color_Selection_Record;
                            Color    : Gdk.Color.Gdk_Color);
procedure Get_Current_Color(Colorsel : access Gtk_Color_Selection_Record;
                            Color    : out Gdk.Color.Gdk_Color);
--Fixer ou obtenir l'ancienne couleur
procedure Set_Previous_Color(Colorsel : access Gtk_Color_Selection_Record;
                             Color    : Gdk.Color.Gdk_Color);
procedure Get_Previous_Color(Colorsel : access Gtk_Color_Selection_Record;
                             Color    : out Gdk.Color.Gdk_Color);

La couleur obtenue se présente sous la forme d'une variable composite Gdk_Color (oui je sais, c'est notre première variable Gdk ^^ ). Pour la manipuler, utilisez le package Gdk.Color et les méthodes suivantes :

1
2
3
4
5
procedure Set_Rgb (Color : out Gdk_Color; Red, Green, Blue : Guint16);
function Red (Color : Gdk_Color) return Guint16;
function Green (Color : Gdk_Color) return Guint16;
function Blue (Color : Gdk_Color) return Guint16;
function To_String (Color : Gdk_Color) return String;

Set_Rgb() vous permettra de définir votre propre couleur à partir de ses valeurs RGB (Rouge Vert et Bleu). Attention, celles-ci sont définies de 0 à 65535 et pas de 0 à 255. À l'inverse, les fonctions Red(), Green(), Blue() vous permettront de connaître chacune des composantes de votre couleur, tandis que To_String() vous renverra le code hexadécimal HTML de votre couleur (#92D06C dans l'exemple ci-dessus).

Signaux

Le seul signal nouveau apporté par les Gtk_Color_Selection est le signal Signal_Color_Changed / "color_changed" indiquant que l'utilisateur a changé la couleur.

Cas général

Fiche d'identité

  • Widget : Gtk_Dialog.
  • Package : Gtk.Dialog
  • Descendance : GTK_Widget >> GTK_Container >> GTK_Bin >> GTK_Window
  • Description : Il s'agit là de la boîte de dialogue mère, personnalisable à volonté. Par défaut, Gtk considère qu'une boîte de dialogue est une fenêtre coupée en deux. La partie haute comprend divers widgets, tandis que la partie basse, appelée Zone d'actions, comprend des boutons rangés horizontalement.

Méthodes

Nous avons déjà vu bon nombre de méthodes des GTK_Dialog comme les constructeurs ou la méthode run(), mais en voici quelques-unes qui pourraient vous être utile pour personnaliser vos boîtes de dialogue (y compris celles vues précédemment) :

1
2
3
4
5
6
7
function Get_Action_Area (Dialog : access Gtk_Dialog_Record) return Gtk.Box.Gtk_Box;
function Get_Content_Area(Dialog : access Gtk_Dialog_Record) return Gtk.Box.Gtk_Box;
function Get_Vbox        (Dialog: access Gtk_Dialog_Record)  return Gtk.Box.Gtk_Box;

function Add_Button(Dialog      : access Gtk_Dialog_Record;
                    Text        : UTF8_String;
                    Response_Id : Gtk_Response_Type) return Gtk.Widget.Gtk_Widget;

Les trois premières méthodes permettent respectivement de récupérer la zone d'action, la zone de contenu et le conteneur principal de votre boîte de dialogue afin de les personnaliser. La fonction Add_Button() crée un bouton, tout en l'ajoutant à la zone d'action de votre boîte de dialogue (pas besoin de set_extra_widget() par exemple). Le paramètre Text est bien entendu le texte du bouton, Responde_Id est quant à lui le type de réponse qu'il renverra (ce sont les fameux Gtk_Response_# vus au début de cette partie).

Signaux

Enfin, voici deux signaux généraux aux boîtes de dialogue :

  • Signal_Close / "close" : émis lorsque l'utilisateur appuie sur la touche Echap.
  • Signal_Response / "response" : émis lorsque l'utilisateur clique sur l'un des widgets de la zone d'action (en général sur un bouton).

En résumé :

  • Pour afficher messages, options ou informations sur votre logiciel, ne créez pas de nouvelles GTK_Window, mais utilisez plutôt les diverses boîtes de dialogue mises à votre disposition.
  • Pour connaître l'action choisie par l'utilisateur, le résultat de la boîte de dialogue, n'utilisez pas les signaux mais la fonction Run().
  • La fonction Run() exécute automatiquement la boîte de dialogue alors évitez d'utiliser plusieurs IF ou ELSIF imbriqués. Privilégiez les CASE.