KGF.dll: fonctions Print

Nombre de messages : 7112 Localisation : 77 Date d'inscription : 29/11/2007

Bonjour Klaus, voilà j'ai un petit problème pour passer en mode paysage, par exemple avec ceci:

Code:: DIM fs$, hnd%, cnv%, cd%, rs%, val%(10), ppmm, wim%, him%
fs$ = "C:\TEMP\Test.bmp"
DLL_ON "C:\PANORAMIC\KLAUS\DLLs\KGF.dll": ' <===== à ajuster
PICTURE 1: WIDTH 1,700: HEIGHT 1,406
2D_TARGET_IS 1: 2D_RECTANGLE 0,0,WIDTH(1),HEIGHT(1)
FILE_SAVE 1, fs$: ' image bmp de 700x406 pixels (désirée sur papier en 246x143 mm)
' 1) Caractéristiques imprimante:
rs% = DLL_call4("PrinterManager",1,adr(hnd%),adr(cnv%),0): ' init
FOR cd% = 1 TO 10
val%(cd%) = DLL_call6("PrinterFunction",8,adr(hnd%),adr(cnv%),cd%,0,0)
NEXT cd%
ppmm = val%(3)/210: ' pixels par mm
wim% = 246*ppmm: him% = 143*ppmm: ' dimensions de l'image finale (5813x3379 pixels)
' 2) Impression de l'image:
rs% = DLL_Call4("PrinterManager",1,ADR(hnd%),ADR(cnv%),0): ' init imprimante
rs% = DLL_Call4("PrinterManager",4,ADR(hnd%),ADR(cnv%),1): ' orientation paysage <=======
rs% = DLL_Call6("PrinterFunction",7,ADR(hnd%),ADR(cnv%),ADR(fs$),wim%,him%)
rs% = DLL_Call4("PrinterManager",3,ADR(hnd%),ADR(cnv%),0): ' lancement impression
END

L'imprimante s'obstine à imprimer en mode portrait, quelque chose que je fais mal ?

Normal. La détermination de l'orientation doit être faite AVANT le début d'impression. Et il y avait 2 fois le début d'impression. Essaie comme ceci:

Code:: DIM fs$, hnd%, cnv%, cd%, rs%, val%(10), ppmm, wim%, him%
fs$ = "C:\TEMP\Test.bmp"
DLL_ON "KGF.dll": ' <===== à ajuster
PICTURE 1: WIDTH 1,700: HEIGHT 1,406
2D_TARGET_IS 1: 2D_RECTANGLE 0,0,WIDTH(1),HEIGHT(1)
FILE_SAVE 1, fs$: ' image bmp de 700x406 pixels (désirée sur papier en 246x143 mm)
' c'est ICI qu'il faut déterminer l'orientation:
rs% = DLL_Call4("PrinterManager",4,ADR(hnd%),ADR(cnv%),1): ' orientation paysage <=======
' 1) Caractéristiques imprimante:
rs% = DLL_call4("PrinterManager",1,adr(hnd%),adr(cnv%),0): ' init
FOR cd% = 1 TO 10
val%(cd%) = DLL_call6("PrinterFunction",8,adr(hnd%),adr(cnv%),cd%,0,0)
NEXT cd%
ppmm = val%(3)/210: ' pixels par mm
wim% = 246*ppmm: him% = 143*ppmm: ' dimensions de l'image finale (5813x3379 pixels)
' 2) Impression de l'image:
' ligne suivante désactivée - déjà fait en ligne 10 !
' rs% = DLL_Call4("PrinterManager",1,ADR(hnd%),ADR(cnv%),0): ' init imprimante
' ligne suivante désactivée - doit e^tre faite AVANT PrinterManager code 1 !
' rs% = DLL_Call4("PrinterManager",4,ADR(hnd%),ADR(cnv%),1): ' orientation paysage <=======
rs% = DLL_Call6("PrinterFunction",7,ADR(hnd%),ADR(cnv%),ADR(fs$),wim%,him%)
rs% = DLL_Call4("PrinterManager",3,ADR(hnd%),ADR(cnv%),0): ' lancement impression
END

Ca passe en paysage.

EDIT

Je suis désolé pour le contre-temps - cette contrainte n'était pas notée dans la doc ! Voilà qui est corrigé !

Nombre de messages : 7112 Localisation : 77 Date d'inscription : 29/11/2007

