INFO : Conventions d'affectation de noms de MCS (Microsoft Consulting Services) pour Visual Basic

Exclusion de responsabilité du contenu obsolète de la base de connaissances

Cet article a été rédigé sur les produits pour lesquels Microsoft n’offre plus aucune prise en charge. Par conséquent, cet article est proposé « en l’état » et ne sera plus mis à jour.

Résumé

Il est judicieux d'établir des conventions d'affectation de noms pour votre code Visual Basic. Cet article vous donne les conventions d'affectation de noms utilisées par MCS (Microsoft Consulting Services).

Il rassemble les conventions de codage de Visual Basic que vous pouvez trouver dans le Guide du programmeur Visual Basic.

REMARQUE : Les contrôles tiers mentionnés dans cet article sont fabriqués par des fournisseurs indépendants de Microsoft. Microsoft exclut toute garantie, implicite ou autre, concernant les performances ou la fiabilité de ces contrôles.

Plus d'informations

Les conventions d'affectation de noms aident les programmeurs de Visual Basic à :

  • normaliser la structure, le style de codage et la logique d'une application.
  • créer un code source précis, lisible et non ambigu.
  • être cohérent avec les conventions d'autres langages (notamment le Guide du programmeur Visual Basic et la notation hongroise Windows C standard).
  • être efficace du point de vue de la longueur des chaînes et du travail, offrant ainsi plus de possibilités pour des noms d'objets plus longs et plus complets.
  • définir les exigences minimales nécessaires pour atteindre les objectifs ci-dessus.

Définition des options de l'environnement

Utilisez Option Explicit. Déclarez toutes les variables pour réduire le temps de programmation en diminuant le nombre de bogues causés par les fautes de frappe (par exemple, aUserNameTmp, sUserNameTmp et sUserNameTemp). Dans la boîte de dialogue Options d'environnement, définissez Déclaration des variables obligatoire sur Oui. L'instruction Option Explicit requiert la déclaration de toutes les variables dans votre programme Visual Basic. Enregistrez les fichiers en texte ASCII. Enregistrez les fichiers de feuille (.FRM) et de module (.BAS) en texte ASCII pour faciliter l'utilisation des systèmes de contrôle de version et minimiser les problèmes liés aux altérations du disque. De plus, vous pouvez :

  • utiliser votre propre éditeur
  • utiliser des outils automatisés, tels que grep
  • créer la génération de code ou les outils CASE pour Visual Basic
  • effectuer une analyse externe de votre code Visual Basic
Pour que Visual Basic enregistre toujours vos fichiers en texte ASCII, définissez l'option Format d'enregistrement par défaut sur Texte dans la boîte de dialogue Options d'environnement.

Conventions d'affectation de noms d'objets pour les objets standard

Les tableaux suivants définissent les préfixes des noms d'objets standard de MCS. Ces préfixes sont cohérents avec ceux qui figurent dans le Guide du programmeur Visual Basic.

Préfixe Type d'objet Exemple
----------------------------------------------------------------------
ani Bouton Animation aniMailBox
bed Stylet Bedit bedFirstName
cbo Liste modifiable et zone de liste déroulante cboEnglish
chk Case à cocher chkReadOnly
clp Clip image clpToolbar
cmd (3d) Bouton de commande (3D) cmdOk (cmd3dOk)
com Communications comFax
ctr Contrôle (si type spécifique inconnu) ctrCurrent
dat Contrôle Data datBiblio
dir Zone de liste de répertoires dirSource
dlg Contrôle Common dialog dlgFileOpen
drv Zone de liste de lecteurs drvTarget
fil Zone de liste de fichiers filSource
frm Feuille frmEntry
fra (3d) Cadre (3d) fraStyle (fra3dStyle)
gau Indicateur gauStatus
gpb Groupe de boutons gpbChannel
gra Graphique graRevenue
grd Grille grdPrices
hed Stylet Hedit hedSignature
hsb Barre de défilement horizontale hsbVolume
img Image imgIcon
ink Encre stylet inkMap
key Statut touches clavier keyCaps
lbl Étiquette lblHelpMessage
lin Ligne linVertical
lst Zone de liste lstPolicyCodes
mdi Feuille MDI fille mdiNote
mpm Message MAPI mpmSentMessage
mps Session MAPI mpsSession
mci MCI mciVideo
mnu Menu mnuFileOpen
opt (3d) Bouton d'option (3d) optRed (opt3dRed)
ole Contrôle OLE oleWorksheet
out Contrôle Outline outOrgChart
pic Image picVGA
pnl3d Panel 3d pnl3d
rpt Contrôle Report rptQtr1Earnings
shp Contrôles Shape shpCircle
spn Contrôle Spin spnPages
txt Zone de texte txtLastName
tmr Minuterie tmrAlarm
vsb Barre de défilement verticale vsbRate

