imprimer avec Print.dll

Sujet: imprimer avec Print.dll Lun 19 Nov 2018 - 17:01

Bonjour à tous.

Je voudrais imprimer un ficher .txt qui contient un nombre variable de lignes.

Y a t'il une personne qui le fait déjà avec print.dll, et pourrait me donner un exemple.

J' ai regardé les exemples, mais il n'y en a pas pour cela.

Je désirerais un exemple simple avec quelques lignes seulement.

Cela me permettra de comprendre rapidement pour ensuite étoffer mon programme.

Merci pour toutes vos réponses

Lepetitmarocain

Sujet: Re: imprimer avec Print.dll Lun 19 Nov 2018 - 20:01

Bonsoir lepetitmarocain,

Je suppose que tu parles bien de print.dll de l'ami Klaus.
J'avais fait autrefois un programme d'impression qui utilise cette dll, mais j'avoue qu'il était passé aux oubliettes,
Klaus ayant ajouté depuis des fonctions d'impression dans KGF.dll que j'utilise fréquemment.

Je te livre ci-dessous mon programme, sans garantie, ça peut te donner une idée de l'utilisation de print.dll...

Code:: LABEL PrInit, PrCarac, PrOrient, PrPosit, PrTrait, PrLigne, PrRectangle
LABEL PrCercle, PrEllipse, PrImage, PrTexte, PrClose, fpr
DIM PrNom$, phnd%, chnd%, njob$, wpt%, hpt%, wpu%, hpu%, mgp%, mhp%, k%, rel%, ray%
DIM x1%, y1%, x2%, y2%, f$, w%, h%, fnt$, sz%, attr$, mm, ct%, cb%, et%, txt$
DIM a$, sx1%, i%
' ==============================================================================
DLL_ON "KLAUS\Print.dll": ' ================= A AJUSTER ==========================
f$ = "C:\Graph\Jpg\Grille.jpg": ' ======= A AJUSTER ==========================
' ==============================================================================
fnt$ = "Arial": sz% = 12

GOSUB PrInit
' GOSUB PrCarac
mm = wpt%/210: ' nb de pixels par millimètres
x1% = 70*mm: ' centre à 70 mm du bord gauche
y1% = 60*mm
ray% = 20*mm: ' rayon
ct% = 255*256: cb% = -2: et% = 20
' GOSUB PrTrait
' GOSUB PrCercle
' x1% = 50*mm: y1% = 10*mm
' txt$ = "Au clair de la lune"+CHR$(13)+CHR$(10)+"Mon ami Pierrot"
' GOSUB PrTexte

x1% = 0: y1% = 0: w% = 1280: h% = 960: GOSUB PrImage
x1% = 1500: y1% = 0
w% = 1280: h% = 960: w% = w% - x1%: ' ***** ERREUR DE PRINT.DLL: x s'ajoute à la largeur
GOSUB PrImage
x1% = 0: y1% = 1000
w% = 1280: h% = 960: h% = h% - y1%: ' ***** ERREUR DE PRINT.DLL: y s'ajoute à la hauteur
GOSUB PrImage: goto fpr
fpr:
GOSUB PrClose

DLL_OFF
TERMINATE
END

