Page suivante
Page précédente
Table des matières
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.
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
.
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 :
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é.
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 :
KRestrictedLine
KLed
Hérite de
QWidget
- Apparence :
- LedColor : (setColor()) définit la couleur de la LED affichée
É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 :
- 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 ;
- 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
.
- 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.
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.
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.
QSplitter
KPanner
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