Convention d'affectation de noms d'objets pour les objets de base de données


Préfixe Type d'objet Exemple
------------------------------------------------------
db Base de données ODBC dbAccounts
ds Objet Dynaset ODBC dsSalesByRegion
fdc Collection Field fdcCustomer
fd Objet Field fdAddress
ix Objet Index ixAge
ixc Collection Index ixcNewAge
qd Objet QueryDef qdSalesByRegion
qry (suffixe) Requête (voir REMARQUE) SalesByRegionQry
ss Objet Snapshot ssForecast
tb Objet Table tbCustomer
td Objet TableDef tdCustomers
REMARQUE : L'utilisation d'un suffixe pour les requêtes permet à chaque requête d'être triée avec sa table associée dans les boîtes de dialogue Microsoft Access (Ajouter une table, Lister les tables Snapshot).

Conventions d'affectation de noms des menus

Les applications utilisent fréquemment de très nombreux contrôles Menu. Par conséquent, vous devez utiliser un jeu différent de conventions d'affectation de noms pour ces contrôles. Les préfixes des contrôles Menu doivent être étendus au-delà de l'étiquette mnu initiale par l'ajout d'un préfixe supplémentaire pour chaque niveau d'imbrication, avec la légende de menu finale à la fin de la chaîne du nom. Par exemple :

Séquence de menus Nom du gestionnaire de menu
Aide.Sommaire mnuAideSommaire
Fichier.Ouvrir mnuFichierOuvrir
Format.Caractère mnuFormatCaractère
Fichier.Envoyer.Fax mnuFichierEnvoyerFax
Fichier.Envoyer.Email mnuFichierEnvoyerEmail
Lorsque cette convention est utilisée, tous les membres d'un groupe de menus particulier sont listés les uns à côté des autres dans les zones de liste déroulantes d'objets (dans la fenêtre de code et la fenêtre des propriétés). De plus, les noms des contrôles de menu documentent clairement les éléments des menus auxquels ils se rapportent.

Conventions d'affectation de noms des menus pour les autres contrôles

Pour les nouveaux contrôles qui ne sont pas énumérés ci-dessus, essayez de trouver un préfixe unique de trois caractères. Cependant, il est plus important d'être clair que d'adhérer à tout prix à la règle des trois caractères.

Pour les contrôles dérivés, tels qu'une zone de liste améliorée, étendez les préfixes ci-dessus de sorte qu'il n'y ait pas de confusion quant au contrôle réellement utilisé. Une abréviation du fabricant en minuscules pourrait aussi être ajoutée au préfixe. Par exemple, vous pouvez utiliser un préfixe fra3d pour une instance de contrôle créée à partir du cadre 3D de Visual Basic Professional pour éviter toute confusion quant au contrôle réellement utilisé. Vous pouvez utiliser cmdm pour un bouton de commande MicroHelp pour le différencier d'un bouton de commande standard (cmd).

Contrôles tiers

Chaque contrôle tiers utilisé dans une application doit être énuméré dans la section de commentaires de présentation de l'application, donnant le préfixe utilisé pour le contrôle, le nom complet du contrôle et le nom du fournisseur de logiciel :

Préfixe Type de contrôle Fournisseur
cmdm Bouton de commande MicroHelp

Affectation de noms des variables et des routines

Les noms des variables et des fonctions ont la structure suivante : <préfixe><corps><qualificateur><suffixe>

Partie Description Exemple
-------------------------------------------------------------------------------
<préfixe> Décrit l'utilisation et la portée de la variable. iGetRecordNext
<corps> Décrit la variable. iGetNameFirst
<qualificateur> Signale un dérivé de la variable. iGetNameLast
<suffixe> Caractère Visual Basic facultatif. iGetRecordNext%
Préfixes :