Je reviens, merci Klaus pour ta réponse rapide, j'essaie ça tout de suite !

EDIT Impeccable Klaus, ça marche très bien comme ça, je le note dans ma doc perso, et merci encore.

J'ai mis KGF.chm à jour sur ce point !

Nombre de messages : 7112 Localisation : 77 Date d'inscription : 29/11/2007

Une remarque tout de même Klaus, ou bien c'est moi qui ne vois plus bien clair:
Dans la PrinterFunction 8 (dans la doc: 'retourner une dimension de la feuille'), les valeurs verticales et horizontales semblent être permutées (ça trompe), puisque j'obtiens suivant l'opt1%:
1: 75
2: 75
3: 7013
4: 4962
5: 600
6: 600
7: 6863
8: 4812
9: 291
10: 204
ce n'est pas gênant (quand on sait, mais il faut le savoir !)

J'attends avant de recharger KGF.chm...

Eh bien, puisque tu est passé en mode paysage, ce serait plutôt normal, non ? Mets la ligne de sélection du mode paysage en commentaire et réexécute. Tu verras la différence...

Nombre de messages : 7112 Localisation : 77 Date d'inscription : 29/11/2007

Là tu m'as eu Klaus ! Embarassed

Effectivement c'est tout à fait normal et je suis tout honteux de ne pas y avoir pensé !
Mea culpa, je fais amende (honorable ? pas sûr)

JL 35 on n’est pas tous des Klaus !!!.

Nombre de messages : 7112 Localisation : 77 Date d'inscription : 29/11/2007

Certes, et j'en suis bien conscient !

@Klaus
Je remarque dans la doc de KGF.dll à plusieurs reprises l'utilisation du mot managment... ça ne serait pas plutôt management ???
(@papydall j'essaie de trouver la faille !)

Qui cherche trouve !

Klaus a des failles, c'est vrai. Mais qu'est-ce que j'aimerais avoir ses points forts !! ;D

Moi aussi ! Laughing

managment ==> management : remarque judicieuse ! C'est corrigé, et merci pour l'info.

Nombre de messages : 7112 Localisation : 77 Date d'inscription : 29/11/2007

Juste une remarque, mais je me demande si ça n'avait pas déjà été signalé:
PrinterFunction, fonction 2: dessiner une forme à partir de la position active
opt1% = 0 (tracé de ligne), on ne peut pas tracer une ligne parfaitement horizontale, il faut toujours au moins un pixel d'écart (sinon, pas de tracé).

Une remarque également: si le positionnement (fct 4) donne le choix absolu ou relatif, les coordonnées du point d'arrivée (fct 2) sont toujours en relatif par rapport au point de départ. Juste pour fixer les idées et éviter les tâtonnements (comme moi Very Happy

).

Convernant le premier point, ce n'est pas tout à fait exact. Regarde ce code:

Code:: dim res%, phnd%, chnd%

dll_on "KGF.dll"

res% = DLL_call4("PrinterManager",1,adr(phnd%),adr(chnd%),0)

' ellipse
res% = DLL_call6("PrinterFunction",4,adr(phnd%),adr(chnd%),0,100,200)
res% = DLL_call6("PrinterFunction",2,adr(phnd%),adr(chnd%),2,600,200)

' trait au milieu de l'ellipse
res% = DLL_call6("PrinterFunction",4,adr(phnd%),adr(chnd%),0,100,300)
res% = DLL_call6("PrinterFunction",2,adr(phnd%),adr(chnd%),0,600,0)

' trait en-dessous de l'ellipse
res% = DLL_call6("PrinterFunction",4,adr(phnd%),adr(chnd%),0,100,400)
res% = DLL_call6("PrinterFunction",2,adr(phnd%),adr(chnd%),0,600,1)

res% = DLL_call4("PrinterManager",3,adr(phnd%),adr(chnd%),0)

dll_off
end

Les deux traits s'affichent ! Mais il ne faut pas oublier que les paramètres de la fonction, dans ce cas, donnent les dimensions du rectangle dans lequel la forme dessinée s'inscrit, et NON les coordonnées relatives ou absolues du point final - c'est documenté. C'est une nuance, mais elle a son importance !

Du coup, la remarque 2 est caduque: il n'y a pas de coordonnées du point d'arrivée, ce qui d'ailleurs n'aurait pas de sens dans le cas d'une ellipse ! Il n'y a que les dimensions du rectangle englobant.

