Le Manuel de Programmation de KDevelop: L'Éditeur de Boîtes de Dialogue : Où vos Boîtes de Dialogue sont Construites

Page suivante Page précédente Table des matières

### 6. L'Éditeur de Boîtes de Dialogue : Où vos Boîtes de Dialogue sont Construites

### 6.1 Ce que fournit l'Éditeur de boîtes de dialogue

L'éditeur de boîtes de dialogue interne à KDevelop est conçu pour vous aider à construire les widgets et les boîtes de dialogue qui correspondent aux besoins de votre application et réduit significativement le temps nécessaire pour étendre l'interface graphique utilisateur (NdT : GUI) de votre application. La seule limitation actuelle est que l'éditeur de boîtes de dialogue ne supporte pas la gestion de la mise en page qui est proposée par Qt ; c'est pourquoi les boîtes de dialogue ont des tailles statiques et cela peut conduire à des situations où, par exemple, la largeur d'une étiquette (NdT : label) n'est pas assez grande pour contenir toute la longueur de sa traduction.

D'un autre côté, l'état courant de l'éditeur, associé à la gestion de projets de KDevelop, reste la façon la plus rapide de créer des applications aux fonctionnalités nombreuses pour l'Environnement de Bureau KDE.

### 6.2 Widgets de Qt et KDE

Actuellement, les widgets supportés sont :

Widgets de Qt :

- QWidget - un widget qui peut être spécifié par vous-même et peut contenir aussi d'autres widgets. Cela permet de créer une hiérarchie de widgets dans une boîte de dialogue ;
- QLabel - une étiquette qui représente une information de type texte sur le widget. Utilisez QLabel, par exemple, devant des zones de saisie pour indiquer l'objectif de la zone de saisie ou quelle variable, par exemple, une liste déroulante permet de définir ;
- QPushButton - un bouton qui permet, par exemple, d'appeler une autre boîte de dialogue (comme QFileDialog pour sélectionner un nom de fichier) ;
- QCheckBox - une case à cocher pour, par exempe, activer/désactiver des options. QCheckBox est largement utilisé dans les boîtes de dialogue de configuration ;
- QLCDNumber - affiche des nombres dans le style LCD. Souvent utilisé pour des horloges ;
- QRadioButton - Comme QCheckBox, souvent utilisé pour laisser l'utilisateur choisir des options. QRadioButton spécialise le choix des options lorsqu'elles dépendent les unes des autres, par exemple, vous avez trois boutons radio mais vous voulez que l'utilisateur sélectionne une des trois options données. Consultez `QButtonGroup` pour plus d'informations ;
- QComboBox - une liste déroulante permet à l'utilisateur de choisir une valeur en la sélectionnant dans un menu qui se déroule vers le bas ou en insérant la valeur, s'il est possible d'y écrire ;
- QListBox - fournit une liste à une seule colonne d'éléments qui peut défiler ;
- QListView - crée une liste multi-colonnes qui peut être utilisée pour afficher, par exemple, des arborescences de fichiers ou des tables ;
- QMultiLineEdit - fournit un éditeur multi-lignes ;
- QProgressBar - affiche la progression d'une action qui demande beaucoup de temps pour se terminer ;
- QSpinBox - permet de choisir des valeurs numériques avec des boutons haut/bas ou en insérant la valeur, si l'écriture est activée ;
- QSlider - définit, avec une glissière, une valeur dans une plage définie par le programme ;
- QScrollBar - indique l'étendue d'une valeur et définit la valeur courante grâce à un "ascenseur" ainsi que des boutons haut/bas ; souvent utilisé pour des widgets dont le contenu est plus grand que la zone de vue réellement visible. En utilisant la barre de défilement, la zone visible peut être déplacée vers une autre partie du contenu du widget ;
- QGroupBox - fournit une zone de cadre avec un titre pour indiquer que les widgets fils appartiennent à la même zone.

Widgets KDE :