Les tableaux suivants définissent les préfixes des variables et des noms de fonction qui sont basés sur la notation C hongroise pour Windows. Ces préfixes doivent être utilisés avec toutes les variables et les noms de fonction. L'utilisation des anciens suffixes Basic (tels que %, &, #, etc.) est déconseillée.

Préfixes des variables et des noms de fonction :

Préfixe Convergé Utilisation variable Type de données Suffixe
--------------------------------------------------------------------------
b bln Booléen Entier %
c cur Monétaire - 64 bits Monétaire @
d dbl Double - Quantité Double #
signée 64 bits
dt dat Date et heure Variante
e err Erreur
f sng Flottant/Unique - Virgule Unique !
flottante signée
32 bits
h Descripteur Entier %
i Index Entier %
l lng Longue - Quantité Longue &
signée 32 bits
n int Nombre/Compteur Entier %
s str Chaîne Chaîne $
u Non signée - Quantité Longue &
non signée 16 bits
udt Type défini par l'utilisateur
vnt vnt Variante Variante
a Tableau
REMARQUE : Les valeurs dans la colonne Convergé correspondent aux efforts conjugués pour réunir les affectations de noms standard de Visual Basic, Visual Basic for Applications et Access Basic. Il est probable que ces préfixes deviendront des standards Microsoft dans un avenir proche.

Préfixes de portée et d'utilisation :

Préfixe Description
g Global
m Local au module ou à la feuille
st Variable statique
(pas de préfixe) Variable non statique, préfixe local à la procédure
v Variable passée par valeur (local à une routine)
r Variable passée par référence (locale à une routine)
La notation hongroise est aussi utile en Visual Basic qu'en C. Bien que les suffixes Visual Basic indiquent le type de données d'une variable, ils n'expliquent ni comment une variable ou une fonction est utilisée, ni la manière dont il est possible d'y accéder. En voici quelques exemples :
iSend - Représente le nombre de messages envoyés.
bSend - Indicateur booléen définissant le succès de la dernière opération Send.
hSend - Descripteur de l'interface Comm.
Chacun de ces noms de variables a une signification très différente pour un programmeur. Ces informations sont perdues lorsque le nom de la variable est réduit à Send%. Les préfixes de portée tels que g et m permettent aussi de réduire le problème lié aux conflits de noms, surtout dans des projets impliquant plusieurs développeurs.

La notation hongroise est aussi largement utilisée par les programmeurs en Windows C et est constamment référencée dans la documentation des produits Microsoft et dans les livres de programmation de l'industrie. De plus, les relations entre les programmeurs en C et les programmeurs en Visual Basic pourront se renforcer à mesure que le système de développement Visual C++ prend de la vitesse. Cette transition permettra à de nombreux programmeurs en Visual Basic de passer au C pour la première fois et à de nombreux développeurs de se déplacer fréquemment entre les deux environnements.

Corps d'une variable et noms de routines

Le corps d'une variable ou le nom de routine doit utiliser des majuscules et des minuscules et décrire son objectif, peu importe sa longueur. De plus, les noms de fonction doivent commencer par un verbe, tels que InitNameArray ou CloseDialog.

Pour les termes longs ou fréquemment utilisés, il est recommandé d'utiliser des abréviations standard pour que la longueur des noms reste raisonnable. En général, les noms de variables dont la longueur est supérieure à 32 caractères peuvent être difficiles à lire en mode VGA.

Lorsque vous utilisez des abréviations, assurez-vous qu'elles sont cohérentes tout au long de l'application. En choisissant au hasard Cnt ou Count dans un projet, vous créerez une confusion inutile.

Qualificateurs sur les noms de variables et de routines

Les variables et les routines associés servent souvent à gérer et à manipuler un objet courant. Dans ces cas, utilisez des qualificateurs standard pour étiqueter les variables et les routines dérivées. Bien qu'il puisse paraître bizarre de placer le qualificateur après le corps du nom (comme dans sGetNameFirst, sGetNameLast au lieu de sGetFirstName, sGetLastName), cette pratique permet d'organiser ces noms ensemble dans les listes de routine de l'éditeur Visual Basic, facilitant ainsi la compréhension de la logique et de la structure de l'application. Le tableau suivant définit les qualificateurs courants et leur signification standard :