PrInit:
' choix et initialisation de l'imprimante (si autre que l'imprimante windows)
' ou utile pour changer les 'Propriétés' de l'imprimante.
' PrNom$ = STRING$(255, " ")
' k% = DLL_CALL2("SelectWindowsPrinter",ADR(PrNom$),LEN(PrNom$))
' titre du job d'impression
' njob$ = ""
' k% = DLL_CALL4("PrinterManager",6,ADR(phnd%),ADR(njob$),LEN(njob$))
' ouverture du job d'impression
k% = DLL_CALL4("PrinterManager",1,ADR(phnd%),ADR(chnd%),0)
RETURN

PrCarac:
' caractéristiques de l'imprimante sur format A4, en pixels
wpt% = DLL_CALL6("PrinterFunction",8,ADR(phnd%),ADR(chnd%),3,0,0): ' largeur totale
hpt% = DLL_CALL6("PrinterFunction",8,ADR(phnd%),ADR(chnd%),4,0,0): ' hauteur totale
wpu% = DLL_CALL6("PrinterFunction",8,ADR(phnd%),ADR(chnd%),8,0,0): ' largeur utile
hpu% = DLL_CALL6("PrinterFunction",8,ADR(phnd%),ADR(chnd%),9,0,0): ' hauteur utile
mgp% = DLL_CALL6("PrinterFunction",8,ADR(phnd%),ADR(chnd%),1,0,0): ' marge gauche
mhp% = DLL_CALL6("PrinterFunction",8,ADR(phnd%),ADR(chnd%),2,0,0): ' marge haut
RETURN

PrOrient:
' Orientation Portrait: rel% = 0, Paysage: rel% = 1
k% = DLL_CALL4("PrinterManager",4,ADR(phnd%),ADR(chnd%),ADR(opt%))
RETURN

PrPosit:
' Positionnement en x1%,y1% (Absolu: rel% = 0, Relatif: rel% = 1)
k% = DLL_CALL6("PrinterFunction",4,ADR(phnd%),ADR(chnd%),rel%,x1%,y1%)
RETURN

PrTrait:
' caractéristiques du traçage: ct% couleur trait, cb% couleur fond, et% épaisseur trait
' ct% = couleur trait (-1 si inchangé)
' cb% = couleur fond (-1 si inchangé, -2 si transparent)
' et% = épaisseur du trait
k% = DLL_CALL6("PrinterFunction",6,ADR(phnd%),ADR(chnd%),ct%,cb%,et%)
RETURN

PrLigne:
' Dessin d'une ligne x1%,y1%,x2%,y2%
' x2% doit être différent de x1%, et y2% doit être différent de y1%
rel% = 0: GOSUB PrPosit: ' position de départ en x1%,y1%
k% = DLL_CALL6("PrinterFunction",4,ADR(phnd%),ADR(chnd%),0,x1%,y1%): ' posit
x2% = x2%-x1%: y2% = y2%-y1%: ' provisoire
k% = DLL_CALL6("PrinterFunction",2,ADR(phnd%),ADR(chnd%),0,x2%,y2%): ' ligne
RETURN

PrRectangle:
' Dessin rectangle en x1%,y1%, dimensions w% x h%.
' Coins arrondis: ray% = rayon (sinon 0)
rel% = 0: GOSUB PrPosit: ' position de départ en x1%,y1%
IF ray% > 0 THEN ray% = 256*ray%: ' coins arrondis
ray% = ray% + 1
k% = DLL_CALL6("PrinterFunction",2,ADR(phnd%),ADR(chnd%),ray%,w%,h%)
RETURN

PrCercle:
' Dessin d'un cercle de centre x1%,y1% et de rayon ray%
x1% = x1%-ray%: y1% = y1%-ray%: w% = 2*ray%: h% = w%
rel% = 0: GOSUB PrPosit: ' position de départ en x1%,y1%
k% = DLL_CALL6("PrinterFunction",2,ADR(phnd%),ADR(chnd%),2,w%,h%)
RETURN

PrEllipse:
' impression d'une ellipse de w% x h%
rel% = 0: GOSUB PrPosit: ' position de départ en x1%,y1%
k% = DLL_CALL6("PrinterFunction",2,ADR(phnd%),ADR(chnd%),2,w%,h%)
RETURN

PrImage:
' Impression d'une image f$ en x1%,y1%, dimensions w%,h%
rel% = 0: GOSUB PrPosit: ' position de départ en x1%,y1%
k% = DLL_CALL6("PrinterFunction",7,ADR(phnd%),ADR(chnd%),ADR(f$),w%,h%)
RETURN

PrTexte:
' Impression du texte txt$, fonte fnt$, taille sz%, attributs attr$, en x1%,y1%
' (éventuellement plusieurs lignes, séparées par retour chariot/interligne)
i% = INSTR(txt$, CHR$(13)+CHR$(10))
WHILE i% > 0
   a$ = LEFT$(txt$, i%-1): txt$ = MID$(txt$, i%+2, 1000)
   sx1% = x1%
   k%=DLL_CALL6("PrinterPrintText",ADR(a$),ADR(fnt$),ADR(attr$),sz%,ADR(x1%),ADR(y1%))
   x1% = sx1%: y1% = y1% + sz%*9.8: ' + interligne)
   i% = INSTR(txt$, CHR$(13)+CHR$(10))
END_WHILE
k%=DLL_CALL6("PrinterPrintText",ADR(txt$),ADR(fnt$),ADR(attr$),sz%,ADR(x1%),ADR(y1%))
RETURN

PrClose:
' Clôture du job (début d'impression physique)
k% = DLL_CALL4("PrinterManager",3,ADR(phnd%),ADR(chnd%),0)
RETURN

