iPosX (Fonction)

DOCUMENTATION EN LIGNE
DE WINDEV, WEBDEV ET WINDEV MOBILE

Version :

Accueil | Connexion | Français

Aide / WLangage / Fonctions WLangage / Fonctions standard / Fonctions d'impression

Origine et marges physiques
Gestion du paramètre
Combinaison de positions (paramètre )
Impression en Java et Android

WINDEV

WEBDEV

WINDEV Mobile

Autres

Voir Aussi

iPosX (Fonction)

En anglais : iXPos

Permet de gérer la position horizontale (abscisse ou colonne) du curseur d'impression dans la page. Il est possible de :

connaître la position horizontale en cours,
modifier la position horizontale du curseur d'impression.

Remarque : Lors de l'impression d'une chaîne texte, la position verticale en cours pointe sur le haut de la chaîne à imprimer. La ligne basse d'impression dépend de la hauteur des polices utilisées dans la ligne imprimée.

Exemple

// Traçage de traits verticaux séparés de deux millimètres
// sur toute la largeur de la page
iTraitV(0, iHauteurPage(), 1) // Trace un trait
iPosX(iPosX() + 2) // Décale de 2
iTraitV(0, iHauteurPage(), 3) // Trace un trait
iFinImprime()

Syntaxe

Connaître la position horizontale du curseur d'impression Masquer les détails

<Résultat> = iPosX()

<Résultat> : Réel

Position horizontale actuelle du curseur (en millimètres).

Modifier la position horizontale du curseur d'impression Masquer les détails

<Résultat> = iPosX(<Position horizontale> [, <Calcul immédiat>])

<Résultat> : Chaîne de caractères

Position horizontale demandée.

<Position horizontale> : Réel

Nouvelle position horizontale (abscisse ou colonne) du curseur d'impression (en millimètres).

<Calcul immédiat> : Booléen optionnel

Vrai (par défaut) pour effectuer immédiatement le calcul de la position horizontale.
Faux si le calcul de la position horizontale doit être effectué uniquement lors de l'impression (cas d'imbrication de positions par exemple). Pour plus de détails, consultez les remarques.

Remarques

Origine et marges physiques

L'origine (0,0) est située dans le coin supérieur gauche de la feuille. Cette origine tient compte des marges physiques de l'imprimante.

Chaque imprimante gère des marges physiques dans lesquelles aucune impression n'est possible. La fonction iMarge permet de définir des marges "logiques" d'impression. Si des marges logiques ont été définies, la fonction iPosX gère la position horizontale par rapport à ces nouvelles marges.

Gestion du paramètre <Calcul Immédiat>

Lorsque le paramètre <Position horizontal> est précisé dans la fonction iPosX, la fonction effectue deux actions en même temps :

Renvoi d'une chaîne de caractères de contrôle. Cette chaîne de caractères de contrôle provoque une modification de la position d'impression au moment où elle est imprimée.
Modification immédiate de la position en cours du curseur d'impression

Le paramètre <Calcul immédiat> permet de récupérer la chaîne de caractères de contrôle sans modifier la position en cours du curseur d'impression.

sMonTitre est une chaîne = "Titre impression"
iDestination(iVisualisateur)

// --- CAS 1 : <Calcul immédiat> à Vrai (par défaut)
// Positionnement du curseur à l'endroit souhaité
// Note : La chaîne de caractères de contrôle n'est pas récupérée ici
iPosX((iLargeurPage() - iLargeurTexte(sMonTitre))/2)
// Calcul pour centrer le texte

// Impression à la position du curseur précédemment déterminée
iImprime(sMonTitre) // Donc doit être centré

// --- CAS 2 : Le même code avec le paramètre <Calcul immédiat> à Faux
// La chaîne de caractères de contrôle n'est pas récupérée ici
// Et le curseur d'impression n'est pas positionné car
// <Calcul immédiat> est à Faux
// Note : Donc cette ligne ne sert à rien
iPosX((iLargeurPage() - iLargeurTexte(sMonTitre))/2, Faux)

// Impression à la position du curseur
// La ligne de code précédente ne l'ayant pas changé
// le texte va s'imprimer à la position précédente (donc en début de ligne ici)
iImprime(sMonTitre) //Donc NE doit PAS être centré