- KColorButton - un bouton (NdT : pushbutton) affichant une couleur sélectionnée. Lors d'un appui sur le bouton, la boîte de dialogue de Sélection de couleur de KDE est affichée, dans laquelle l'utilisateur peut choisir une autre couleur. Souvent utilisé pour les applications de dessin ou, dans tous les cas, quand une couleur doit être définie ;
- KCombo - similaire à `QComboBox`. Permet à l'utilisateur de choisir une valeur dans un menu déroulant ;
- KDatePicker - un widget complet pour laisser l'utilisateur choisir une valeur de date ;
- KDateTable - une table de calendrier pour sélectionner une date dans un mois. Utilisé par `KDatePicker` pour créer la boîte de dialogue de choix de date ;
- KKeyButton - un bouton pour sélectionner une valeur de touche. Si le bouton est sélectionné, il devient actif. Appuyer sur une touche du clavier changera la valeur de touche du bouton. Souvent utilisé pour configurer des raccourcis clavier ;
- KLed - un widget de LED (Light Emitting Diode) pour afficher un certain état ;
- KLedLamp - une lampe LED qui supporte aussi les actions de clic ;
- KProgress - similaire à `QProgressBar`, `KProgress` supporte d'autres valeurs ;
- KRestrictedLine - un `QLineEdit` qui accepte seulement certaines entrées de l'utilisateur. Peut être utilisé pour restreindre l'accès à certaines données par des boîtes de dialogue de mot de passe ;
- KSeparator - un widget de séparation à utiliser, dans tous les cas, lorsque les applications KDE nécessitent un séparateur pour fournir un affichage unique. Souvent utilisé dans des boîtes de dialogue pour séparer logiquement certaines parties si `QGroupBox` ne convient pas ;
- KTreeList - une liste développable/réductible (NdT : collapsible list) pour afficher des arborescences comme `QListView`.

### 6.3 Propriétés des Widgets Qt supportés

Le chapitre suivant donne une vision complète des widgets de la boîte à outils Qt actuellement supportés. Pour avoir une meilleure compréhension des propriétés, elles sont séparées de leur héritage. Comme tous les widgets héritent de `QWidget`, cette classe est décrite en premier. Toutes les propriétés de `QWidget` sont disponibles pour tous les autres widgets donc elles ne seront pas listées à chaque fois. Pour les groupes de widgets qui héritent d'une sous-classe abstraite de `QWidget` comme classe de base, les propriétés de la classe de base sont listées en premier (bien que cette classe ne représente pas elle-même un widget dans l'éditeur de boîtes de dialogue). Ensuite, les propriétés du widget pour le widget disponible du groupe contiennent les propriétés qui lui sont spécifiques. Pour une meilleure compréhension, l'arbre d'héritage des widgets disponibles est donné ci-dessous :

- QWidget
  - QButton (abstrait)
    - QCheckBox
    - QPushButton
    - QRadioButton
  - QComboBox
  - QFrame (actuellement abstrait)
    - QGroupBox
    - QLCDNumber
    - QLabel
    - QProgressBar
    - QScrollView (actuellement abstrait)
      - QListView
    - QSpinBox
    - QTableView (abstrait)
      - QListBox
      - QMultiLineEdit
  - QLineEdit
  - QScrollBar
  - QSlider

#### Propriétés de QWidget

`QWidget` est la classe de base pour presque tous les widgets dans Qt et KDE. Les widgets qui héritent de `QWidget` permettront donc d'utiliser les mêmes paramètres dans la plupart des cas.

- Apparence :
  - BgColor: Couleur du fond du widget
  - BgMode : Mode du fond du widget
  - BgPalColor : Palette de couleur du fond
  - BgPixmap : Nom du fichier pour une image de fond
  - Cursor : Curseur au-dessus du widget
  - Font : Police du widget
  - MaskBitmap : Nom du fichier pour le bitmap de masque
