Programmation GTK2 en Pascal/GtkFrame
Présentation.
Le contrôle GtkFrame permet de créer différentes zones dans une même fenêtre à l'aide de cadres qui peuvent avoir un titre afin de définir la zone.
Il est classé par différents auteurs dans les contrôles décoratifs, mais il pourrait également être dans les conteneurs.
Utilisation de base.
Création.
Le contrôle codice_1 étant très simple, il n'y a qu'une seule fonction de création :
 function gtk_frame_new(_label : Pgchar) : PGtkWidget;
Le paramètre codice_2 est tout simplement le texte qui sera affiché en haut à gauche du cadre (position par défaut).
Modification du texte.
Il peut arriver que dans votre application, le texte du cadre nécessite une modification. Bien entendu, le contrôle codice_1 est fourni avec toutes les fonctions nécessaires :
 procedure gtk_frame_set_label(frame : PGtkFrame; _label : Pgchar);
Le paramètre codice_4 est le contrôle codice_1 dont nous voulons modifier le texte, et codice_2 est le nouveau texte à inscrire. Cette fois encore, il faut utiliser une fonction de conversion pour le premier paramètre qui est cette fois GTK_FRAME.
Pour récupérer le texte du cadre, la fonction est :
 function gtk_frame_get_label(frame : PGtkFrame) : Pgchar;
Remplacer le texte par un contrôle.
Les cadres offrent aussi la possibilité de remplacer le texte par un contrôle quelconque (GtkImage, GtkStockItem, etc.) grâce à cette fonction :
 procedure gtk_frame_set_label_widget(frame : PGtkFrame; label_widget : PGtkWidget);
Et comme toujours, la fonction permettant de récupérer le contrôle affiché:
 function gtk_frame_get_label_widget(frame : PGtkFrame) : PGtkWidget;
Position du texte.
Par défaut, la position du texte est en haut à gauche du cadre, centré en hauteur par rapport à la ligne supérieure. Cela peut-être modifié avec cette fonction :
 procedure gtk_frame_set_label_align(frame : PGtkFrame; xalign : gfloat; yalign : gfloat);
Les valeurs codice_7 et codice_8 doivent être comprises entre 0.0 et 1.0.
Le paramètre codice_7 définit la position horizontale du texte. Une valeur de 0.0 positionne le texte à gauche du cadre, tandis qu'une valeur de 1.0 le positionne à droite. Évidemment, une valeur de 0.5 centrera le texte.
Quant à codice_8, il permet de définir la position verticale du texte par rapport à la ligne supérieure du cadre. Une valeur de 0.0 mettra le nom en dessous de la ligne et une valeur de 1.0 le mettra au-dessus de la ligne.
On peut, bien sûr, connaître les valeurs de positionnement avec les fonctions suivantes :
 procedure gtk_frame_get_label_align(frame : PGtkFrame; xalign : Pgfloat; yalign : Pgfloat);
Style du cadre.
Le style du cadre est donné par la configuration visuelle de ses lignes et plus précisément de l'ombre des lignes. Cette modification de fait avec cette fonction :
 procedure gtk_frame_set_shadow_type(frame : PGtkFrame; _type : TGtkShadowType);