// --- CAS 3 : Le code en une seule ligne
// Avec le paramètre <Calcul immédiat> à Faux ou à Vrai
// le résultat est le même

// La position du curseur d'impression est modifiée au moment de
// l'exécution de iPosX, et au moment de l'impression de la
// chaîne de caractères qui contient le résultat renvoyé par iPosX
iImprime(iPosX((iLargeurPage() - iLargeurTexte(sMonTitre))/2, Vrai) + sMonTitre)
// Donc doit être centré
// Le positionnement est fait deux fois : un peu plus lourd
// mais le résultat est celui attendu

// --- CAS 3 Bis
// La position du curseur d'impression N'est PAS modifiée au moment
// de l'exécution de iPosX, MAIS elle est modifiée au moment
// de l'impression de la chaîne de caractères qui contient le résultat
// renvoyé par iPosX
iImprime(iPosX((iLargeurPage() - iLargeurTexte(sMonTitre))/2, Faux) + sMonTitre)
// Donc doit être centré

// Fin d'impression
iFinImprime()

Combinaison de positions (paramètre <Calcul immédiat>)

Lors de la combinaison de positions, des effets inattendus peuvent être observés. Par exemple, le code :

iPosX(50)
iImprime("Première partie" + iPosX(20) + "Seconde partie")

n'est pas équivalent à :

iImprime(iPosX(50) + "Première partie" + iPosX(20) + "Seconde partie")

Dans le premier cas, toute la chaîne de caractères est imprimée en position horizontale 20. En effet, dans ce cas, la fonction iPosX(20) est exécutée lors de la construction de la chaîne à imprimer et donc avant l'impression de la chaîne "Première partie".

Pour obtenir un résultat identique, il suffit d'utiliser la fonction iPosX avec le paramètre Faux : la fonction iPosX(20, Faux) ne sera réellement exécutée que lors de l'impression.

La même manipulation peut être réalisée avec la fonction iPosY.

Impression en Java et Android

Les impressions peuvent être moins précises car la résolution des impressions est de 72 points par pouce (ppp) même si l'imprimante supporte des résolutions plus importantes.

Conséquence : Les calculs des points des images et des dessins (traits par exemple) sont arrondis durant les calculs de position en impression, en particulier lorsque l'on manipule des valeurs petites. Lors de l'impression, les calculs se font en point (en fonction de la résolution d'impression) et non en mm (ou cm).

Exemple : Impressions de traits : si les traits sont espacés de 0.5 mm, combien y a-t-il de points entre chaque trait en Java (résolution 72 ppp) ?

Le premier trait est à 0.5 mm soit (0.5/25.4) pouces et avec une résolution de 72 points par pouce (ppp) : (0.5/25.4) x 72 = 1,42 point. Mais le point est l'unité de base, il est donc indivisible : le résultat est automatiquement arrondi au 1 point inférieur ou supérieur selon le cas.

Voici donc une succession de traits imprimés avec un espace de à 0.5 mm :

0.5 mm --> (1.42) 1 point
1.0 mm --> (2.84) 3 points
1.5 mm --> (4.25) 4 points. Attention : le trait à 1.5 mm est collé avec le trait qui est à 1 mm (sans espace entre ces deux traits)
2.0 mm --> (5.67) 6 points
2.5 mm --> (7.09) 7 points. Attention : le trait à 2.5 mm est collé avec le trait qui est à 2 mm (sans espace entre ces deux traits)
3.0 mm --> (8.50) 9 points
3.5 mm --> (9.92) 10 points. Attention : le trait à 3.5 mm est collé avec le trait qui est à 3 mm (sans espace entre ces deux traits)
4.0 mm --> (11.33) 11 points. Attention : le trait à 4 mm est collé avec le trait qui est à 3.5 mm (sans espace entre ces deux traits)
etc.

Pour avoir une représentation fidèle (sans arrondis), la taille et / ou la position en mm pour une résolution de 72 ppp doit être un multiple de 127/360.

1 point --> (1/72) pouces --> (1/72) x 25.4 mm = 127/360 = 0.3527778 mm

Composante : wd300prn.dll

Voir Aussi

Version minimum requise

Version 9

Documentation également disponible pour…

Commentaires

Cliquez sur [Ajouter] pour publier un commentaire

Dernière modification : 21/06/2023

Signaler une erreur ou faire une suggestion | Aide en ligne locale