Qualificateur Description (suit le corps)
--------------------------------------------------------------------------
First Premier élément d'un jeu.
Last Dernier élément d'un jeu.
Next Élément suivant d'un jeu.
Prev Élément précédent d'un jeu.
Cur Élément en cours d'un jeu.
Min Valeur minimale d'un jeu.
Max Valeur maximale d'un jeu.
Save Utilisé pour préserver une autre variable qui doit être
réinitialisée plus tard.
Tmp Variable dont la portée est hautement localisée dans le
code. La valeur d'une variable Tmp est de manière générale
seulement valide dans un jeu d'instructions contiguës au sein
d'une procédure unique.
Src Source. Utilisé fréquemment avec des routines de comparaison
et de transfert.
Dst Destination. Souvent utilisé conjointement avec Source.

Types définis par l'utilisateur

Déclare des types définis par l'utilisateur en majuscules avec _TYPE ajouté à la fin du symbole. Par exemple :
Type CUSTOMER_TYPE
sName As String
sState As String * 2
lID as Long
End Type
En déclarant une variable d'instance d'un type défini par l'utilisateur, ajoutez un préfixe au nom de la variable pour référencer le type. Par exemple :
   Dim custNew as CUSTOMER_TYPE

Constantes d'affectation de noms

Le corps des noms de constantes doit être en MAJUSCULES et comporter des caractères soulignés (_) entre les mots. Bien que les constantes en Visual Basic n'incluent pas d'informations en notation hongroise, les préfixes (tels que i, s, g et m) peuvent être très utiles pour comprendre la valeur et la portée d'une constante. Pour les noms de constantes, suivez les mêmes règles que pour les variables. Par exemple :
<mnUSER_LIST_MAX   ' Entrée limite max pour la liste des utilisateurs
' (valeur entière, locale au module)
gsNEW_LINE ' Chaîne de caractères nouvelle ligne (globale
' à l'application entière)

Type de données Variant

Si vous savez qu'une variable enregistrera toujours des données d'un type particulier, Visual Basic peut traiter ces données plus efficacement si vous déclarez une variable de ce type.

Cependant, le type de donnée Variant peut être extrêmement utile lorsque vous travaillez avec des bases de données, des messages, DDE ou OLE. De nombreuses bases de données autorisent la valeur NULL comme étant valide pour un champ. Votre code doit faire la distinction entre NULL, 0 (zéro) et "" (chaîne vide). Très souvent, ces types d'opérations peuvent utiliser une routine de service générique qui n'a pas besoin de connaître le type de données reçu pour traiter ou passer les données. Par exemple :
   Sub ConvertNulls(rvntOrg As Variant, rvntSub As Variant)
' Si rvntOrg = Null, remplace Null par rvntSub
If IsNull(rvntOrg) Then rvntOrg = rvntSub
End Sub
L'utilisation de ce type de données présente cependant quelques inconvénients. Les instructions de code qui utilisent des variantes peuvent être ambiguës pour le programmeur. Par exemple :
   vnt1 = "10.01" : vnt2 = 11 : vnt3 = "11" : vnt4 = "x4"
vntResult = vnt1 + vnt2 ' Est-ce que vntResult = 21.01 ou 10.0111 ?
vntResult = vnt1 + vnt2 ' Est-ce que vntResult = 21.01 ou 1110.01 ?
vntResult = vnt1 + vnt3 ' Est-ce que vntResult = 21.01 ou 10.0111 ?
vntResult = vnt3 + vnt1 ' Est-ce que vntResult = 21.01 ou 1110.01 ?
vntResult = vnt2 + vnt4 ' Est-ce que vntResult = 11x4 ou ERROR ?
vntResult = vnt3 + vnt4 ' Est-ce que vntResult = 11x4 ou ERROR ?
Les exemples ci-dessus seraient moins ambigus et plus facile à lire, à déboguer et à maintenir si les routines de conversion de type Visual Basic étaient utilisées. Par exemple :
   iVar1 = 5 + val(sVar2)   ' utilise ceci (conversion explicite)
vntVar1 = 5 + vntVar2 ' non cela (conversion implicite)

Commentaire de votre code