Le paramètre type peut prendre cinq valeurs différentes :
Programme exemple.
Nous allons créer un programme très simple avec trois cadres différents.
Voilà le fichier codice_11 :
 program gtk039;
 uses glib2, gtk2;
 var
 pFenetre : PGtkWidget;
 pVBox : PGtkWidget;
 pBouton : PGtkWidget;
 pChampSaisie : PGtkWidget;
 pLabel : PGtkWidget;
 pCadre : array[1..3] of PGtkWidget;
 pHBox : array[1..3] of PGtkWidget;
 begin
 gtk_init(@argc, @argv);
 pFenetre := gtk_window_new(GTK_WINDOW_TOPLEVEL);
 gtk_window_set_position(GTK_WINDOW(pFenetre), GTK_WIN_POS_CENTER);
 gtk_window_set_default_size(GTK_WINDOW(pFenetre), 320, 200);
 gtk_window_set_title(GTK_WINDOW(pFenetre), 'Gtk039 : Cadres');
 gtk_signal_connect(pGTKOBJECT(pFenetre), 'destroy', G_CALLBACK(@gtk_main_quit), NULL);
 // Création de la GtkVBox
 pVBox := gtk_vbox_new(TRUE, 5);
 gtk_container_add(GTK_CONTAINER(pFenetre), pVBox);
 // Création des cadres, des contrôles à mettre dedans, etc.
 pCadre[1] := gtk_frame_new('Un GtkLabel');
 pLabel := gtk_label_new('Le label');
 gtk_container_add(GTK_CONTAINER(pCadre[1]), pLabel);
 gtk_box_pack_start(GTK_BOX(pVBox), pCadre[1], FALSE, FALSE, 0);
 pCadre[2] := gtk_frame_new('Un GtkButton');
 pBouton := gtk_button_new_with_label('Le bouton');
 pHBox[2] := gtk_hbox_new(TRUE, 5);
 gtk_box_pack_start(GTK_BOX(pHBox[2]), pBouton, TRUE, FALSE, 5);
 gtk_container_add(GTK_CONTAINER(pCadre[2]), pHBox[2]);
 gtk_box_pack_start(GTK_BOX(pVBox), pCadre[2], FALSE, FALSE, 0);
 gtk_frame_set_shadow_type(GTK_FRAME(pCadre[2]), GTK_SHADOW_IN);
 pCadre[3] := gtk_frame_new('Une GtkEntry');
 pChampSaisie := gtk_entry_new;
 pHBox[3] := gtk_hbox_new(TRUE, 5);
 gtk_box_pack_start(GTK_BOX(pHBox[3]), pChampSaisie, TRUE, FALSE, 5);
 gtk_container_add(GTK_CONTAINER(pCadre[3]), pHBox[3]);
 gtk_box_pack_start(GTK_BOX(pVBox), pCadre[3], TRUE, FALSE, 5);
 gtk_frame_set_shadow_type(GTK_FRAME(pCadre[3]), GTK_SHADOW_ETCHED_OUT);
 gtk_widget_show_all(pFenetre);
 gtk_main;
 end.
Voilà ce que donne l'exécution du programme codice_12 :

Livre de cuisine/Recettes de pâtes
L’expression pâtes fait référence aux s et autres produits fabriqués à partir de faite à partir de de blé dur, d'épeautre ou de différentes céréales, d'eau et parfois aussi d'œuf et de sel. Les pâtes peuvent également désigner les plats dont les pâtes sont l'ingrédient principal servis avec de la ou des assaisonnements.

Programmation C-C++/La fonction main
La fonction main.
Lorsqu'un programme est chargé, son exécution commence par l'appel d'une fonction spéciale du programme. Cette fonction doit impérativement s'appeler « main » (principal en anglais) pour que le compilateur puisse savoir que c'est cette fonction qui marque le début du programme. La fonction main est appelée par le système d'exploitation, elle ne peut pas être appelée par le programme, c'est-à-dire qu'elle ne peut pas être récursive.
Exemple - Programme minimal.
La fonction main doit renvoyer un code d'erreur d'exécution du programme, le type de ce code est int. Elle peut aussi recevoir des paramètres du système d'exploitation. Ceci sera expliqué plus loin. Pour l'instant, on se contentera d'une fonction main ne prenant pas de paramètre.
Note : Il est spécifié dans la norme du C++ que la fonction main ne doit pas renvoyer le type void. En pratique cependant, beaucoup de compilateurs l'acceptent également.
La valeur 0 retournée par la fonction main indique que tout s'est déroulé correctement. En réalité, la valeur du code de retour peut être interprétée différemment selon le système d'exploitation utilisé. La bibliothèque C définit donc les constantes codice_1 et codice_2, qui permettent de supprimer l'hypothèse sur la valeur à utiliser respectivement en cas de succès et en cas d'erreur.

Enseignement de l'anglais/The family, la famille

Retour Enseignement de l'anglais
Programmation C-C++/Entrée / sortie de base