- Code C++ :
  - AcceptsDrops : si défini à true, l'élément du widget acceptera les "dépots" par les mécanismes de glisser-déposer (NdT : drag'n drop mechanisms ) (le protocole de "glisser-déposer" de Qt , pas celui de KDE 1.x !)
  - Connections : connecte les signaux de l'élément aux slots
  - FocusProxy : l'élément qui donne son focus au widget.
  - HasFocus : définit si, par défaut, le widget a le focus. Notez que seulement un élément par boîte de dialogue peut avoir cette valeur à true
  - ResizeToParent : redimensionne le widget à la taille de son parent (non visible en mode édition)
  - VarName : Nom de variable de l'élément. Changez-le avec le nom qui décrit le but de l'élément.
- Général :
  - IsEnabled : définit si le widget acceptera les événements utilisateur
  - IsHidden : définit si l'élément est visible (false) ou caché (true)
  - Name : définit le nom du widget. Notez que le nom est différent de VarName dans le code C++.
- Géométrie :
  - Height : hauteur de l'élément
  - IsFixedSize :
  - MaxHeight : valeur maximale de Height
  - MaxWidth : valeur maximale de Width
  - MinHeight : valeur minimale de Height
  - MinWidth : valeur minimale de Width
  - SizeIncX : nombre de pixels pour le redimensionnement dans la direction X
  - SizeIncY : nombre de pixels pour le redimensionnement dans la direction Y
  - Width : largeur de l'élément
  - X : position horizontale (abscisse), comptée depuis le coin gauche
  - Y : position verticale (ordonnée), comptée du haut vers le bas

#### Widgets qui héritent de QButton

`QButton` est une classe de widget abstraite qui fournit des propriétés communes aux boutons.

Hérite de QWidget

Hérité par QCheckBox, QPushButton et QRadioButton.

- Apparence :
  - setPixmap : définit le nom du fichier de pixmap à utiliser
- Général :
  - setText : le texte sur les étiquettes, boutons et cases ; pré-définit aussi le texte pour les zones de saisie.
  - setAutoRepeat : si activé, le signal clicked() est émis à des intervalles réguliers lorsque le bouton est enfoncé. Aucun effet sur les boutons à bascule (NdT : toggle buttons).
  - setAutoResize : active l'auto-redimensionnement si true. Quand l'auto-redimensionnement est actif, le bouton se redimensionne lui-même lorsque son contenu a changé.

#### Propriétés de QCheckBox

Hérite de QWidget et QButton

- Général :
  - isChecked : (setChecked) définit si la case à cocher est cochée lors de sa construction

#### Propriétés de QPushButton

Hérite de QWidget et QButton

- Général :
  - isAutoDefault : (setAutoDefault) le bouton automatiquement par défaut (NdT : auto-default button) devient le bouton par défaut s'il reçoit le focus du clavier.
  - isDefault : (setDefault) il ne peut y a voir qu'un seul bouton par défaut et il est seulement autorisé dans les boîtes de dialogue (voir `QDialog`). Le bouton par défaut émet `clicked()` si l'utilisateur a appuyé sur la touche "Entrée".
  - isMenuButton : (setIsMenuButton) indique au bouton de dessiner un triangle d'indication de menu s'il est activé. Le menu doit être inséré séparément.
  - isToggleButton : (setToggleButton) fait d'un bouton un bouton à bascule, si bien que le bouton se comporte comme une case à cocher.
  - isToggledOn : (setOn) (public slot) bascule un bouton dans l'état "on".

#### Propriétés de QRadioButton

Hérite de QWidget et QButton

- Général :
  - isChecked : (setChecked) définit si le bouton radio est coché lors de la construction

#### Propriétés de QComboBox

Hérite de QWidget

(aucune propriété supplémentaire)

#### Widgets qui héritent de QFrame

Hérite de QWidget

Pour l'instant, seulement utilisée comme une classe abstraite.

- Apparence :
  - Margin (setMargin) : définit la marge, qui est la distance entre le pixel le plus à l'intérieur du cadre et celui qui est le plus à l'extérieur du contenu.

#### Propriétés de QGroupBox

Hérite de QWidget et QFrame