Nombre de messages : 7112 Localisation : 77 Date d'inscription : 29/11/2007

Bonjour Klaus, et merci pour ta réponse.
Certes ton exemple fonctionne bien, mais je reste un peu perplexe: je désire tracer une simple ligne horizontale, mais ça ne marche pas:

Code:: dim res%, phnd%, chnd%
dll_on "KGF.dll"

res% = DLL_call4("PrinterManager",1,adr(phnd%),adr(chnd%),0)
' tracer un trait de 100,300 à 600,300
res% = DLL_call6("PrinterFunction",4,adr(phnd%),adr(chnd%),0,100,300)
res% = DLL_call6("PrinterFunction",2,adr(phnd%),adr(chnd%),0,500,0): ' +500,+0
res% = DLL_call4("PrinterManager",3,adr(phnd%),adr(chnd%),0)

dll_off
end

Qu'est-ce que je fais mal ?
Peut-être parce que le rectangle englobant a une hauteur nulle, donc pas de tracé ?

Ton code est correct. Voici ce que ça donne chez moi (impression dans un fichier PDF):

Tu dois avoir un problème d'imprimante (résolution, ...).

Nombre de messages : 7112 Localisation : 77 Date d'inscription : 29/11/2007

C'est peut-être (sans doute) lié à l'imprimante, j'imprime en 600 dpi
Si je fais:

Code:: res% = DLL_call6("PrinterFunction",4,adr(phnd%),adr(chnd%),0,100,4100)
res% = DLL_call6("PrinterFunction",2,adr(phnd%),adr(chnd%),0,4000,0): ' +4000,+0