Les chemins de fichiers sont évidemment à adapter, comme d'habitude.

NB Les seuls s/p intéressants pour ton cas sont PrIinit, PrTexte et PrClose

Sujet: Re: imprimer avec Print.dll Lun 19 Nov 2018 - 20:21

Bonsoir à tous !

IL y a aussi ce sujet qui parle d'impression.

Il y est aussi présenté une solution avec une simple ligne de commande :

EXECUTE_WAIT "Cmd.exe | /c start /min Notepad.exe /p "+CHR$(34)+"Z:\Test.txt"+CHR$(34)

"Z:\Test.txt" étant le fichier à imprimer avec son chemin. Wink

Je crois que tu te reconnaîtra JL35 ! Laughing

Sujet: Re: imprimer avec Print.dll Lun 19 Nov 2018 - 20:36

Bonsoir Minibug, effectivement c'est beaucoup plus simple et j'en félicite l'auteur ! Very Happy

De toute façon je n'arrive même plus à faire marcher mon programme ci-dessus, même simplifié.
Je pense qu'il vaut mieux (à part des impressions simples avec notepad) utiliser KGF.dll qui a des fonctions d'impression puissantes, je les utilise couramment (textes, images, etc).

Nota Bene: dans l'exemple que tu as cité ci-dessus minibug, il faut bien mettre maintenant:
EXECUTE_WAIT "Cmd.exe|/c ...etc..."
avec la barre verticale entre exe et /c