Toutes les procédures et les fonctions doivent commencer par un bref commentaire décrivant les caractéristiques fonctionnelles de la routine (ce q'elle fait). Cette description ne doit pas inclure les détails de l'implémentation (comment elle le fait) car ceux-ci changent souvent au cours du temps, entraînant une maintenance inutile des commentaires ou, pire encore, des commentaires erronés. Le code en lui-même et tout commentaire local ou dans la ligne nécessaire décriront l'implémentation.

Les paramètres passés à une routine doivent être décrits lorsque leurs fonctions ne sont pas évidentes et lorsque la routine s'attend à ce que les paramètres soient compris dans une plage spécifique. Les valeurs de retour de fonctions et les variables globales qui sont changées par la routine (surtout par l'intermédiaire des paramètres de référence) doivent aussi être décrites au début de chaque routine.

Les blocs de commentaires en en-tête des routines devraient ressembler à ceci (voir la section "Format de votre code" ci-après pour un exemple) :

Section Description du commentaire
--------------------------------------------------------------------------
Objectif Ce que fait la routine (et non la manière dont elle le fait).
Entrées Chaque paramètre non évident sur une ligne séparée
avec des commentaires sur la ligne.
Assume Liste de chaque variable externe non évidente, contrôle, fichier
ouvert, etc.
Renvoie Explication de la valeur renvoyée pour les fonctions.
Affecte Liste de chaque variable externe affectée, contrôle, fichier,
etc. et l'effet encouru (uniquement si ce n'est pas évident)
Chaque déclaration de variable complexe doit inclure un commentaire sur la ligne décrivant l'utilisation de la variable déclarée.

Les variables, les contrôles et les routines doivent être clairement nommés de sorte que les commentaires sur la ligne soient seulement nécessaires pour des détails d'implémentation non intuitifs ou complexes.

Une description d'ensemble de l'application, énumérant les objets de données primaires, les routines, les algorithmes, les boîtes de dialogue, les dépendances système des bases de données et des fichiers, et ainsi de suite, doivent être incluse au début du module .BAS contenant les déclarations des constantes génériques Visual Basic du projet.

REMARQUE : Le fenêtre Projet décrit par nature la liste des fichiers dans un projet ; cette section de présentation doit seulement fournir des informations sur les fichiers et les modules les plus importants, ou sur les fichiers non répertoriés dans la fenêtre Projet, tels que les fichiers d'initialisation (.INI) ou de base de données.

Format de votre code

De nombreux programmeurs utilisant toujours des modes d'affichage VGA, l'état de l'écran doit être conservé le plus possible, tout en veillant à ce que le code puisse être formaté pour refléter la structure logique et l'imbrication.

Les mises en retrait d'imbrication standard, tabulées ou par blocs doivent contenir entre deux et quatre espaces. Il est inutile d'utiliser plus de quatre espaces car des instructions pourraient être cachées ou tronquées accidentellement. L'utilisation de moins de deux espaces n'est pas suffisante pour indiquer l'imbrication logique. Dans la Base de Connaissances Microsoft, nous utilisons une mise en retrait de trois espaces. Utilisez la boîte de dialogue Options d'environnement pour définir la largeur de la tabulation par défaut.

Le commentaire de présentation fonctionnelle d'une routine doit être mis en retrait d'un espace. Les instructions de haut niveau qui suivent le commentaire de présentation doivent être mises en retrait d'un espace, chaque bloc imbriqué étant mis en retrait d'un espace supplémentaire. Par exemple :
**************************************************************************
'Objectif : Localiser la première occurence d'un utilisateur spécifié
' dans un tableau UserList.
'Entrées : rasUserList(): la liste des utilisateurs à parcourir.
' rsTargetUser: le nom de l'utilisateur à rechercher.
'Renvoie : l'index de la première occurrence de rsTargetUser
' dans la table rasUserList. Si l'utilisateur cible n'est pas
' trouvé, renvoie -1.
'**************************************************************************

'VB3Line: Entrez les lignes suivantes sur une ligne
Function iFindUser (rasUserList() As String, rsTargetUser as String) _
As Integer
Dim i As Integer ' compteur de boucles
Dim bFound As Integer ' indique que la cible a été trouvée
iFindUser = -1
i = 0
While i <= Ubound(rasUserList) and Not bFound
If rasUserList(i) = rsTargetUser Then
bFound = True
iFindUser = i
End If
Wend
End Function
Les variables et les constantes non génériques divent être groupées par fonction au lieu d'être séparées dans des zones isolées ou des fichiers spéciaux. Les constantes génériques de Visual Basic telles que HOURGLASS doivent être groupées dans un module unique (VB_STD.BAS) de façon à ce qu'elles soient séparées des déclarations spécifiques à l'application.