- Général :
  - Title : (setTitle) définit le titre du groupe d'éléments qui est affiché dans le cadre.

#### Propriétés de QLCDNumber

Hérite de QWidget et QFrame

- Général :
  - NumDigits : (setNumDigits) définit le nombre de chiffres affichés dans QLCDNumber
  - Value : (display) (public slot) définit la valeur initiale de QLCDNumber

#### Propriétés de QLabel

Hérite de QWidget et QFrame

- Apparence :
  - Margin (setMargin) : définit la marge qui est, pour QLabel, la distance du cadre à la première lettre du texte de l'étiquette, suivant l'alignement de l'étiquette.
- Code C++ :
  - Buddy : (setBuddy) définit le widget compagnon de l'étiquette.
- Général :
  - Text : (setText) définit le texte de l'étiquette.
  - isAutoResize : (setAutoResize) si true, l'étiquette se redimensionnera elle-même si son contenu a changé. Le coin en haut à gauche n'est pas déplacé.

#### Propriétés de QProgressBar

Hérite de QWidget et QFrame

- Général :
  - TotalSteps : (setTotalSteps) (public slot) définit le nombre total d'étapes de la barre de progression. Durant l'itération de l'action dont vous voulez afficher la progression, vous devez appeler setProgress(int) pour faire avancer l'étape de progression affichée à (int).

#### QScrollView

Hérite de QWidget et QFrame