@lepetitmarocain,
tu as donc ici une façon simple (parmi d'autres) d'imprimer un fichier texte.
Si tu veux un outil plus sophistiqué avec plein de possibilités, je te conseille d'utiliser KGF.dll de Klaus,
avec les fonctions
- initialisation de l'imprimante
- impression de texte
- lancement de l'impression physique
J'ai quelques subs qui font tout ça, je les mettrai ici si ça t'intéresse. Mais les possibilités sont bien plus grandes, et donc évidemment le paramétrage des fonctions est un peu plus compliqué.

Sujet: Re: imprimer avec Print.dll Lun 19 Nov 2018 - 21:10

Salut JL35 !

J'ai corrigé la ligne pour ne pas 'enduire' nos amis dans l'erreur... Laughing

Sujet: Re: imprimer avec Print.dll Lun 19 Nov 2018 - 21:11

Et tu as bien fait (on s'est croisés).

Sujet: print avec print.dll Mar 20 Nov 2018 - 15:45

JL35 a ecrit

Si tu veux un outil plus sophistiqué avec plein de possibilités, je te conseille d'utiliser KGF.dll de Klaus,
avec les fonctions
- initialisation de l'imprimante
- impression de texte
- lancement de l'impression physique
J'ai quelques subs qui font tout ça, je les mettrai ici si ça t'intéresse. Mais les possibilités sont bien plus grandes, et donc
évidemment le paramétrage des fonctions est un peu plus compliqué.

Bonjour

Merci pour toutes les réponses que vous avez envoyées.

Je me doutais que vous allez être très rapides pour m'envoyer des exemples

JL 35, j'aimerais avoir quelques exemples de SUBS, car je voudrais bien faire

quelque chose de plus compliqué (Font, titre etc... etc ...)

Merci par avance

Lepetitmarocain

Sujet: Re: imprimer avec Print.dll Mar 20 Nov 2018 - 17:28

Bon, alors allons-y !
Donc je précise bien que ce sont des subs qui utilisent des fonctions de KGF.dll

Il s'agit ici d'imprimer non pas un fichier mais une chaîne de caractères, comprenant éventuellement des retours chariot/interligne (donc plusieurs lignes), à un emplacement donné de la feuille, avec une police de caractères donnée, de taille et de couleur donnés, avec des enrichissements: ces paramètres étant appliqués à toute l'impression.

Il faut d'abord initialiser l'imprimante (ajuster le chemin de KGF.dll):

Code:: SUB Pr_init(orient%,prn$)
  ' Initialisation imprimante ('début d'impression')
  ' orient% = 0 Portrait, = 1 Paysage
  ' prn$ = "": imprimante par défaut
  ' sinon nom de l'imprimante (pour essais)
  ' par exemple "Microsoft XPS Document Writer" impression virtuelle
  ' dans un fichier .XPS
  ' Dans les paramètres des fonctions, le positionnement initial doit être fait en
  ' valeurs absolues: distances par rapport aux bords gauche et haut de la feuille
  ' A4, sans tenir compte des marges non imprimables.
  ' Les couleurs sont à exprimer au format BGR (en non pas RGB): B*256*256+G*256+R
  DLL_ON "C:\PANORAMIC\KGF\KGF.dll": ' <========== À AJUSTER ! ============
  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_px%") = 0 THEN DIM Pr_px%: ' pixels par mm (600 dpi)
  IF VARIABLE("Pr_lt%") = 0 THEN DIM Pr_lt%: ' largeur totale
  IF VARIABLE("Pr_ht%") = 0 THEN DIM Pr_ht%: ' hauteur totale
  IF VARIABLE("Pr_mg%") = 0 THEN DIM Pr_mg%: ' marge gauche
  IF VARIABLE("Pr_mh%") = 0 THEN DIM Pr_mh%: ' marge haut
  IF VARIABLE("Pr_lu%") = 0 THEN DIM Pr_lu%: ' largeur utile
  IF VARIABLE("Pr_hu%") = 0 THEN DIM Pr_hu%: ' hauteur utile
  IF prn$ <> "": ' pour essais sans impression réelle
   Pr_res%=DLL_CALL4("PrinterManager",10,ADR(phnd%),ADR(chnd%),ADR(prn$))
  END_IF
  ' Orientation portrait (0) ou paysage (1)
  Pr_res% = DLL_CALL4("PrinterManager",4,ADR(phnd%),ADR(chnd%),orient%): ' orientation
  Pr_res% = DLL_CALL4("PrinterManager",1,ADR(phnd%),ADR(chnd%),0): ' init
  ' Dimensions sans les marges, en pixels:
  ' ==========
  ' ATTENTION: Les dimensions sont actualisées en fonction de l'option orientation !
  ' ==========
  Pr_lt% = DLL_CALL6("PrinterFunction",8,ADR(phnd%),ADR(chnd%),3,0,0): ' largeur totale
  Pr_ht% = DLL_CALL6("PrinterFunction",8,ADR(phnd%),ADR(chnd%),4,0,0): ' hauteur totale
  IF orient% = 0
   Pr_px% = Pr_ht%/297: ' pixels par mm, à l'impression en 600 dpi
  ELSE
   Pr_px% = Pr_lt%/297: ' idem (paysage)
  END_IF
  ' Marges non imprimables: décalage en pixels à soustraire gauche et haut:
  Pr_mg% = DLL_CALL6("PrinterFunction",8,ADR(phnd%),ADR(chnd%),1,0,0): ' marge gauche
  Pr_mh% = DLL_CALL6("PrinterFunction",8,ADR(phnd%),ADR(chnd%),2,0,0): ' marge haut
  ' Dimensions utiles, en pixels:
  IF Pr_mg% = 0 OR Pr_mh%= 0: ' cas imprimante virtuelle (PDFCreator)
   Pr_mg% = 75: Pr_mh% = 75: ' forçage comme imprimante réelle
   Pr_lu% = Pr_lt% - 2*Pr_mg%: Pr_hu% = Pr_ht% - 2*Pr_mh%
  ELSE
   Pr_lu% = DLL_CALL6("PrinterFunction",8,ADR(phnd%),ADR(chnd%),7,0,0): ' largeur utile
   Pr_hu% = DLL_CALL6("PrinterFunction",8,ADR(phnd%),ADR(chnd%),8,0,0): ' hauteur utile
  END_IF
  ' Couleur trait noir, épaisseur = 1, arrière-plan transparent:
  inip% = -2
  Pr_res% = DLL_CALL6("PrinterFunction",6,ADR(phnd%),ADR(chnd%),0,inip%,1)
  inip% = 1
END_SUB

Si l'impression se fait sur l'imprimante implicite au format portrait, l'appel sera tout simplement:
Pr_init(0,"")
Ensuite on donne les caractéristiques du texte à imprimer:
chaîne, position sur la feuille (en pixels ou en millimètres), police, attributs, couleur, taille,
et type d'unité (pixels ou millimètres):

Code:: SUB Pr_Texte(txt$,x%,y%,pol$,attr$,ct%,sz%,u%)
' Impression du texte txt$ en x%,y%, police pol$, taille police sz%
' couleur ct% (format BGR), attributs attr$: GISB (gras, italique, souligné, barré)
' si plusieurs lignes: séparées par chr$(13)+chr$(10)
' u% = 0: unités pixels, u% = 1, unités millimètres
' ******** NB: coordonnées d'impression (pixels): de 75,75 à 4811,6862 ********
' LES COORDONNÉES D'IMPRESSION SONT EN VALEUR ABSOLUE (par rapport à 0,0 de la feuille)
' ** NB: Hauteur en millimètres des caractères imprimés = sz%/2.5 **
IF inip% = 0 THEN EXIT_SUB: ' imprimante non initialisée (Sub Pr_Init)
DIM_LOCAL htx%, ks%, ptra$
IF attr$ <> ""
   IF INSTR(attr$,"G") > 0 THEN sz% = sz%+256: ' gras
   IF INSTR(attr$,"I") > 0 THEN sz% = sz%+512: ' italique
   IF INSTR(attr$,"S") > 0 THEN sz% = sz%+1024: ' souligné
   IF INSTR(attr$,"B") > 0 THEN sz% = sz%+2046 : ' barré
END_IF
Pr_res% = DLL_call6("PrinterFunction",5,ADR(phnd%),ADR(chnd%),ADR(pol$),ct%,sz%)
IF u% = 1: ' unités en mm, conversion en pixels
   x% = x%*Pr_mmpix: y% = y%*Pr_mmpix
END_IF
htx% = DLL_call6("PrinterFunction",9,ADR(phnd%),ADR(chnd%),8,ADR(txt$),0): ' hauteur texte
ks% = INSTR(txt$,CHR$(13)+CHR$(10))
WHILE ks% > 0
   ptra$ = LEFT$(txt$, ks%-1): txt$ = MID$(txt$,ks%+2,LEN(txt$)-ks%-1)
   Pr_res% = DLL_call6("PrinterFunction",4,ADR(phnd%),ADR(chnd%),0,x%,y%): ' positionnement
   Pr_res% = DLL_call6("PrinterFunction",1,ADR(phnd%),ADR(chnd%),ADR(ptra$),LEN(ptra$),1)
   y% = y% + htx%
   ks% = INSTR(txt$,CHR$(13)+CHR$(10))
END_WHILE
IF txt$ <> ""
   Pr_res% = DLL_call6("PrinterFunction",4,ADR(phnd%),ADR(chnd%),0,x%,y%)
   Pr_res% = DLL_call6("PrinterFunction",1,ADR(phnd%),ADR(chnd%),ADR(txt$),LEN(txt$),1)
END_IF
END_SUB

Puis on lance physiquement l'impression:

Code:: SUB Pr_Impr()
  ' Lancement de l'impression réelle ('fin d'impression')
  IF inip% = 0 THEN EXIT_SUB: ' imprimante non initialisée (Sub Pr_Init)
  Pr_res% = DLL_CALL4("PrinterManager",3,ADR(phnd%),ADR(chnd%),0)
  inip% = 0
  DLL_OFF
END_SUB

Ces fonctions sont valables pour l'impression d'un texte à un endroit donné de la feuille, avec des caractéristiques données.
S'il s'agit d'un fichier contenant des enrichissements variés, il vaut mieux utiliser tout simplement une des fonctions citées plus haut, avec notepad.exe, ou write.exe (pour du texte au format rtf).

Il existe également des subs pour imprimer une image, ou des figures diverses, à un endroit donné de la feuille.
On peut faire succéder plusieurs textes ou figures, à des endroits différents, avant de lancer l'impression finale (Pr_Impr().

Sujet: Re: imprimer avec Print.dll Mar 20 Nov 2018 - 17:57

Un moyen encore plus simple (piqué sur internet) pour imprimer un fichier texte classique, ou bien un fichier avec des enrichissements genre RTF, et ça marche très bien:

Code:: DIM f$
f$ = "C:\TEMP\Exemole.txt"
PrintAny(f$)
END

SUB PrintAny(f$)
' Impression passante du fichier f$ (types différents à tester)
' (d'après: http://www.robvanderwoude.com/printfiles.php)
' Testé avec succès pour du .TXT et du .RTF (texte enrichi)
DIM_LOCAL q$,a$,fbat$
fbat$ = "Z:\Printany.bat": ' <=========== À AJUSTER ! ===================
q$ = CHR$(34)
DATA "PrintAny"
DATA "@ECHO OFF"
DATA "SETLOCAL"
DATA "SET PrintCmd="
DATA "SET FileType="
DATA "SET Temp=%Temp:"+q$+"=%"
DATA "FOR /F "+q$+"tokens=1* delims=="+q$+" %%A IN ('ASSOC %~x1') DO ("
DATA " FOR /F "+q$+"tokens=1 delims=="+q$+" %%C IN ('FTYPE ^| FIND /I "+q$+"%%~B"+q$+"') DO ("
DATA " CALL :GetPrintCommand %%~C"
DATA " )"
DATA ")"
DATA "IF NOT DEFINED PrintCmd GOTO NoAssoc"
DATA "CALL START /MIN "+q$+"PrintAny"+q$+" %PrintCmd%"
DATA "GOTO End"
DATA ":GetPrintCommand"
DATA "FOR /F "+q$+"tokens=3*"+q$+" %%D IN ('REG.EXE Query HKCR\%1\shell\print\command /ve 2^>NUL') DO SET PrintCmd=%%E"
DATA "IF NOT DEFINED PrintCmd GOTO:EOF"
DATA "SET PrintCmd=%PrintCmd:\"+q$+"="+q$+"%"
DATA "SET PrintCmd=%PrintCmd:"+q$+q$+"="+q$+"%"
DATA "SET PrintCmd=%PrintCmd:\\=\%"
DATA "ECHO.%PrintCmd% | FINDSTR.EXE /R /C:"+q$+"\"+q$+"%%1\"+q$+q$+" >NUL && SET PrintCmd=%PrintCmd:"+q$+"%1"+q$+"="+q$+"%%%~1"+q$+"%"
DATA "GOTO:EOF"
DATA ":NoAssoc"
DATA "CLS"
DATA ":End"
DATA "IF "+q$+"%OS%"+q$+"=="+q$+"Windows_NT"+q$+" ENDLOCAL"
DATA "F"
READ a$: WHILE a$<>"PrintAny": READ a$: END_WHILE
FILE_OPEN_WRITE 9,fbat$
READ a$: WHILE a$<>"F": FILE_WRITELN 9,a$: READ a$: END_WHILE
FILE_CLOSE 9
EXECUTE_WAIT fbat$+"|"+f$
FILE_DELETE fbat$
END_SUB

Ça doit marcher également pour d'autres formats, mais je n'ai pas essayé encore.
(Attention aux lignes de datas coupées éventuellement par le forum)

Sujet: print avec DLL Ven 23 Nov 2018 - 14:53

Bonjour.

Merci beaucoup à vous tous pour votre aide et surtout à JL35

En piquant un peu de code par ci par là, j'ai réussi à imprimer un fichier texte, mais (il y a tjrs un mais)

j' ai un petit problème

avec le code suivant je n'imprime qu'une ligne, alors que j'ai une dizaine de lignes dans mon fichier.

Pouvez vous me dire comment faire

Merci par avance

Le petit Marocain

ps: Comment faire pour avoir ce que j'ai mis en exemple pour l'avoir dans une fenêtre à part

Merci

' ******************************************************************************
DIM dll$, res%, phnd%, chnd%, txt$, pol$, sz%, attr$, cl%, clsz%, x%, y%, R, G, B ,toto$
dll$ = "KGF.dll"
DLL_ON dll$

dim a$

x% = 200: y% = 600
pol$ = "Arial"
sz% = 12
cl% = ((B*256+G)*256+R)*256
attr$ = "GAXAY": ' gras, positionnement en absolu
R = 0: G = 255: B = 0
clsz% = cl% + sz%

' Initialisation impression pour Titre *******************

res% = DLL_call4("PrinterManager",1,ADR(phnd%),ADR(chnd%),0): ' init imprimante

' *********************************************

' Titre ********************

txt$= "Liste des Mouvements"

res% = DLL_call6("PrinterPrintText",ADR(txt$),ADR(pol$),ADR(attr$),clsz%,ADR(x%),ADR(y%))

' ************************************************************
file_open_read 1,"Facture.txt"
while file_eof(1) <> 1
file_readln 1, a$

txt$=a$

y% = y% + 100

' Préparation impression de txt$

res% = DLL_call6("PrinterPrintText",ADR(txt$),ADR(pol$),ADR(attr$),clsz%,ADR(x%),ADR(y%))

end_while

' Clôture et lancement impression
res% = DLL_call4("PrinterManager",3,ADR(phnd%),ADR(chnd%),0): ' fermer et imprimer

TERMINATE

Sujet: Re: imprimer avec Print.dll Ven 23 Nov 2018 - 15:44

Bonjour lepetitmarocain,

Je vais regarder ton code, mais déjà pour mettre tes exemples de code dans une fenêtre à part:

Tu sélectionnes à la souris dans ton message la partie 'code', puis tu cliques sur l'icône ci-dessus (flèche rouge)
Tu peux aussi encadrer la partie concernée avec les balises [ code ] et [ /code ] (sans les espaces), mais le clic sur l'icône le fait automatiquement.

TEST
J'ai repris ton exemple tel quel avec un fichier de plusieurs lignes à moi.
Ça imprime bien toutes les lignes, mais décalées.
Tu fais bien progresser la variable y% dans ta boucle, mais il faut réinitialiser la variable x% à sa valeur initiale, pour que toutes les lignes commencent au même endroit (alignées verticalement).
Donc, dans la boucle while/end_while:
y% = y% + 100: x% = 200

N'oublie pas non plus de fermer la dll après usage:
DLL_OFF

Sujet: print avec dll Lun 26 Nov 2018 - 14:15

Bonjour à tous.

Merci beaucoup JL35, pour ta réponse qui a fait que mon programme imprime normalement.

Puisque j' y suis a demander des renseignements, peux tu me dire qu'elle est l’échelle utilisé pour X ou Y.

je voudrais transformer les chiffres (200) en cm juste pour calculer plus facilementsur une feuille

Merci pour ta réaction (Action , Réaction)

Lepetitmarocain

Sujet: Re: imprimer avec Print.dll Lun 26 Nov 2018 - 17:17

Bonjour à toi,
et tant mieux si ça marche !

Les dimensions x% et y% sont à exprimer en pixels.
On peut donner des valeurs en millimètres, mais il faut d'abord les convertir en pixels
avant de les donner à la fonction d'impression.

Pour ça, il faut connaître la définition de ton imprimante.
Mais c'est facile à déduire:
- tu donnes une valeur x% en pixels quelconque, assez élevée, par exemple 1000
- tu imprimes, et tu mesures sur le papier la distance de l'impression depuis le bord
- tu divises x% ( ici 1000) par la distance en mm, et tu as le nombre de pixels par millimètre.

A partir de là, dans ton programme d'impression, tu peux convertir les millimètres en pixels.

C'est un peu empirique, il y a des fonctions de kgf.dll qui te donnent les dimensions en pixels imprimés d'une page A4, hauteur et largeur, pour ton imprimante.
Par exemple, sur mon imprimante, c'est 4962 x 7013 pixels, pour 210 x 297 mm (c'est du 600 dpi).
Avec ces données c'est facile de faire les conversions.

Donc pour moi, je multiplie les valeurs en millimètres par 600/25,4 (600 pixels par pouce) pour avoir des pixels.

PS
Pour tout connaître de ton imprimante avec kgf.dll, tu as la fonction 8 de PrinterFunction (voir la doc)
Tu récupères au choix (en pixels) les marges, les dimensions totales, la résolution en dpi, et les dimensions utiles en pixels ou en millimètres.

Sujet: print avec Print.dll Jeu 29 Nov 2018 - 18:25

Bonsoir.

Merci beaucoup pour toutes vos réponses, et surtout à JL35.

Tout ce qui a été dit m'a bien servi, et cela me servira de reference

Encore merci.

Lepetitmarocain Smile

Sujet: Re: imprimer avec Print.dll Jeu 29 Nov 2018 - 21:33

Bonsoir lepetitmarocain,
C'est un peu long à expliquer mais très facile à mettre en oeuvre.

» demande explication KGF pour imprimer en mm
» imprimer
» Imprimer un fichier
» imprimer un texte
» Imprimer dans PANORAMIC