Opérateurs

Utilisez toujours une esperluette (&) lorsque vous concaténez des chaînes et utilisez le signe plus (+) lorsque vous travaillez avec des valeurs numériques. L'utilisation du signe plus (+) avec des valeurs non numériques peut causer des problèmes en opérant sur deux variantes. Par exemple :
   vntVar1 = "10.01"
vntVar2 = 11
vntResult = vntVar1 + vntVar2 ' vntResult = 21.01
vntResult = vntVar1 & vntVar2 ' vntResult = 10.0111

Portée

Les variables doivent toujours être définies avec la plus petite portée possible. Les variables globales peuvent créer des machines très complexes et rendre la logique d'une application extrêmement difficile à comprendre. Les variables globales rendent aussi la réutilisation et la maintenance de votre code plus difficiles. Les variables dans Visual Basic peuvent avoir la portée suivante :

Portée Variable déclarée dans : Visibilité
----------------------------------------------------------------------------------
Niveau procédure Procédure d'événement, sub ou Visible dans la
fonction procédure dans laquelle
elle est déclarée
Niveau feuille, Section de déclarations d'une feuille Visible dans chaque
Niveau module ou module principal (.FRM, .BAS) procédure dans le
module feuille
ou code
Global Section de déclarations d'un code Toujours visible
module (.BAS, utilisant le mot-clé
global)
Dans une application Visual Basic, utilisez seulement des variables globales lorsqu'il n'y a pas d'autre moyen pratique de partager les données entre les feuilles. Vous pouvez considérer l'enregistrement des informations dans la propriété Tag d'un contrôle, à laquelle il est possible d'accéder globalement à l'aide de la syntaxe form.object.property.

Si vous devez utiliser des variables globales, il convient de les déclarer toutes dans un module unique et de les regrouper par fonction. Donnez au module un nom significatif qui indique son objectif, tel que GLOBAL.BAS.

À l'exception des variables globales (qui ne doivent pas être passées), les procédures et les fonctions doivent seulement s'appliquer aux objets qui leur sont passés. Les variables globales qui sont utilisées dans des routines doivent être identifiées dans la zone de commentaires d'ordre général au début de la routine. De plus, passez les arguments aux sub et aux fonctions en utilisant ByVal, à moins que vous ne souhaitiez changer la valeur de l'argument passé.

Écrivez du code modulaire chaque fois que cela s'avère possible. Par exemple, si votre application affiche une boîte de dialogue, mettez tous les contrôles et le code requis pour effectuer la tâche de la boîte de dialogue dans une feuille unique. Cela permet de garder le code de l'application organisé en composants utiles et de minimiser sa gestion d'exécution.

Contrôles tiers

REMARQUE : Les produits mentionnés ci-dessous sont fabriqués par des fournisseurs indépendants de Microsoft. Microsoft exclut toute garantie, implicite ou autre, concernant les performances ou la fiabilité de ces produits.

Le tableau suivant répertorie les préfixes des noms des fournisseurs tiers standard à utiliser avec les préfixes des contrôles :

Fournisseur Abr
------------------------

MicroHelp (VBTools) m
Pioneer Software p
Crescent Software c
Sheridan Software s
Autres (Divers) o
Le tableau suivant répertorie les préfixes des contrôles tiers standard :