(donc départ en 100,4100, arrivée en 4100,4100) je n'ai aucune impression ni velléité d'impression (l'imprimante ne marque pas de pause)
et si je fais:

Code:: res% = DLL_call6("PrinterFunction",4,adr(phnd%),adr(chnd%),0,100,4100)
res% = DLL_call6("PrinterFunction",2,adr(phnd%),adr(chnd%),0,4000,1): ' +4000,+1

(départ idem, arrivée idem mais 1 pixel plus bas) là j'ai bien impression d'une ligne bien nette horizontale (le décalage vertical est invisible).
scratch

~~PS il me semble qu'on ne peut pas moduler l'épaisseur de la ligne...~~
Edit autant pour moi: fonction 6, paramètre opt3%

Bizarre. Voici ce que donne ton code chez moi:
KGF.dll: fonctions Print Aa112

Et c'est bien avec la hauteur 0...

Nombre de messages : 7112 Localisation : 77 Date d'inscription : 29/11/2007

Merci en tout cas Klaus pour ton attention, je continue à explorer la bête...
J'essaie de positionner avec précision des objets (lignes, rectangles, cercles) sur la feuille, en donnant les dimensions en millimètres (converties en pixels), mais c'est un peu empirique, avec les marges non imprimables, etc.
Pour la ligne horizontale, je peux toujours dessiner un rectangle de hauteur 1 ou 2...
edit: tiens, finalement dans un autre cas (dessin d'une croix) la ligne s'est bien imprimée...

Quelque chose dans la doc PDF qui ne me semble pas clair:
PrinterFunction, fonction 2 (dessiner une forme...), je vois "si rectangle: additionner 256*diamètre arrondi" ??
Quel diamètre ? la diagonale (cercle enveloppant) ? additionner à quoi ? ça doit être pour le cas ellipse ?

Nombre de messages : 7112 Localisation : 77 Date d'inscription : 29/11/2007

Ca y est, après quelques tâtonnements je crois que j'en suis venu à bout, je me suis fait une petite collection de Subs pour exploiter tout ça.
Je rappelle qu'il s'agit d'imprimer des figures sur une feuille A4 (lignes, rectangles, cercles ou ellipses), en donnant les paramètres de ces figures (position, dimensions) soit en pixels, soit en millimètres.
Ces positions sont données par rapport aux bords gauche et haut de la feuille.
Ici ce sont les fonctions de base, il y a bien d'autres enrichissements possibles (couleurs...), pour ça il faut consulter la doc de KGF.dll... et écrire les subs correspondantes.

Il faut donc d'abord initialiser l'impression (Sub Pr_Init), tracer les figures désirées en appelant les subs adéquates, puis exécuter l'impression (Sub Pr_Impr).
Il n'y a rien là-dedans de révolutionnaire, c'est juste pour faciliter l'utilisation des excellentes fonctions d'impression de la DLL de Klaus.

Code:: ' ------------------------------------------------------------------------------
SUB Pr_init()
' Initialisation imprimante ('début d'impression')
IF VARIABLE("phnd%") = 0 THEN DIM phnd%
IF VARIABLE("chnd%") = 0 THEN DIM chnd%
IF VARIABLE("inip%") = 0 THEN DIM inip%
IF VARIABLE("Pr_res%") = 0 THEN DIM Pr_res%
IF VARIABLE("Pr_mmpix") = 0 THEN DIM Pr_mmpix: ' pixels par mm
IF VARIABLE("Pr_mg%") = 0 THEN DIM Pr_mg%
Pr_res% = DLL_CALL4("PrinterManager",1,ADR(phnd%),ADR(chnd%),0): ' init
Pr_res% = DLL_CALL6("PrinterFunction",8,ADR(phnd%),ADR(chnd%),4,0,0)
Pr_mmpix = Pr_res%/297: ' pixels par mm, à l'impression en 600 dpi
Pr_res% = DLL_CALL6("PrinterFunction",8,ADR(phnd%),ADR(chnd%),1,0,0)
Pr_mg% = Pr_res%: ' pixels, à soustraire pour marges non imprimables
inip% = 1
END_SUB
' ------------------------------------------------------------------------------
SUB Pr_Ligne(x1%,y1%,x2%,y2%,u%)
' Tracé d'une ligne entre x1%,y1% et x2%,y2%
' u% = 0: unités pixels, u% = 1, unités millimètres
IF inip% = 0 THEN EXIT_SUB: ' imprimante non initialisée
x2% = x2%-x1%: y2% = y2%-y1%: ' coordonnées relatives d'arrivée
IF u% = 1
   x1% = x1%*Pr_mmpix: y1% = y1%*Pr_mmpix: ' mm -> pixels
   x2% = x2%*Pr_mmpix: y2% = y2%*Pr_mmpix
END_IF
x1% = x1%-Pr_mg%: y1% = y1%-Pr_mg%
Pr_res%=DLL_CALL6("PrinterFunction",4,ADR(phnd%),ADR(chnd%),0,x1%,y1%): ' posit
Pr_res%=DLL_CALL6("PrinterFunction",2,ADR(phnd%),ADR(chnd%),0,x2%,y2%): ' ligne
END_SUB
' ------------------------------------------------------------------------------
SUB Pr_Rect(x%,y%,w%,h%,u%)
' Tracé d'un rectangle en x%,y%, dimensions w%,h%
' u% = 0: unités pixels, u% = 1, unités millimètres
IF inip% = 0 THEN EXIT_SUB: ' imprimante non initialisée
IF u% = 1: ' unités en mm, conversion en pixels
   x% = x%*Pr_mmpix: y% = y%*Pr_mmpix: w% = w%*Pr_mmpix: h% = h%*Pr_mmpix
END_IF
x% = x%-Pr_mg%: y% = y%-Pr_mg%
Pr_res%=DLL_CALL6("PrinterFunction",4,ADR(phnd%),ADR(chnd%),0,x%,y%): ' posit
Pr_res%=DLL_CALL6("PrinterFunction",2,ADR(phnd%),ADR(chnd%),1,w%,h%): ' rectangle
END_SUB
' ------------------------------------------------------------------------------
SUB Pr_Cercle(x%,y%,r%,u%)
' Tracé d'un cercle centré en x%,y%, rayon r%
' u% = 0: unités pixels, u% = 1, unités millimètres
IF inip% = 0 THEN EXIT_SUB: ' imprimante non initialisée
DIM_LOCAL x2%, y2%
x% = x%-r%: y% = y%-r%
x2% = 2*r%: y2% = 2*r%
IF u% = 1: ' unités en mm, conversion en pixels
   x% = x%*Pr_mmpix: y% = y%*Pr_mmpix
   x2% = x2%*Pr_mmpix: y2% = y2%*Pr_mmpix
END_IF
x% = x%-Pr_mg%: y% = y%-Pr_mg%: ' offset
Pr_res%=DLL_CALL6("PrinterFunction",4,ADR(phnd%),ADR(chnd%),0,x%,y%): ' posit
Pr_res%=DLL_CALL6("PrinterFunction",2,ADR(phnd%),ADR(chnd%),2,x2%,y2%): ' ellipse
END_SUB
' ------------------------------------------------------------------------------
SUB Pr_Ellipse(x%,y%,w%,h%,u%)
' Tracé d'une ellipse en x%,y%, dimensions de l'enveloppe w%,h%
' u% = 0: unités pixels, u% = 1, unités millimètres
IF inip% = 0 THEN EXIT_SUB: ' imprimante non initialisée
IF u% = 1: ' unités en mm, conversion en pixels
   x% = x%*Pr_mmpix: y% = y%*Pr_mmpix: w% = w%*Pr_mmpix: h% = h%*Pr_mmpix
END_IF
x% = x%-Pr_mg%: y% = y%-Pr_mg%
Pr_res%=DLL_CALL6("PrinterFunction",4,ADR(phnd%),ADR(chnd%),0,x%,y%): ' posit
Pr_res%=DLL_CALL6("PrinterFunction",2,ADR(phnd%),ADR(chnd%),2,w%,h%): ' ellipse
END_SUB
' ------------------------------------------------------------------------------
SUB Pr_Impr()
' Lancement de l'impression réelle ('fin d'impression')
IF inip% = 0 THEN EXIT_SUB: ' imprimante non initialisée
Pr_res% = DLL_CALL4("PrinterManager",3,ADR(phnd%),ADR(chnd%),0)
END_SUB
' ------------------------------------------------------------------------------

Il faut évidemment avant toute chose charger la dll avec DLL_ON "C:\...\KGF.dll"

Pour le diamètre, il s'agit du diamètre du cercle dont un quart sert d'arrondi pour les coins du rectangle arrondi.

Pour l'épaisseur du trait:

PrinterFunction code 6 permet de choisir l'épaisseur du trait, et éventuellement également la couleur de l'avant-plan et/ou de l'arrière-plan.

Donc, la commande

Code:: res% = dll_call6("PrinterFunction",6,adr(phnd%),adr(chnd%),-1,-1,3)

produira des traits de 3 pixels d'épaisseur.

Est-ce que tu as vu que KGF_SUB.bas contient des procédures multiples autour des fonctions d'impression ? Ne serait-ce que pour PrinterFunction, voici les procédures disponibles:

Code:: '
==== res% = DLL_call6("PrinterFunction",f%,phnd%,chnd%,opt1%,opt2%,opt3%)
sub PrinterFunctionText(txt$,opt%) : ' PrinterFunction f%=1
sub PrinterFunctionForm(forme%,w%,h%,r%) : ' PrinterFunction f%=2
sub PrinterFunctionFlood(mode%,R%,G%,B%) : ' PrinterFunction f%=3
sub PrinterFunctionRelativePosition(dx%,dy%) : ' PrinterFunction f%=4
sub PrinterFunctionAbsolutePosition(dx%,dy%) : ' PrinterFunction f%=4
sub PrinterFunctionStyle(pol$,siz%,R%,G%,B%,gras%,ital%,sous%,barr%)
sub PrinterFunctionColor(colorf%,colorb%,penw%) : ' PrinterFunction f%=6
sub PrinterFunctionImage(nom$,w%,h%) : ' PrinterFunction f%=7
sub PrinterFunctionGetMetrics(code%) : ' PrinterFunction f%=8
sub PrinterFunctionGetValues(code%,txt$) : ' PrinterFunction f%=9

Il en est de même pour les autres fonctions de gestion des impressions. J'ai essayé de fournir des procédures simples, dédiées chacune à une fonctionnalité précise...

Nombre de messages : 7112 Localisation : 77 Date d'inscription : 29/11/2007

Merci Klaus,

Effectivement, je n'ai pas trop étudié KGF_SUB.bas parce que j'aime bien faire les choses moi-même... quand je peux ! mais je me rends bien compte que j'ai réinventé (mal) la roue, puisque tu avais déjà codé tout ça.

Pour l'épaisseur du trait, j'ai vu après coup la fonction 6 et j'avais rectifié mon post plus haut, c'est évidemment très intéressant.

Pour la fonction 2 rectangle, je n'avais pas compris qu'on pouvait faire des coins arrondis, ça c'est super et je comprends mieux la remarque.

Merci pour tout en tout cas, et bon dimanche à toi et à tous les autres (s'il en reste qui ne sont pas en train de se faire cuire sur les plages) sunny

» imprimer avec Print.dll
» DLL Print
» print using
» stretch_on et print
» Prévisualisation dans PRINT.DLL