I. Avant-propos▲
Access n'offre pas spontanément beaucoup de moyens pour positionner un formulaire à un endroit déterminé de l'écran.
Si on veut y arriver, il faut faire appel à des API, c'est-à-dire des interfaces offertes par d'autres programmes (par exemple Windows) qui autorisent l'interaction avec Access. L'utilisation de ces techniques n'est pas facilement abordable par un débutant.
Voici les références de deux contributions sur Developpez.com qui abordent le sujet au moyen d'API :
- Argyronet a traité le sujet dans son tutoriel Comment positionner un formulaire ouvert depuis un autre, à droite de l'écran.
- Arkham46 dans cette contribution, donne tout le code pour positionner un formulaire sous un contrôle d'un autre formulaire.
Notre démarche consistera à utiliser une seule API et d'en expliquer le fonctionnement.
Comme exemple concret pour illustrer la théorie, nous allons construire pas à pas, ce formulaire gadget néanmoins utilisable :
Si on le déplace à l'écran ou si on le redimensionne, les données affichées sont instantanément actualisées.
Si vous voulez ouvrir un formulaire indépendant à un endroit donné avec des dimensions précises, vous le positionnez manuellement. Ensuite vous le recouvrez exactement avec cet utilitaire. La commande DoCmd.MoveSize avec les paramètres adéquats se trouve dans votre presse-papier.
Le code proposé dans cet article contient des API, c'est-à-dire des fonctions externes déclarées avec l'instruction Declare Function ou Declare Sub.
Depuis Office 2010, Microsoft propose une version 64 bits.
Si vous exécutez un fichier contenant ce type de déclaration avec Office 2010 64 bits, ce code ne compile plus et vous aurez ce message
Une réécriture de ces instructions est nécessaire.
Vous trouverez la documentation nécessaire dans ce tutoriel : http://arkham46.developpez.com/articles/office/vba64bits/
II. Le cas banal▲
Pour illustrer notre propos, construisons un formulaire appelé fOuSuisJe.
II-A. Construisons notre formulaire▲
Dans la fenêtre Access : onglet « Formulaires », clic sur 
,
choisir Mode Création 
,
clic sur 
pour enregistrer sous le nom fOuSuisJe.
Dans un premier temps, ce formulaire est totalement vide : il ne contient aucun contrôle et n'est rattaché à aucune source. Nous le garnirons au fur et à mesure des besoins de l'exposé.
Nous modifions quelques-unes des propriétés comme illustré ci-après :
Sauvegarder le formulaire et ouvrez-le à nouveau en double-cliquant sur son nom dans la fenêtre des objets.
Le formulaire s'affiche à l'écran à l'endroit où il se trouvait lorsque vous l'avez sauvegardé.
- Ouvrez le formulaire.
- Déplacez-le.
- Sauvegardez-le.
- Fermez-le.
- Ouvrez-le à nouveau.
Faites l'expérience
III. Positionner et dimensionner un formulaire à l'ouverture▲
III-A. La méthode MoveSize de l'objet Docmd▲
Cette méthode permet de déplacer ou de redimensionner la fenêtre du formulaire.
En d'autres mots, elle permet de positionner le formulaire à un endroit déterminé d'avance et de préciser la hauteur et la largeur de sa fenêtre.
Pour décrire, avec des mots, un rectangle affiché à l'écran, quatre données suffisent :
- la position horizontale du coin supérieur gauche ;
- la position verticale du coin supérieur gauche ;
- la largeur ;
- la hauteur.
Ce sont, précisément, les paramètres de la méthode Docmd.MoveSize.
Un exemple de syntaxe :
DoCmd.MoveSize 2835, 3405, 5670, 5100
Les unités de ces arguments sont exprimées en twips.
Twip est l'acronyme de TWentIeth of a Point soit 1/20e de point. C'est une mesure d'affichage indépendante de la résolution de l'écran.
1 pouce (inch) = 1440 twips.
1 cm = ±567 twips.
Dans l'exemple, les paramètres expriment que l'on veut placer le coin supérieur gauche 5 cm à droite et 6 cm en dessous (nous expliquerons par rapport à quoi, plus bas) et que le formulaire aura 10 cm de large et 9 cm de hauteur.
III-B. Si le formulaire est une fenêtre indépendante▲
Reprenons notre formulaire fOuSuisJe et essayons de voir à quoi correspond une telle syntaxe.
Nous allons communiquer à Access, que l'événement « Sur ouverture » du formulaire fOuSuisJe doit déclencher l'instruction DoCmd.MoveSize 2835, 3405, 5670, 5100.
Nous demandons donc à Access que lorsqu'un utilisateur ouvre le formulaire fOuSuisJe, ce dernier soit à l'endroit décrit et aux dimensions spécifiées dans les paramètres.
Nous allons coder cette instruction.
Ouvrons notre formulaire en mode construction.
Double-cliquons sur son coin supérieur gauche pour afficher les propriétés : 
Une fenêtre s'ouvre et affiche les propriétés du formulaire. Cliquez sur l'onglet « Événement ».
Double-cliquez sur le texte « Sur ouverture » (1) et cliquez ensuite sur les « … » (2) qui apparaissent à l'extrême droite de la ligne.
Vous ouvrez ainsi l'éditeur de code VBA, à l'endroit qui correspond au code associé à l'événement « Sur ouverture » (Form_Open) du formulaire.
Là où se situe le curseur, vous saisissez le code : DoCmd.MoveSize 2835, 3405, 5670, 5100.
Vous obtenez finalement ceci :
Vous refermez la fenêtre de l'éditeur de code.
Vous enfoncez la touche <F5> pour passer en mode Formulaire. Ce dernier s'ouvre à 5 cm à droite et 6 cm en dessous du coin supérieur gauche de l'écran et sa fenêtre fait 10 cm de large et 9 cm de hauteur.
Si le formulaire est une fenêtre indépendante, le point de repère pour positionner avec DoCmd.MoveSize est le coin supérieur gauche de l'écran.
Ceci nous permet d'attirer l'attention sur l'importance de la propriété « Fen indépendante » pour déterminer la position qu'occupera à l'écran, le formulaire après exécution de l'instruction DoCmd.MoveSize.
Pour constater où se situe le repère, nous allons modifier l'instruction :
DoCmd.MoveSize 0, 0, 5670, 5100
En français : déplacer le formulaire 0 twip à droite ; 0 twip en dessous ; avec une largeur de 10 cm ; avec une hauteur de 9 cm.
Pour accéder au code, enfoncez simultanément les touches <ALT> et <F11> (on note : <Alt-Key-F11>).
Modifiez l'instruction.
Fermez la fenêtre.
Ouvrez le formulaire, il s'ouvre maintenant dans le coin supérieur gauche de votre écran.
III-C. Et si le formulaire n'est pas indépendant ?▲
Essayons !
Basculons notre formulaire en mode création. Faites un clic droit sur le formulaire et dans le menu contextuel qui s'affiche, cliquez sur l'icône 
.
Affichez les propriétés et positionnez à « NON » Fen indépendante.
Fermez la fenêtre de l'éditeur de code. Fermez le formulaire en le sauvegardant.
Ouvrez le formulaire à nouveau.
Cette fois la position du formulaire se situe à l'intérieur de la fenêtre de l'application ACCESS en dessous des barres d'outils et collé au bord gauche.
Le positionnement du formulaire avec la méthode MoveSize de l'objet Docmd dépend de la valeur attribuée à la propriété « Fen indépendante ».
Nous avons associé DoCmd.MoveSize à l'ouverture du formulaire, nous aurions pu l'associer à d'autres événements : le clic sur un bouton par exemple.
III-D. En résumé▲
IV. Trouver la position et les dimensions d'un formulaire▲
Essayons de faire l'inverse. C'est-à-dire pouvoir exprimer où se trouve un formulaire ouvert et quelles sont sa largeur et sa hauteur.
C'est plus dur, car Access, du moins dans la version 2000 ne fournit pas, nativement, ce genre de renseignement.
Par contre, de telles informations sont disponibles dans le système d'exploitation Windows.
Windows API ou WinAPI est le nom donné par Microsoft à l'interface de programmation (API) qui permet à une application comme Access d'interagir avec le système d'exploitation Windows.
IV-A. GetWindowRect : une API utile pour localiser un formulaire à l'écran▲
GetWindowRect
Cette fonction nous renseigne les coordonnés du coin supérieur gauche et du coin inférieur droit d'un rectangle affiché à l'écran.
Pour la déclarer dans notre application, il faut insérer ce code dans un module :
Declare Function GetWindowRect Lib "user32" Alias "GetWindowRect" ( _
ByVal hwnd As Long, _
lpRect As RECT) As LongPour l'utiliser, il faut définir un type de données :
Type RECT
Left As Long
Top As Long
Right As Long
Bottom As Long
End TypeIl faudra l'appeler en donnant le paramètre hWnd du rectangle qui nous intéresse, en l'occurrence le rectangle occupé par notre formulaire.
Un hWnd est un nombre entier généré par Windows permettant d'identifier de manière unique une fenêtre à l'écran.
Dans Access, chaque formulaire ouvert a une propriété « hWnd » qui renseigne ce descripteur attribué par Windows.
Faites l'expérience
Ouvrez fOuSuisJe.
Enfoncez <Ctrl-key-G> pour atteindre la fenêtre d'exécution (<Ctrl-Key-G>).
Saisissez : ? Forms!fOuSuisJe.hwnd
(en français : afficher la propriété hWnd du formulaire fOuSuisJe)
Notez ce numéro.
Fermez la fenêtre pour revenir au formulaire.
Fermez-le et ouvrez-le à nouveau.
Retournez à la fenêtre d'exécution et répétez la commande.
Le numéro a changé !
La fonction va nous donner accès à quatre nombres : Left, Top, Right et Bottom qui détermine le rectangle à l'écran.
Précisons : « Top » renseigne la position du premier pixel à l'intérieur de la fenêtre. Par contre, « Bottom » est en dehors, c'est le pixel qui suit le bord inférieur de la fenêtre.
Si l'un vaut t et l'autre vaut b, alors la hauteur en pixels vaut b - t.
Pareil, pour « Left » (dedans) et « Right »(dehors).
Le coin supérieur gauche de notre formulaire a donc comme coordonnées par rapport au coin supérieur gauche de l'écran :
droite (Right) : Left ;
bas (down) : Top.
Rien n'est simple !
Non seulement ce vocabulaire est déroutant : quand Access dit « droite (Right) » Windows dit « Left » ; quand Access dit « Bas (down) » Windows dit « Top ».
Mais en plus Windows s'exprime en pixels tandis qu'Access mesure en twips !
Et pour encore corser les choses : le nombre de pixels dépend de la résolution de votre écran !
Il nous faut donc un convertisseur pixels => twips.
En réalité il en faut deux :
- nombre de pixels d'une distance horizontale => twips ;
- nombre de pixels d'une distance verticale => twips.
Mais ne brûlons pas les étapes.
Essayons d'abord de récupérer les données fournies par GetWindowRect.
IV-B. Une fonction pour récupérer les données de la position▲
Voici une fonction qui permet de récupérer, pour un formulaire ouvert dont le nom est donné en paramètre, sa position et ses dimensions exprimées en pixels :
Option Compare Database
Option Explicit
Type Position
Droite As Long
Bas As Long
Largeur As Long
Hauteur As Long
End Type
Public Function PositionFormPx(NomDuFormulaire As String) As Position
Dim rectForm As RECT
'Récupérer le rectangle de la fenêtre du formulaire
GetWindowRect Forms(NomDuFormulaire).hwnd, rectForm
'Copier les coordonnées du coin sup gauche
PositionFormPx.Droite = rectForm.Left
PositionFormPx.Bas = rectForm.Top
'Calculer la largeur
PositionFormPx.Largeur = rectForm.Right - rectForm.Left
'Calculer la hauteur
PositionFormPx.Hauteur = rectForm.Bottom - rectForm.Top
End FunctionOn commence par définir un type de données spécifique, qui nous permettra de stocker :
- Droite la distance entre le bord gauche de l'écran et le coin supérieur du formulaire ;
- Bas la distance entre le bord supérieur de l'écran et le coin supérieur du formulaire ;
- Largeur de la fenêtre du formulaire ;
- Hauteur de la fenêtre du formulaire.
Toutes ces données seront exprimées en pixels
Dans la fonction proprement dite, on invoque GetWindowRect pour récupérer les coordonnées des quatre coins que l'on exploite pour construire les résultats de la fonction.
Testons tout cela concrètement.
Dans la fenêtre des objets, cliquez sur « Modules » et ensuite sur « Nouveau ».
Dans la fenêtre qui s'ouvre, collez ce code qui correspond à la déclaration de GetWindowRect :
Declare Function GetWindowRect Lib "user32" ( _
ByVal hwnd As Long, _
lpRect As RECT) As Long
Type RECT
Left As Long
Top As Long
Right As Long
Bottom As Long
End TypeSauvegardez en donnant à ce module le nom mAPI (par exemple).
Fermez la fenêtre de l'éditeur VBA.
Dans la fenêtre des objets, cliquez à nouveau sur « Modules » et ensuite sur « Nouveau ».
Dans la fenêtre qui s'ouvre, collez le code de notre fonction PositionFormPx :
Type Position
Droite As Long
Bas As Long
Largeur As Long
Hauteur As Long
End Type
Public Function PositionFormPx(NomDuFormulaire As String) As Position
Dim rectForm As RECT
'Récupérer le rectangle de la fenêtre du formulaire
GetWindowRect Forms(NomDuFormulaire).hwnd, rectForm
'Copier les coordonnées du coin sup gauche
PositionFormPx.Droite = rectForm.Left
PositionFormPx.Bas = rectForm.Top
'Calculer la largeur
PositionFormPx.Largeur = rectForm.Right - rectForm.Left
'Calculer la hauteur
PositionFormPx.Hauteur = rectForm.Bottom - rectForm.Top
End FunctionDans Access, pour en savoir plus sur un mot-clé, placez le curseur de la souris à l'intérieur du mot et enfoncez la touche <F1> : l'aide s'affiche à la bonne page.
Exemple, placez le curseur à l'intérieur de « Type » et enfoncez <F1> : la documentation relative à l'instruction s'affiche.
Si vous utilisez systématiquement cette technique durant votre apprentissage, vos progrès seront spectaculaires.
Ce conseil vaut aussi pour les propriétés des objets (états, formulaires...) : cliquez sur la propriété, elle s'affiche en surbrillance, et enfoncez <F1>.
Dans la barre des menus, cliquez sur « Débogage » et ensuite sur « Compiler... ».
Entre autres, ceci nous permet de vérifier l'absence d'erreur de code.
Sauvegardez en donnant à ce module le nom mFonctions (par exemple).
Fermez la fenêtre de l'éditeur VBA.
Nous allons maintenant constater que la fonction nous donne le résultat attendu.
Modifiez le formulaire fOuSuisje comme suit :
- propriété « Fen indépendante » => OUI ;
- code de l'événement « Sur ouverture » => DoCmd.MoveSize 2835, 3405, 5670, 5100
Puisque la propriété « Fen indépendante est OUI, le formulaire va se positionner par rapport à l'écran :
à 2835 twips du bord gauche ;
à 3405 twips du bord supérieur ;
avec une largeur de 5670 twips ;
avec une hauteur de 5100 twips.
Affichez le formulaire.
Accédez à la fenêtre d'exécution (<Ctrl-Key-G>) et saisissez :
? PositionFormPx("fOuSuisJe").Droite <Enter> => un nombre s'affiche en dessous.
Répétez avec
? PositionFormPx("fOuSuisJe").Bas <Enter>
? PositionFormPx("fOuSuisJe").Largeur <Enter>
? PositionFormPx("fOuSuisJe").Hauteur <Enter>
Les nombres qui vont s'afficher dépendent de la résolution de votre écran.
Mon écran actuel a une résolution de 1280 x 1024.
J'obtiens respectivement : 189 227 378 340.
Cela veut donc dire que, dans mon environnement :
une distance horizontale de 1 pixel vaut 15 twips (2835 / 189 = 15 ; 5670 / 378 = 15) ;
une distance verticale de 1 pixel vaut 15 twips (3405 / 227 = 15 ; 5100 /340 = 15).
De par sa construction, le rapport twips/pixels est un nombre entier.
Si la résolution de votre écran est différente de celle que j'utilise (1280 x 1024), vous aurez peut-être des rapports différents, voire avec des décimales !
C'est dû aux arrondis. Vous en comprendrez l'origine plus loin dans le texte, lorsqu'on affectera des nombres premiers aux paramètres de DoCmd.MoveSize pour voir ce que cela donne.
IV-C. Comment déterminer la conversion Pixels => Twips▲
Avec quelques API, on pourrait calculer les deux coefficients (horizontal et vertical) de conversion Pixels vers Twips.
C'est la solution que choisiront les virtuoses, entre autres les deux auteurs cités plus haut.
Nous allons utiliser une méthode plus artisanale, cela nous permettra de mettre à profit ce que nous savons déjà faire :
- nous pouvons localiser un formulaire ouvert à l'écran et trouver ses dimensions en nous exprimant en pixels, c'est notre fonction PositionFormPx ;
- d'autre part, depuis la version Access2000 un formulaire dispose de deux propriétés WindowHeight (HauteurFenêtre) et WindowWidth (LargeurFenêtre) toutes deux exprimées en twips.
Dès lors, si nous affichons notre formulaire et que dans la foulée, nous récupérons :
- sa largeur avec PositionFormPx(NomDuFormulaire).Largeur ;
- ainsi que sa hauteur avec PositionFormPx(NomDuFormulaire).Hauteur,
toutes deux exprimées en pixels, nous disposerons ainsi de deux longueurs (une horizontale et une verticale) exprimées dans les deux unités de mesure... et nous pourrons calculer leur rapport de conversion.
Nous traduirons ceci en code dans le paragraphe suivant.
V. Un formulaire étalon pour trouver les paramètres de doCmd.MoveSize▲
Nous allons utiliser tout ceci dans notre formulaire fOuSuisJe.
V-A. Les contrôles du formulaire▲
Garnissons-le de quelques étiquettes et zones de texte. Pour rester cohérent avec la suite des explications, veuillez baptiser les zones de texte comme indiqué ci-après :
Nos zones de texte n'ont pas de source. Nous allons les garnir par programmation.
Sauvegardons notre travail : <Ctrl-Key-S>.
V-B. Le code pour calculer le nombre de twips par pixel▲
Comme dit plus haut, lors de l'ouverture du formulaire, nous allons calculer le nombre de twips par pixel horizontal en divisant sa largeur exprimée en twips par sa largeur en pixels.
Nous procéderons de même avec sa hauteur pour déterminer le nombre de twips par pixel vertical.
Voici le code pour effectuer ces actions :
Me.ZdtNbreTwipspPixelHor = Me.WindowWidth / PositionFormPx(Me.Name).LargeurEn français : on divise la largeur en twips par la largeur en pixels et on loge le résultat dans le contrôle ZdtNbreTwipspPixelHor.
De même :
Me.ZdtNbreTwipspPixelVer = Me.WindowHeight / PositionFormPx(Me.Name).HauteurOn divise la hauteur en twips par la hauteur en pixels et on loge le résultat dans le contrôle ZdtNbreTwipspPixelVer.
Nous allons déclencher l'exécution de ce code dans l'événement « Sur ouverture » de notre formulaire.
Accédez au code actuel :
- <Alt-key-F11> pour ouvrir l'éditeur de code VBA ;
- <Ctrl-key-R> pour afficher l'explorateur de projets ;
- double-cliquez sur Form_fOuSuisJe ;
Vous devriez avoir quelque chose comme ceci à l'écran :Dès lors, si nous affichons notre formulaire et que dans la foulée, nous récupérons :
Remplacez le code actuel par celui-ci :
Option Compare Database
Option Explicit
Private Sub Form_Open(Cancel As Integer)
'Calculer le Nbre de twips par Pixel
'Diviser la largeur en Twips (Me.WindowWidth) par la largeur en Pixels (PositionFormPx)
Me.ZdtNbreTwipspPixelHor = Me.WindowWidth / PositionFormPx(Me.Name).Largeur
'Diviser la Hauteur en Twips (Me.WindowHeight) par la hauteur en Pixels (PositionFormPx)
Me.ZdtNbreTwipspPixelVer = Me.WindowHeight / PositionFormPx(Me.Name).Hauteur
End SubPour WindowWidth et WindowHeight, rappelez-vous 
Refermez la fenêtre de l'éditeur de code.
Fermez le formulaire en le sauvegardant.
Ouvrez-le à nouveau et vous obtenez quelque chose comme ceci :
V-C. Le code pour attribuer une valeur à chaque zone de texte▲
Complétons l'habillage des autres contrôles.
Mémorisons dans zdtDroitePix et zdtBasPix les coordonnées en pixels du coin supérieur gauche à l'aide des valeurs de notre fonction PositionFormPx :
Me.zdtDroitePix = PositionFormPx(Me.Name).Droite
Me.zdtBasPix = PositionFormPx(Me.Name).BasEt dans zdtDroiteTwi et zdtBasTwi la conversion en twips en multipliant les précédents par leur coefficient multiplicateur :
Me.zdtDroiteTwi = Me.zdtDroitePix * Me.ZdtNbreTwipspPixelHor
Me.zdtBasTwi = Me.zdtBasPix * Me.ZdtNbreTwipspPixelVerProcédons par analogie, pour les largeur et hauteur :
Me.zdtLargeurTwi = Me.WindowWidth
Me.zdtHauteurTwi = Me.WindowHeight
Me.zdtLargeurPix = Me.zdtLargeurTwi / Me.ZdtNbreTwipspPixelHor
Me.zdtHauteurPix = Me.zdtHauteurTwi / Me.ZdtNbreTwipspPixelVer.
Pour la zone de texte zdtParam, il suffit de coller les morceaux :
Me.zdtParam = "DoCmd.MoveSize " & Me.zdtDroiteTwi & " , " & Me.zdtBasTwi & " , " _
& Me.zdtLargeurTwi & " , " & Me.zdtHauteurTwiEt pour que l'utilisateur puisse récupérer cette commande dans le presse-papier, on programme les opérations qu'il ferait manuellement : sélectionner le texte et copier
Me.zdtParam.SetFocus
'on sélectionne tout le texte
Me.zdtParam.SelStart = 0
Me.zdtParam.SelLength = Len(Me.zdtParam.Text)
'on copie dans le presse-papier
DoCmd.RunCommand acCmdCopy 'équivalent du raccourci Ctrl-Key-CV-D. Quand déclencher le processus ?▲
L'idée est que le formulaire affiche ses données instantanément quelles que soient la position et les dimensions choisies par l'utilisateur qui le déplace et le redimensionne à sa guise.
Nous allons faire en sorte que le code se déclenche par exemple toutes les secondes.
Affichons les propriétés du formulaire , onglet « Événement »,
fixons à 1000 (millisecondes) l'intervalle de minuterie et double-cliquons sur « Sur minuterie » :
Un clic sur les « ... » pour ouvrir l'éditeur de VBA, où nous insérons notre code :
Private Sub Form_Timer()
'La position du coin sup gauche
Me.zdtDroitePix = PositionFormPx(Me.Name).Droite
Me.zdtBasPix = PositionFormPx(Me.Name).Bas
Me.zdtDroiteTwi = Me.zdtDroitePix * Me.ZdtNbreTwipspPixelHor
Me.zdtBasTwi = Me.zdtBasPix * Me.ZdtNbreTwipspPixelVer
'La Largeur et la hauteur
Me.zdtLargeurTwi = Me.WindowWidth
Me.zdtHauteurTwi = Me.WindowHeight
Me.zdtLargeurPix = Me.zdtLargeurTwi / Me.ZdtNbreTwipspPixelHor
Me.zdtHauteurPix = Me.zdtHauteurTwi / Me.ZdtNbreTwipspPixelVer
Me.zdtParam = "DoCmd.MoveSize " & Me.zdtDroiteTwi & " , " & Me.zdtBasTwi & " , " _
& Me.zdtLargeurTwi & " , " & Me.zdtHauteurTwi
'Commande dans le presse-papier
Me.zdtParam.SetFocus
'on sélectionne tout le texte
Me.zdtParam.SelStart = 0
Me.zdtParam.SelLength = Len(Me.zdtParam.Text)
'on copie dans le presse-papier
DoCmd.RunCommand acCmdCopy 'équivalent du raccourci Ctrl-Key-C
End SubSauvegardez le formulaire par précaution. Ouvrez-le, déplacez-le, redimensionnez-le : les données s'actualisent.
V-E. La preuve que ça marche▲
Faites l'expérience :
Positionnez fOuSuisJe de manière telle qu'il recouvre exactement la surface de la fenêtre des objets.
Votre presse-papier contient donc la syntaxe de la commande.
Fermez fOuSuisJe.
Dans un formulaire indépendant quelconque, dans l'événement sur ouverture, collez le code qui se trouve dans votre presse-papier (<Ctrl-Key-V>).
Ouvrez ce formulaire : il recouvre exactement la fenêtre des objets.
Cqfd.
V-F. Si ce gadget vous intéresse▲
Vous pouvez l'importer dans votre base de données, par exemple comme ceci :
vous affichez côte à côte à l'écran la base de données jointe et la vôtre ;
dans PositionnerFormulaire.mdb vous mettez en surbrillance le module mAPI et avec le bouton gauche de la souris enfoncé, vous faites glisser dans la fenêtre de votre application ;
vous procédez de même pour mFonctions et fOuSuisJe... et c'est à vous !
VI. Une dernière pour la route...▲
Quand nous avons élaboré la fonction pour déterminer la conversion Pixels => Twips, j'avais attiré votre attention sur le fait qu'Access ne positionne pas nécessairement exactement, à droite et en bas, au nombre de twips mentionnés dans la commande DoCmd.MoveSize. Chaque paramètre est arrondi au plus proche multiple de twips par pixel.
Notre fOUSuisJe nous permet de constater le phénomène.
Dans l'événement « Sur ouverture », placez cette instruction en tête :
DoCmd.MoveSize 2887, 5167, 10267, 8269
Quelle que soit la résolution de votre écran, donc votre nombre de twips par pixel, vous constaterez que le fOuSuisJe affiché n'a aucun paramètre qui coïncide avec ceux de la commande. En effet, 2887, 5167, 10267 et 8269 sont des nombres premiers, ils ne sont donc pas des multiples de vos rapports twips/pixels.
À titre d'exemple, avec ma résolution 1280 x 1024, j'ai en réalité : 2880, 5160, 10260 et 8265 qui sont les multiples de 15 les plus proches des paramètres originaux.
VII. Conclusion▲
Ceci est une première étape.
Un tutoriel suivra dans lequel on mettra en pratique la technique qui vient d'être exposée :
- positionner un formulaire par rapport à un contrôle d'un autre formulaire ;
- rendre deux formulaires solidaires : le déplacement de l'un, entraînant le déplacement de l'autre.
Cela nous permettra d'évoquer les propriétés WindowLeft et WindowTop disponibles seulement à partir de Access2002 mais nous décrirons un moyen de pallier leur absence en Access2000.
Vous pouvez télécharger la base de données qui a servi d'exemple.
VIII. Remerciements▲
Je dis merci
à Arkham46, j'ai tenu la plume mais c'est lui qui m'a soufflé les idées,
à Djibril pour l'outil qui a permis la mise en ligne de cet article,
à l'équipe Office pour les conseils et l'encouragement,
à Jacques Jean et Djibril qui ont bien voulu vérifier mon orthographe.