Type Nom Abr Fournisseur Exemple Nom
Contrôle Contrôle Fichier VBX
--------------------------------------------------------------------------------
Alarme Alarm almm MicroHelp almmAlarm MHTI200.VBX
Animer Animate anim MicroHelp animAnimate MHTI200.VBX
Rappel Callback calm MicroHelp calmCallback MHAD200.VBX
Liste modifiable DB_Combo cbop Pioneer cbopComboBox QEVBDBF.VBX
Liste modifiable SSCombo cbos Sheridan cbosComboBox SS3D2.VBX
Case à cocher DB_Check chkp Pioneer chkpCheckBox QEVBDBF.VBX
Graphique Chart chtm MicroHelp chtmChart MHGR200.VBX
Horloge Clock clkm MicroHelp clkmClock MHTI200.VBX
Bouton Command cmdm MicroHelp cmdmCommandButton MHEN200.VBX
Bouton
Bouton DB_Command cmdp Pioneer cmdpCommandButton QEVBDBF.VBX
Bouton (Group) Command cmgm MicroHelp cmgmBtton MHGR200.VBX
Bouton
(multiple)
Bouton Command cmim MicroHelp cmimCommandButton MHEN200.VBX
Bouton
(icône)
Jeu de cartes CardDeck crdm MicroHelp crdmCard MHGR200.VBX
Dés Dice dicm MicroHelp dicmDice MHGR200.VBX
Zone de liste (Dir) SSDir dirs Sheridan dirsDirList SS3D2.VBX
Zone de liste (Drv) SSDrive drvs Sheridan drvsDriveList SS3D2.VBX
Zone de liste (File) File List film MicroHelp filmFileList MHEN200.VBX
Zone de liste (File) SSFile fils Sheridan filsFileList SS3D2.VBX
Inverser Flip flpm MicroHelp flpmButton MHEN200.VBX
Barre de défilement Form Scroll fsrm MicroHelp fsrmFormScroll ???
Indicateur Gauge gagm MicroHelp gagmGauge MHGR200.VBX
Graphique Graph gpho Other gphoGraph XYGRAPH.VBX
Grille Q_Grid grdp Pioneer grdpGrid QEVBDBF.VBX
Barre de défilement Horizontal hsbm MicroHelp hsbmScroll MHEN200.VBX
Barre de défilement
Barre de défilement DB_HScroll hsbp Pioneer hsbpScroll QEVBDBF.VBX
Graphique Histo hstm MicroHelp hstmHistograph MHGR200.VBX
Invisible Invisible invm MicroHelp invmInvisible MHGR200.VBX
Zone de liste Icon Tag itgm MicroHelp itgmListBox MHAD200.VBX
État clé Key State kstm MicroHelp kstmKeyState MHTI200.VBX
Étiquette Label (3d) lblm MicroHelp lblmLabel MHEN200.VBX
Ligne Line linm MicroHelp linmLine MHGR200.VBX
Zone de liste DB_List lstp Pioneer lstpListBox QEVBDBF.VBX
Zone de liste SSList lsts Sheridan lstsListBox SS3D2.VBX
Enfant MDI MDI Control mdcm MicroHelp mdcmMDIChild ???
Menu SSMenu mnus Sheridan mnusMenu SS3D3.VBX
Marque Marque mrqm MicroHelp mrqmMarque MHTI200.VB
Image OddPic odpm MicroHelp odpmPicture MHGR200.VBX
Image Picture picm MicroHelp picmPicture MHGR200.VBX
Image DB_Picture picp Pioneer picpPicture QEVBDBF.VBX
Propriété Vwr Property pvrm MicroHelp pvrmPropertyViewer MHPR200.VBX
Afficheur
Option (Group) DB_RadioGroup radp Pioneer radqRadioGroup QEVBDBF.VBX
Curseur Slider sldm MicroHelp sldmSlider MHGR200.VBX
Bouton (Spin) Spinner spnm MicroHelp spnmSpinner MHEN200.VBX
Feuille de calcul Spreadsheet sprm MicroHelp sprmSpreadsheet MHAD200.VBX
Image Stretcher strm MicroHelp strmStretcher MHAD200.VBX
Écran de veille Screen Saver svrm MicroHelp svrmSaver MHTI200.VBX
Interrupteur Switcher swtm MicroHelp swtmSwitcher ???
Zone de liste Tag tagm MicroHelp tagmListBox MHEN200.VBX
Minuterie Timer tmrm MicroHelp tmrmTimer MHTI200.VBX
Barre d'outils ToolBar tolm MicroHelp tolmToolBar MHAD200.VBX
Zone de liste Tree trem MicroHelp tremTree MHEN200.VBX
Boîte d'entrée Input (Text) txtm MicroHelp inpmText MHEN200.VBX
Boîte d'entrée DB_Text txtp Pioneer txtpText QEVBDBF.VBX
Barre de défilement Vertical vsbm MicroHelp vsbmScroll MHEN200.VBX
Barre de défilement
Barre de défilement DB_VScroll vsbp Pioneer vsbpScroll QEVBDBF.VBX
Propriétés

ID d'article : 110264 - Dernière mise à jour : 24 févr. 2004 - Révision : 1

Commentaires