Hérité par QListBox (abstrait pour l'instant)

Fournit un widget que l'on peut faire défiler et qui gère l'affichage d'un widget fils avec des barres de défilement verticale et horizontale.

#### QListView

Hérite de QWidget, QFrame et QListView

Fournit une liste pour afficher hiérarchiquement des données, soit dans une table soit dans un arbre. Gère elle-même les barres de défilement à travers QScrollView.

- Apparence :
  - ListViewFont : (setFont()) définit la police des éléments de la ListView
  - ListViewPalette : (setPalette()) définit la palette des éléments de la ListView
  - TreeStepSize : (setTreeStepSize(int)) décalage en pixels entre un élément fils et son élément père
  - hScrollBarMode : mode de barre de défilement fourni par QScrollView pour la barre de défilement horizontale
  - isAllColumnsShowFocus : (setAllColumnsShowFocus(bool)) affiche le focus sur toutes les colonnes d'un élément
  - isMultiSelection : active les multi-sélections des éléments de la liste
  - isRootDecorated : active les symboles + et - pour ouvrir et fermer les arbres
  - vScrollBarMode : mode de barre de défilement fourni par QScrollView pour la barre de défilement verticale
- Général :
  - Entries : vous permet d'insérer une liste d'entrées qui sont pré-définies comme QListViewItems.
  - isAutoUpdate :

#### Propriétés de QSpinBox

Hérite de QWidget et QFrame

- Général :
  - MaxValue : définit la valeur maximale que l'utilisateur peut choisir
  - MinValue : définit la valeur minimale que l'utilisateur peut choisir
  - Prefix :
  - Suffix :
  - Value : valeur pré-définie quand le widget est affiché
  - isWrapping :

#### Widgets qui héritent de QTableView

Hérite de QWidget, QFrame et QTableView

Hérité par QListBox et QMultiLineEdit

#### Propriétés de QListBox

Hérite de QWidget, QFrame et QTableView

- Général :
  - isAutoBottomScrollBar: (setAutoBottomScrollBar)
  - isAutoScroll : (setAutoScroll)
  - isAutoScrollBar : (setAutoScrollBar)
  - isAutoUpdate : (setAutoUpdate)
  - isBottomScrollBar : (setBottomScrollBar)
  - isDragSelect : (setDragSelect)
  - isSmoothScrolling : (setSmoothScrolling)
- Géométrie :
  - setFixedVisibleLines : définit une hauteur fixe pour le widget de façon à ce que le nombre de lignes de texte donné soit affiché en utilisant la police courante.

#### Propriétés de QMultiLineEdit

Hérite de QWidget, QFrame et QTableView

- Général :
  - Text : (setText) (public slot) définit le texte du widget
  - isAutoUpdate : (setAutoUpdate) utilisé pour éviter le scintillement pendant de grandes modifications ; la vue n'est pas rafraîchie si désactivé.
  - isOverWriteMode : (setOverwriteMode) (public slot) définit si le mode écrasement est activé ou non.
  - isReadOnly : (setReadOnly) (public slot) rend le texte du widget en lecture seule ; désactive les entrées de texte.
  - isTextSelected : (selectAll)(public slot) marque tout le texte comme sélectionné
- Géométrie :
  - setFixedVisibleLines: définit une hauteur fixe pour le widget de façon à ce que le nombre de lignes de texte donné soient affichées en utilisant la police courante.

#### Propriétés de QLineEdit

Hérite de QWidget

- Général :
  - CursorPosition : (setCursorPosition) définit la position du curseur par défaut
  - MaxLength : (setMaxLength) définit la longueur maximale de la chaîne de caractères
  - Text : (setText) (public slot) définit le contenu affiché lors de la construction
  - hasFrame : (setFrame) dessine la zone de saisie dans un cadre de deux pixels, si activé
  - isTextSelected : (selectAll) (public slot) définit le texte à sélectionner.

#### Propriétés de QScrollBar

Hérite de QWidget et `QRangeControl`.

- Général :
  - MaxValue : définit la valeur maximale de la barre de défilement ; utilisé dans le constructeur (optionnel)
  - MinValue : définit la valeur minimale de la barre de défilement ; utilisé dans le constructeur (optionnel)
  - Orientation : (setOrientation) définit l'orientation de la barre de défilement à horizontale ou verticale
  - Value : définit la valeur initiale de la barre de défilement ; utilisé dans le constructeur (optionnel)
  - isTracking : (setTracking) si activé, la barre de défilement émet le signal `valueChanged()` lorsque la barre est déplacée ; sinon, seulement lorsque le bouton de la souris est relâché.

#### Propriétés de QSlider

Hérite de QWidget et `QRangeControl`.

- Général :
  - MaxValue : définit la valeur maximale de la glissière ; utilisé dans le constructeur (optionnel)
  - MinValue : définit la valeur minimale de la glissière ; utilisé dans le constructeur (optionnel)
  - Orientation : (setOrientation) définit l'orientation de la glissière à horizontale ou verticale
  - Value : (setValue) (public slot) utilise `QRangeControl::setValue()` pour définir la valeur
  - isTracking :(setTracking) si activé, la glissière émet le signal `valueChanged()` lorsque la barre est déplacée ; sinon, seulement lorsque le bouton de la souris est relâché.

### 6.4 Propriétés des Widgets KDE supportés

- QWidget
  - QButton (abstrait)
    - QPushButton
      - KColorButton
      - KKeyButton
  - QComboBox
    - KCombo
  - QFrame (abstrait actuellement)
    - KDatePicker
    - KLedLamp
    - KProgress
    - KSeparator
    - QTableView (abstrait)
      - KDateTable
      - KTreeList
  - QLineEdit
    - KRestrictedLine
- KLed

#### KColorButton

Hérite de QPushButton

- Général :
  - DisplayedColor (setColor()) : la couleur affichée sur le bouton

#### KKeyButton

#### KCombo

Hérite de QComboBox

- Général :
  - Entries : liste des chaînes de caractères qui sont les entrées affichées dans la liste déroulante
  - Text : le texte affiché actuellement dans la liste déroulante
  - isAutoResize : redimensionne la liste déroulante à l'élément courant

#### KDatePicker

- Apparence :
  - FontSize : la taille de la police pour le sélecteur de date

#### KLedLamp

#### KProgress

#### KSeparator

- Général :
  - Orientation : définit l'orientation du séparateur à horizontale ou verticale ; par défaut, horizontale.

#### KDateTable

#### KTreeList

- Apparence :
  - TreeListBgColor
  - TreeListPalette
  - isBottomScrollbar
  - isScrollBar
  - isShowItemText
  - isSmoothScrolling
  - isTreeDrawing
- Général :
  - Entries
  - isAutoUpdate

#### KRestrictedLine

#### KLed

Hérite de QWidget

- Apparence :
  - LedColor : (setColor()) définit la couleur de la LED affichée

### 6.5 Construire une nouvelle boîte de dialogue

Élaborer une nouvelle boîte de dialogue est très facile si vous êtes déjà familier avec les applications de construction graphique. KDevelop permet de créer visuellement un widget et d'afficher son apparence telle qu'elle se présentera à l'utilisateur. En plus, vous pouvez avoir une prévisualisation de votre widget en sélectionnant "Aperçu" dans le menu "Affichage".

Pour commencer la construction d'une boîte de dialogue ou de n'importe quel widget, passez dans l'Éditeur de boîtes de dialogue et sélectionnez "Nouveau" dans le menu "Fichier". Sélectionnez "Boîte de dialogue Qt/KDE (*.kdevdlg)" dans la boîte de dialogue "Nouveau fichier" et saisissez le nom de fichier de la boîte de dialogue. Construisez votre boîte de dialogue et quand vous avez terminé, sélectionnez "Générer les fichiers sources complets" dans le menu "Construire".

Saisissez ensuite toutes les informations nécessaires dans la boîte de dialogue "Nouvelle boîte de dialogue". Ce sont :

1. l'héritage de la boîte de dialogue. Ceci est nécessaire parce que tout widget dérive au moins de `QWidget`. Au-delà des types de widgets fournis par Qt, vous pouvez hériter, par exemple, d'une classe abstraite que vous avez développée vous-même au sein de votre projet. Dans ce cas, sélectionnez "Personnalisé" et saisissez le chemin menant au fichier d'en-tête dans la zone de saisie en-dessous ;
2. le nom de la boîte de dialogue. Ceci définit le nom de la classe pour la boîte de dialogue générée. Sélectionnez un nom de classe décrivant explicitement ce que fait la boîte de dialogue ; au cas où vous héritez de `QDialog`, vous pourriez saisir un nom qui se termine par `Dlg` afin de vous aider à vous souvenir que c'est une boîte de dialogue. Les conventions de nommage devraient néanmoins correspondre à celles de KDE et Qt : utilisez des lettres majuscules pour votre nom de classe. Pour, par exemple, une boîte de sélection de taille de quadrillage (NdT : grid-size selection dialog), vous pourriez saisir `GridSizeDlg`.
3. les noms des fichiers générés. Ceux-ci sont pré-définis lorsque vous donnez le nom de la boîte de dialogue mais peuvent être modifiés utlérieurement. Si vous voulez utiliser d'autres noms de fichiers, la convention de nommage devrait respecter celle de KDE et Qt : les noms des fichiers sont écrits en minuscules et contiennent le nom de la classe afin de se rappeler rapidement quelle classe est à l'intérieur. Les fichiers de données qui doivent être définis contiendront ensuite le code généré qui construira votre boîte de dialogue. Après, vous ne devrez pas éditer ce fichier manuellement ; utilisez le fichier d'implantation pour les ajouts au code de construction de la boîte de dialogue et à l'implantation des méthodes.

La boîte de dialogue s'affiche ensuite sous la forme d'un widget avec un quadrillage. Comme l'éditeur de boîte de dialogue utilise cette grille pour positionner les widgets fils, vous pouvez modifier la taille du quadrillage avec l'entrée "Taille de la grille" dans le menu "Affichage", si la valeur prédéfinie ne vous convient pas.

Sélectionnez ensuite l'onglet "Widgets" dans la partie gauche et cliquez sur le bouton du widget que vous voulez ajouter à votre widget principal. Il apparaît immédiatement dans le coin en haut à gauche du widget principal et il est sélectionné dans un cadre redimensionnable. Ensuite, déplacez ou redimensionnez le widget avec la souris. Le curseur changera pour indiquer quelle action peut être effectuée à sa position courante.

Après avoir terminé la construction, sélectionnez "Générer les fichiers" dans le menu "Construire" ou cliquez sur le bouton correspondant de la barre d'outils. Les fichiers seront ensuite générés à l'endroit prédéfini et inclus dans vos fichiers sources. Une reconstruction ou un "make" compilera tous les fichiers générés dans votre projet et vous pourrez ajouter un appel au constructeur idoine pour créer une instance de la boîte de dialogue ou du widget. Pour les projets KDE, toutes les propriétés du widget qui seront visibles, par exemple le texte d'une étiquette, sont définies avec la macro `i18n()` de `kapp.h` pour permettre l'internationalisation. C'est pourquoi, vous devriez faire un "Exécuter make messages et fusionner" lorsque vous avez terminé la construction et l'implantation.

Pendant la création d'une boîte de dialogue ou d'un widget, vous devriez respecter les règles suivantes :

- Essayez de rester homogène ! C'est probablement la règle la plus importante dans la constructions d'éléments graphiques. Souvenez-vous qu'un utilisateur n'acceptera une application que si elle est simple à comprendre, quelle que soit la complexité des services qu'elle rend ;
- Ajoutez de l'aide partout où c'est possible avec des bulles d'aide, de l'aide "Qu'est-ce que c'est...?" ou de l'Aide rapide. Cela permet d'obtenir directement des informations sur l'utilité des composants graphiques ;
- Surveillez le focus du clavier ! Le générateur ne gère pas cela - cela doit être pris en considération lors de la construction d'un widget : sinon vous devrez réordonner manuellement votre code d'initialisation ce qui n'est pas une tâche très amusante. Le focus du clavier sur n'importe quel widget signifie l'ordre dans lequel les éléments obtiennent le focus d'entrée du clavier lorsque l'utilisateur appuie sue les touches "tab" ou "shift+tab". Ce serait très désagréable si le focus sautait d'un widget à un autre au lieu de passer au widget visible suivant, au-dessous ou à droite du widget courant. C'est pourquoi, vous devriez construire vos widgets de haut en bas et de gauche à droite afin de préserver une certaine homogénéité du focus.

### 6.6 Définir les Propriétés des Widgets

Les propriétés d'un widget peuvent facilement être définies avec les entrées de la fenêtre des propriétés. Quand un widget devient sélectionné, la fenêtre des propriétés est automatiquement mise à jour avec les propriétés du widget courant. Comme tous les widgets dérivent de `QWidget`, vous pouvez définir les propriétés `QWidget` ainsi que les propriétés qui sont spécifiques au widget sélectionné.

Les propriétés peuvent être des :

- valeurs entières, comme la géométrie du widget ou la taille de la police
- valeurs booléennes pour activer/désactiver certains paramètres du widget. Définies avec des listes déroulantes contenant true et false ;
- valeurs énumérées d'un widget, par exemple la palette. Définies avec des listes déroulantes contenant la liste des valeurs possibles ;
- valeurs de couleur pour, par exemple, la couleur d'affichage. Définies avec la boîte de dialogue de sélection de couleur de KDE ;
- valeurs de police pour, par exemple, des étiquettes. Veillez à utiliser des valeurs qui ne sont pas des valeurs par défaut si vous ne voulez pas que KDE rafraîchisse la police. Définies avec la boîte de dialogue de sélection de police de KDE ;
- noms de fichiers pour, par exemple, des images de fond. N'utilisez pas des images au format gif ici car elles pourraient ne plus être supportées dans des versions de Qt supérieures à 1.42.

### 6.7 Intégrer la Boîte de Dialogue

Lorsque votre widget est créé, vous voulez probablement l'ajouter au projet afin d'exécuter l'action pour laquelle il a été conçu. Comme un widget peut avoir plusieurs finalités, nous allons considérer les deux cas : un widget héritant de `QWidget` et un autre de `QDialog`.

#### Héritage de `QWidget`

Supposons que vous avez créé un widget qui est un morceau de votre vue principale. S'il remplit toute la zone de vue, vous devez ajouter un pointeur d'instance à la déclaration d'en-tête de votre instance de `KTMainWindow` qui remplace le widget de vue actuellement défini. Modifiez ensuite le code dans la méthode `initView` pour définir ce widget comme la vue principale. En plus, vous pouvez supprimer la classe de vue (NdT : View class) du projet généré mais souvenez-vous que l'instance de document et l'instance de App dépendent de la classe de vue. Dans ce cas, d'un point de vue technique, il est mieux de créer une mini application KDE et de construire votre instance de `KTMainWindow` vous-même.

Plus souvent, le widget est juste une partie de la zone de vue, ce qui signifie qu'il est combiné avec d'autres widgets. Ceci peut être réalisé en utilisant une des classes suivantes qui fournit une division pour séparer deux widgets.

1. `QSplitter`
2. `KPanner`
3. `KNewPanner`

Si la vue principale doit contenir plus de deux widgets, vous devez utilisez une autre instance du séparateur qui sera l'un des deux widgets gérés par le premier. Ajoutez ensuite les widgets correspondants de chaque côté et définissez le premier séparateur comme la zone de vue.

#### Héritage de `QDialog`

Si votre widget hérite de `QDialog`, il est probablement sensé changer une ou plusieurs valeurs ; ceci est souvent utilisé pour définir les préférences d'une application. Pour appeler la boîte de dialogue, vous devez ajouter un slot dans la classe `App` en ajoutant la déclaration de la méthode et le corps de son implantation. Ajoutez ensuite l'appel au constructeur ainsi que les appels à `show()` ou `exec()` de la boîte de dialogue. Enfin, vous devez veiller à traiter les résultats de la boîte de dialogue ; soit la boîte de dialogue modifie elle-même directement les valeurs du widget parent, soit elle retrouve les valeurs de la boîte de dialogue (ce qui devrait rendre votre boîte de dialogue beaucoup plus réutilisable dans d'autres projets). Pensez à appeler `delete` si vous aviez créé l'instance de la boîte de dialogue avec `new` pour éviter les fuites de mémoire.

Enfin, vous devez connecter une entrée de menu (avec l'aide correspondante dans la barre d'état) au nouveau slot qui appelle la boîte de dialogue ; facultativement, un raccourci clavier et une icône de barre d'outils. Pour cela, ajoutez un identificateur de ressource au fichier `resource.h` avec un define. Ajoutez ensuite une entrée de menu correspondante à l'un des menus popups déjà présents dans la barre de menus ou créez un nouveau popup pour ajouter l'entrée de menu. Une entrée de menu est constituée de :

- un pixmap d'icône optionnel. Utilisez la macro `Icon("iconname.xpm")` de `KApplication` pour obtenir une instance de l'icône fournie par `KIconLoader` ;
- le nom de l'entrée de menu. Ajoutez la avec la macro `i18n("&entryname")` de `KApplication` pour permettre l'internationalisation. Le symbole "&" doit être devant la lettre qui apparaîtra soulignée pour y accéder directement avec le clavier ;
- l'instance du membre à appeler. Normalement, ce devrait être le pointeur `this`.
- le slot du membre à appeler. Utilisez `SLOT(yourmethod()` pour appeler le slot lors de l'émission du signal `activated()`.
- la touche de raccourci clavier . Elle devrait être définie à zéro car ceci est fait avec une entrée dans `initKeyAccel()` où vous devez introduire une touche de raccourci clavier en même temps que le slot à appeler. Appelez ensuite `changeMenuAccel()` pour changer le raccourci clavier de l'élément de menu. Cela sera alors configurable via la boîte de dialogue de configuration des raccourcis clavier. Pour des actions standards, utilisez les valeurs énumérées données par `KAccel`.
- l'identificateur de menu défini dans `resource.h`

Page suivante Page précédente Table des matières