Gérer les paramètres d'une impression d'un texte [Résolu]

DenisPhil 20 Messages postés mardi 13 mai 2008Date d'inscription 21 août 2009 Dernière intervention - 29 juil. 2009 à 18:54 - Dernière réponse : Bacterius 3869 Messages postés samedi 22 décembre 2007Date d'inscription 3 juin 2016 Dernière intervention
- 20 août 2009 à 23:12
Bonjour,
Ma question est la suivante: j'ai une table TStringList que j'ai constituée et je veux l'imprimer (imprimante Lexmark X1150).
Avec le source suivant:
[i]AssignPrn(P);
Rewrite(P);
for u = 0 to Table1.Count-1 do writeLn(P, table1[u]);
CloseFile(P);/i
ça fonctionne très bien mais... je ne peux pas modifier
- la fonte (nom, taille),
- la présentation (paysage / portrait) et
- je ne sais pas introduire de sauts de pages .
J'ai bien fouillé dans l'aide Delphi mais l'utilisation de TPrinter et de ses méthodes ne sont pas clairs pour moi.
Quelqu'un a-t-il des précisions, svp ?
Merci
Denis
Afficher la suite 

Votre réponse

11 réponses

Meilleure réponse
ni69 1529 Messages postés samedi 12 juin 2004Date d'inscription 5 juillet 2010 Dernière intervention - 29 juil. 2009 à 21:35
3
Merci
Tu peux utiliser le code suivant, qui te permet de faire plus de formatage:


[b]uses Printers;


// Orientation de la page : poLandscape ou poPortrait
Printer.Orientation := poLandscape;

// On peut également utiliser Printer.PageWidth et Printer.PageHeight

// Titre dans le gestionnaire d'impression
Printer.Title := 'Impression personnalisée';

// Nombre d'exemplaires
Printer.Copies := 1;

Printer.BeginDoc;

// Texte formaté
Printer.Canvas.Font.xxxxx := xxxxx;
// On place le texte
Printer.Canvas.TextOut(15,15,'formatage 1');

// Texte formaté
Printer.Canvas.Font.xxxxx := xxxxx;
// On place le texte
Printer.Canvas.TextOut(15,15,'formatage 2');

Printer.EndDoc;/b

@+
Nico { www.ni69.info }

Merci ni69 3

Avec quelques mots c'est encore mieux Ajouter un commentaire

Codes Sources a aidé 91 internautes ce mois-ci

Commenter la réponse de ni69
Meilleure réponse
Bacterius 3869 Messages postés samedi 22 décembre 2007Date d'inscription 3 juin 2016 Dernière intervention - 29 juil. 2009 à 22:12
3
Merci
Et je complète ni69 par les sauts de page, qui sont des caractères ASCII correspondant à la valeur $C (12). Tu as juste à insérer ce caractère là où tu veux un saut de page

Cordialement, Bacterius !

Merci Bacterius 3

Avec quelques mots c'est encore mieux Ajouter un commentaire

Codes Sources a aidé 91 internautes ce mois-ci

Commenter la réponse de Bacterius
Meilleure réponse
ni69 1529 Messages postés samedi 12 juin 2004Date d'inscription 5 juillet 2010 Dernière intervention - 30 juil. 2009 à 00:15
3
Merci
Effectivement Bacterius, j'avais omis cette question !


@+
Nico { www.ni69.info }

Merci ni69 3

Avec quelques mots c'est encore mieux Ajouter un commentaire

Codes Sources a aidé 91 internautes ce mois-ci

Commenter la réponse de ni69
Meilleure réponse
ni69 1529 Messages postés samedi 12 juin 2004Date d'inscription 5 juillet 2010 Dernière intervention - 30 juil. 2009 à 20:35
3
Merci
Non, mes deux xxxxx n'ont (presque) rien à voir entre eux ! Du moins ils ne représentent pas la même chose. Une déclaration correcte est par exemple la suivante (à toi d'en déduire toutes les autres possibilités de formatage, voir pour cela les propriétés de la classe TFont) :
Printer.Canvas.Font.Name := 'Tahoma';

En gros, on définit tout le formatage voulu, avant de positionner du texte sur le Canvas d'impression.

On peut ensuite utiliser toutes les procédures d'écriture classiques de TCanvas, celle qui t'intéresse ici étant TextOut. Cet exemple écrit du texte aux coordonnées (15,15) :

Printer.Canvas.TextOut(15, 15, 'exemple de texte');


Pour écrire tout le contenu d'un objet TStringList, tu peux faire directement :

Printer.Canvas.TextOut(15, 15, MaStrLst.Text);


A savoir que AssignPrn, Rewrite, writeln et CloseFile ne sont pas utilisés dans ce cas.

@+
Nico { www.ni69.info }

Merci ni69 3

Avec quelques mots c'est encore mieux Ajouter un commentaire

Codes Sources a aidé 91 internautes ce mois-ci

Commenter la réponse de ni69
Meilleure réponse
Bacterius 3869 Messages postés samedi 22 décembre 2007Date d'inscription 3 juin 2016 Dernière intervention - 30 juil. 2009 à 23:38
3
Merci
Oui oui chr(12) ou chr($C), ou encore #12

Cordialement, Bacterius !

Merci Bacterius 3

Avec quelques mots c'est encore mieux Ajouter un commentaire

Codes Sources a aidé 91 internautes ce mois-ci

Commenter la réponse de Bacterius
Meilleure réponse
ni69 1529 Messages postés samedi 12 juin 2004Date d'inscription 5 juillet 2010 Dernière intervention - 31 juil. 2009 à 00:08
3
Merci
Juste un petit détail pour DenisPhil : Quand tu écris du code Delphi, il est parfois pratique d'utiliser les balises de code pour éviter les erreurs d'affichage : Par exemple
TextOut(15, 15, MaStrLst[u]);

remplace avantageusement :
TextOut(15, 15, MaStrLst);

En effet, le [ u ] est utilisé pour le soulignement... Mais ce n'est qu'un détail !

@+
Nico { www.ni69.info }

Merci ni69 3

Avec quelques mots c'est encore mieux Ajouter un commentaire

Codes Sources a aidé 91 internautes ce mois-ci

Commenter la réponse de ni69
Meilleure réponse
armagnac32 1 Messages postés dimanche 3 octobre 2004Date d'inscription 17 août 2009 Dernière intervention - 17 août 2009 à 17:25
3
Merci
Je me suis fait cette petite unité (qui doit être améliorable) mais qui donne de bons résultats pour les mises en page :

unit JPP_Printer;

interface

uses WinTypes, WinProcs,
Windows, Messages, SysUtils, Classes, Graphics, Controls,
Forms, Dialogs, Printers, ExtCtrls;

const ftSB = 'Symbol';
ftAR = 'Arial';
ftTNR = 'Times New Roman';
ftCO = 'Coronet';
ftCN = 'Courier New';
ifSB = 0;
ifAR = 1;
ifTR = 2;
ifCO = 3;
ifCN = 4;
NFont : array[ifSB..ifCN] of TFontName = (ftSB, ftAR, ftTNR, ftCO, ftCN);

type TAlign = (alLeft, alCenter, alRight);
TCarPolice = record
Hauteur,
ExternalLeading,
InternalLeading,
Ascent,
Descent : longint;
end;

TImprimante = class(TObject)
tiPrinter : TPrinter;
tiDefaultDPI : integer;
tiX, tiY,
tiPixelsPerInch,
tiHauteurPage,
tiLargeurPage, // largeur imprimable
tiLPage, // largeur du papier
tiHPage,
tiMargeG,
tiMargeD,
tiMargeH,
tiMargeB : integer;
tiCarPolice : TCarPolice;
tiStarting : boolean;
tiFont : TFont;
tiFontTaille : longint;
constructor Create;
procedure Debut;
procedure SetPoliceTaille(nom : TFontName; taille : integer; s : TFontStyles);
procedure SetPT(index, taille : integer; s : TFontStyles);
procedure SetTaille(taille : integer);
// procedure SetHauteur(h : integer);
function SetX(X : integer): boolean;
function SetY(Y : integer): boolean;
function SetXAbs(X : integer): boolean;
function SetYAbs(Y : integer): boolean;
function PlusX(X : integer): boolean;
function PlusY(Y : integer): boolean;
function SetXY(X, Y : integer): boolean;
function GetAlignX(nb : integer; S : string): integer;
function GetXCentre(X0, X1 : integer; S : string): integer;
function GetYCentre(Y0, Y1 : integer; S : string): integer;
procedure CentreX(X0, X1 : integer; S : string);
procedure CentreY(Y0, Y1 : integer; S : string);
procedure CentreRect(X0, Y0, X1, Y1 : integer; S : string);
procedure CentreXPage(S : string);
function BasDePage : boolean;
function VerifieY : boolean;
Function CalculeIncY(Yhaut, Ybas, NbLigne : integer): integer;
procedure Cadre(X1, Y1, lg, ht, epaisseur : integer);
procedure Grise(X1, Y1, X2, Y2, epaisseur : integer);
procedure Trait(isVertical : boolean; longueur, epaisseur : integer);
procedure TraitXY(isVertical : boolean; X, Y, longueur, epaisseur : integer);
procedure Texte(align : TAlign; S : string);
procedure RTexte(nbCar : smallint; S : string);
procedure Ecrit(P, S : string);
procedure EcritXY(X, Y : integer; P, S : string);
procedure EcritXYAbs(X, Y : integer; P, S : string);
function GetLargeur(S : string): integer;
function GetHauteur(S : string): integer;
procedure SetTab(x : integer);
procedure EcritPenche(a : integer; S : string);
function GetHPolice(f, t : integer; isGras : boolean): integer;
function GetInfosPolice(what, f, t : integer; isGras : boolean): string;
procedure EnTitre(Club, S1, S2 : string);
procedure Entoure(Y1, X1, Y2, X2, epais : integer);
function GetX(X : longint): longint;
function GetY(Y : longint): longint;
function GetMX(coeff : integer): integer;
function GetMY(coeff : integer): integer;
procedure AligneDroite(nb : integer; S : string);
procedure Fin;
private
{ Déclarations privées }
tiTab : array[1..30] of integer;
tiCompteurTab : smallint;
tiNbTab : integer;
tiCarFontes : array[ifSB..ifCO, 8..24, false..true] of TCarPolice;
procedure FontMetric;
// procedure SetPixelsPerInch;
function Retour : boolean; // passage à la ligne sans remettre tiX à margeG
function Alaligne : boolean; // passage à la ligne
end;

var Imp : TImprimante;

implementation

uses MyTools;

const dixM : longint = 10000;

constructor TImprimante.Create;
begin
inherited;
tiPrinter := Printers.Printer;
tiFont := TFont.Create;
tiStarting := false;
tiX := 0;
tiY := 0;
tiHauteurPage := 0;
tiLargeurPage := 0;
tiLPage := 0;
tiHPage := 0;
tiMargeG := 0;
tiMargeD := 0;
tiMargeH := 0;
tiMargeB := 0;
FillChar(tiCarPolice, SizeOf(TCarPolice), 0);
FillChar(tiTab, SizeOf(tiTab), 0);
FillChar(tiCarFontes, SizeOf(tiCarFontes), 0);
tiCompteurTab := 0;
tiNbTab := 0;
end;

function TImprimante.GetX(X : longint): longint;
// X en dixièmes de mm
begin
Result := (X * tiLargeurPage) div DixM;
end;

function TImprimante.GetY(Y : longint): longint;
// Y en dixièmes de mm
begin
Result := (Y * tiHauteurPage) div dixM;
end;

function TImprimante.GetMX(coeff : integer): integer;
begin
Result := (tiLargeurPage * coeff) div 1000;
end;

function TImprimante.GetMY(coeff : integer): integer;
begin
Result := (tiHauteurPage * coeff) div 1000;
end;

function TImprimante.GetHauteur(S : string): integer;
begin
Result := tiPrinter.Canvas.TextHeight(S);
end;

procedure TImprimante.CentreRect(X0, Y0, X1, Y1 : integer; S : string);
begin
if SetX(GetXCentre(X0, X1, S))
and SetY(GetYCentre(Y0, Y1, S))
then tiPrinter.Canvas.TextOut(tiX, tiY, S);
end;

procedure TImprimante.TraitXY(isVertical : boolean; X, Y, longueur, epaisseur : integer);
begin
tiX := X;
tiY := Y;
Trait(isVertical, longueur, epaisseur);
end;

procedure TImprimante.EcritPenche(a : integer; S : string);
var FHandle : integer;
LogFont : TLogFont;
begin
with tiPrinter.Canvas
do begin
GetObject(Font.Handle, SizeOf(TLogFont), @LogFont);
LogFont.lfEscapement := a;
FHandle := CreateFontIndirect(LogFont);
if (FHandle <> 0)
then Font.Handle := FHandle;
TextOut(tiX, tiY, S);
end;
end;

procedure TImprimante.Entoure(Y1, X1, Y2, X2, epais : integer);
var OldWidth : integer;
begin
with Imp.tiPrinter.Canvas
do begin
OldWidth := Pen.Width;
Pen.Width := epais;
Rectangle(X1, Y1, X2, Y2);
Pen.Width := OldWidth;
end;
end;

procedure TImprimante.SetTab(x : integer);
begin
inc(tiNbTab);
tiTab[tiNbTab] := x;
tiCompteurTab := 0;
end;

function TImprimante.GetLargeur(S : string): integer;
begin
Result := tiPrinter.Canvas.TextWidth(S);
end;

function TImprimante.Retour : boolean;
// vrai si la place pour une ligne de plus
begin
PlusY(tiCarPolice.Hauteur);
Result := (tiY < (tiMargeB - tiCarPolice.Hauteur));
end;

function TImprimante.Alaligne : boolean;
// vrai si la place pour une ligne de plus
begin
SetX(0);
Result := Retour;
end;

function TImprimante.GetAlignX(nb : integer; S : string): integer;
begin
Result := tiPrinter.Canvas.TextWidth(StringOfChar('9', nb)) - tiPrinter.Canvas.TextWidth(S);
end;

procedure TImprimante.AligneDroite(nb : integer; S : string);
var x : integer;
begin
x := tiPrinter.Canvas.TextWidth(StringOfChar('9', nb)) - tiPrinter.Canvas.TextWidth(S);
if x > 0 then PlusX(x);
Ecrit('', S);
end;


procedure TImprimante.Ecrit(P, S : string);
// P contient des paramètres
var n, i : integer;

function GetNb(x : integer; S : string): integer;
begin
try
x := StrToInt(S[x + 1]);
except x := 0; end;
Result := x;
end;

begin
if S <> ''
then tiPrinter.Canvas.TextOut(tiX, tiY, S);

n := Pos('r', P);
if n <> 0
then begin // descend de x lignes sans revenir au bord gauche
for i := 1 to GetNb(n, P)
do Retour;
end;

n := Pos('l', P);
if n <> 0
then begin // retour à la ligne (il peut y en avoir plus d'un)
for i := 1 to GetNb(n, P)
do Alaligne;
end;

n := Pos('x', P);
if n <> 0
then begin // décale horizontalement de x espaces après le texte
// largeur texte + n espaces
inc(tiX, tiPrinter.Canvas.TextWidth(s + StringOfChar(#32, GetNb(n, P))));
end;
end;

procedure TImprimante.RTexte(nbCar : smallint; S : string);
begin
if (tiNbTab = 0) then exit;
inc(tiCompteurTab);
tiX := tiTab[tiCompteurTab] + GetAlignX(nbCar, S);
tiPrinter.Canvas.TextOut(tiX, tiY, S);
if tiCompteurTab = tiNbTab
then begin
Alaligne;
tiCompteurTab := 0;
VerifieY;
end;
end;

procedure TImprimante.Texte(align : TAlign; S : string);
var X : integer;
begin
if tiNbTab = 0 then exit;
inc(tiCompteurTab);
// recherche le bord droit
if tiCompteurTab = tiNbTab
then X := tiMargeD
else X := tiTab[tiCompteurTab + 1];
case align of
alLeft : begin
tiX := tiTab[tiCompteurTab];
if S <> ''
then tiPrinter.Canvas.TextOut(tiX, tiY, S);
end;
alCenter : CentreX(tiTab[tiCompteurTab], X, S);
alRight : begin
tiX := X - tiPrinter.Canvas.TextWidth(S);
if S <> ''
then tiPrinter.Canvas.TextOut(tiX, tiY, S);
end;
end;

if tiCompteurTab = tiNbTab
then begin
Alaligne;
tiCompteurTab := 0;
VerifieY;
end;
end;

procedure TImprimante.EcritXYAbs(X, Y : integer; P, S : string);
begin
SetXAbs(X);
SetYAbs(Y);
Ecrit(P, S);
end;

procedure TImprimante.EcritXY(X, Y : integer; P, S : string);
begin
SetX(X);
SetY(Y);
Ecrit(P, S);
end;

function TImprimante.BasDePage : boolean;
begin
Result := (tiY > tiMargeB - tiCarPolice.Hauteur);
end;

function TImprimante.VerifieY : boolean;
var nom : TFontName;
taille : integer;
s : TFontStyles;
begin
Result := false;
if BasDePage
then begin
nom := tiFont.Name;
taille := tiFontTaille;
s := tiFont.Style;
tiPrinter.NewPage;
tiX := 0;
tiY := 0;
SetPoliceTaille(nom, taille, s);
Result := true;
end;
end;

procedure TImprimante.Trait(isVertical : boolean; longueur, epaisseur : integer);
begin
with tiPrinter.Canvas
do begin
Pen.Width := round(epaisseur * tiPixelsPerInch / 300);
MoveTo(tiX, tiY);
if isVertical
then LineTo(tiX, tiY + longueur)
else LineTo(tiX + longueur, tiY);
end;
end;

function TImprimante.GetYCentre(Y0, Y1 : integer; S : string): integer;
begin
Result := Y0 + ((Y1 - Y0 - tiPrinter.Canvas.TextHeight(S)) div 2);
end;

function TImprimante.GetXCentre(X0, X1 : integer; S : string): integer;
begin
Result := X0 + ((X1 - X0 - tiPrinter.Canvas.TextWidth(S)) div 2);
end;

procedure TImprimante.CentreX(X0, X1 : integer; S : string);
begin
if SetX(GetXCentre(X0, X1, S))
then tiPrinter.Canvas.TextOut(tiX, tiY, S);
end;

procedure TImprimante.CentreY(Y0, Y1 : integer; S : string);
begin
if SetY(GetYCentre(Y0, Y1, S))
then tiPrinter.Canvas.TextOut(tiX, tiY, S);
end;

procedure TImprimante.CentreXPage(S : string);
begin
CentreX(0, tiLargeurPage, S);
end;

procedure TImprimante.Fin;
begin
tiPrinter.EndDoc;
end;

function TImprimante.SetXAbs(X : integer): boolean;
// place X en fonction du bord de la page
begin
Result := SetX(X - tiMargeG);
end;

function TImprimante.SetYAbs(Y : integer): boolean;
begin
Result := SetY(Y - tiMargeH);
end;

function TImprimante.SetX(X : integer): boolean;
// positionne l'abcisse dans [0..largeurPage]
begin
if (X < 0) or (X > tiLargeurPage)
then Result := false
else begin
tiX := X;
Result := true;
end;
end;

function TImprimante.SetY(Y : integer): boolean;
// positionne l'ordonnée dans [0..hauteurPage]
begin
if (Y < 0) or (Y > tiHauteurPage)
then Result := false
else begin
tiY := Y;
Result := true;
end;
end;

function TImprimante.SetXY(X, Y : integer): boolean;
begin
Result := SetX(X) and SetY(Y);
end;

function TImprimante.PlusX(X : integer): boolean;
begin
inc(tiX, X);
Result := (tiX >= 0) and (tiX <= tiLargeurPage);
end;

function TImprimante.PlusY(Y : integer): boolean;
begin
inc(tiY, Y);
Result := (tiY >= 0) and (tiY <= tiHauteurPage);
end;

procedure TImprimante.FontMetric;
var Metrics : TTextMetric;
begin
if GetTextMetrics(tiPrinter.canvas.handle, Metrics)
then begin
// descriptif interne
tiCarPolice.ExternalLeading := Metrics.tmExternalLeading;
tiCarPolice.InternalLeading := Metrics.tmInternalLeading;
tiCarPolice.Ascent := Metrics.tmAscent;
tiCarPolice.Descent := Metrics.tmDescent;
// taille des fontes en hauteur
tiCarPolice.Hauteur := Metrics.tmExternalLeading +
Metrics.tmAscent +
Metrics.tmDescent;
end;
end;

function TImprimante.GetInfosPolice(what, f, t : integer; isGras : boolean): string;
begin
case what of
0 : Result :'ExternalL ' + IntToStr(tiCarFontes[f,t,isGras].ExternalLeading);
1 : Result :'InternalL ' + IntToStr(tiCarFontes[f,t,isGras].InternalLeading);
2 : Result :'Ascent ' + IntToStr(tiCarFontes[f,t,isGras].Ascent);
3 : Result :'Descent ' + IntToStr(tiCarFontes[f,t,isGras].Descent);
4 : Result :'Hauteur ' + IntToStr(tiCarFontes[f,t,isGras].Hauteur);
end;
end;


procedure TImprimante.SetTaille(taille : integer);
begin
if tiFontTaille <> taille
then SetPoliceTaille(tiFont.Name, taille, tiFont.Style);
end;


procedure TImprimante.SetPoliceTaille(nom : TFontName; taille : integer; s : TFontStyles);
// taille en 1/72 eme de pouce
var ttm : TTextMetric;
LogFont : TLogFont;
begin
tiFontTaille := taille;
tiPrinter.Canvas.Font.Name := nom;
tiPrinter.Canvas.Font.Height := -round(taille / 72 * 254);
tiPrinter.Canvas.Font.Style := s;
GetTextMetrics(tiPrinter.Canvas.Font.Handle, ttm);
with LogFont
do begin
lfHeight := ttm.tmHeight;
lfWidth := 0;
lfEscapement := 0;
lfOrientation := 0;
// ajout
if fsBold in tiPrinter.Canvas.Font.Style
then lfWeight := FW_BOLD
else lfWeight := FW_NORMAL;
// suppression
// lfWeight := ttm.tmWeight;
lfItalic := byte(fsItalic in tiPrinter.Canvas.Font.Style); // ttm.tmItalic;
lfUnderline := 0; // byte(fsUnderline in tiPrinter.Canvas.Font.Style);// ttm.tmUnderlined;
lfStrikeOut := byte(fsStrikeOut in tiPrinter.Canvas.Font.Style); // ttm.tmStruckOut;
lfCharSet := ttm.tmCharSet;
lfOutPrecision := OUT_DEFAULT_PRECIS;
lfClipPrecision := CLIP_DEFAULT_PRECIS;
lfQuality := DEFAULT_QUALITY;
lfPitchAndFamily := ttm.tmPitchAndFamily;
GetTextFace(tiPrinter.Canvas.Handle, lf_FaceSize - 1, lfFaceName);
end;
tiFont.Handle := CreateFontIndirect(LogFont);
FontMetric;
end;

procedure TImprimante.SetPT(index, taille : integer; s : TFontStyles);
begin
SetPoliceTaille(NFont[index], taille, s);
end;

procedure TImprimante.Debut;
var pt : TPoint;
HorizontalInch,
VerticalInch,
lp1x, lp1y, f, t : longint;
lx, ly, lmx, lmy : double;
Size : TSize;
begin
tiPrinter.BeginDoc;
SetMapMode(tiprinter.canvas.handle, MM_ISOTROPIC);
{HORZRES Largeur de la page imprimable en pixels.}
Lp1x := GetDeviceCaps(tiprinter.canvas.handle, HORZRES);
Lp1y := GetDeviceCaps(tiprinter.canvas.handle, VERTRES);
// pt contient la largeur (x) et la hauteur (y) de la page en pixels
Escape(tiprinter.canvas.handle, GETPHYSPAGESIZE, 0, NIL, @pt);
{LOGPIXELSX pixels par pouce en largeur (résolution)}
HorizontalInch := GetDeviceCaps(tiprinter.canvas.handle, LOGPIXELSX);
{LOGPIXELSY pixels par pouce en hauteur (résolution)}
VerticalInch := GetDeviceCaps(tiprinter.canvas.handle, LOGPIXELSY);
tiPixelsPerInch := VerticalInch;
// marge latérale
lmx := ((pt.x - lp1x) div 2) / HorizontalInch;
// marge verticale
lmy := ((pt.y - lp1y) div 2) / VerticalInch;
// les mêmes en 10èmes de mm
tiMargeG := Round(lmx * 254); // en 10èmes de mm
tiMargeH := Round(lmy * 254);

// largeur et hauteur imprimables
lmx := lp1x / HorizontalInch; // passage pixels en pouces
lmy := lp1y / VerticalInch;
tilargeurPage := Round(lmx * 25.4) * 10; // passage pouces en mm
tihauteurPage := Round(lmy * 25.4) * 10;
tiMargeB := tihauteurPage - tiMargeH;
tiMargeD := timargeG + tiLargeurPage;
{Pixels en pouces}
lx := pt.x / HorizontalInch; // largeur totale : pixels en pouces
ly := pt.y / VerticalInch;
{Pouces en 10 èmes de mm}
tilPage := Round(lx * 25.4 )* 10; // largeur totale en 10èmes de mm
tihPage := Round(Ly * 25.4 )* 10; //

// 2100 unités logiques en x, 2970 en y
SetWindowExtEx (tiprinter.canvas.handle, tilPage, tihPage, @Size);
SetViewPortExtEx(tiprinter.canvas.handle, pt.x, pt.y, @Size);

// calcule les tailles des polices
for f := ifSB to ifCO
do for t := 8 to 24
do begin
SetPT(f, t, []);
Move(tiCarPolice, tiCarFontes[f, t, false], SizeOf(TCarPolice));
SetPT(f, t, [fsBold]);
Move(tiCarPolice, tiCarFontes[f, t, true], SizeOf(TCarPolice));
end;

tiStarting := true;
tiX := 0;
tiY := 0;
// police par défaut : Arial corps 10
SetPT(ifAR, 10, []);
end;

function TImprimante.GetHPolice(f, t : integer; isGras : boolean): integer;
begin
Result := tiCarFontes[f, t, isGras].Hauteur -
tiCarFontes[f, t, isGras].Descent;
end;

procedure TImprimante.Cadre(X1, Y1, lg, ht, epaisseur : integer);
var OldEpaisseur : integer;
begin
with tiPrinter.Canvas
do begin
OldEpaisseur := Pen.Width;
Pen.Width := epaisseur * round(tiPixelsPerInch / 300);
Rectangle(X1, Y1, X1 + lg, Y1 + ht);
{ replace les anciennes valeurs }
Pen.Width := OldEpaisseur;
end;
end;

procedure TImprimante.Grise(X1, Y1, X2, Y2, epaisseur : integer);
var OldColor : TColor;
OldStyle : TBrushStyle;
OldEpaisseur : integer;
begin
with tiPrinter.Canvas
do begin
OldColor := Brush.Color;
OldStyle := Brush.Style;
Brush.Style := bsSolid;
Brush.Color := $02E8E8E8; { 02F0F0F0 }
{ et le liseré }
OldEpaisseur := Pen.Width;
Pen.Width := epaisseur * round(tiPixelsPerInch / 300);
Rectangle(X1, Y1, X2, Y2);
{ replace les anciennes valeurs }
Brush.Color := OldColor;
Brush.Style := OldStyle;
Pen.Width := OldEpaisseur;
end;
end;


Function TImprimante.CalculeIncY(Yhaut, Ybas, NbLigne : integer): integer;
begin
CalculeIncY := ((Ybas - Yhaut - (NbLigne * tiCarPolice.Hauteur)) div NbLigne)
+ tiCarPolice.Hauteur;
end;

procedure TImprimante.EnTitre(Club, S1, S2 : string);
const mini = 10;
var OldBC : TColor;
OldStyle : TBrushStyle;
begin
tiY := timargeH;
Grise(mini, mini, tilargeurPage - mini, tiHauteurPage div 12, 2);
//
with tiPrinter.Canvas
do begin
OldBC := Brush.Color;
OldStyle := Brush.Style;
Brush.Color := $02E8E8E8;
Brush.Style := bsSolid;
tiY := mini + mini;
tiX := tiY;
SetPT(2, 12, [fsBold]);
Ecrit('', Club);
if S2 = ''
then SetPT(2, 20, [fsBold])
else SetPT(2, 18, [fsBold]);
tiY := mini + tiHauteurPage div 48;
CentreXPage(S1);
if S2 <> ''
then begin
tiY := mini + tiHauteurPage div 20;
SetPT(2, 18, [fsItalic]);
CentreXPage(S2);
end;
Brush.Color := OldBC;
Brush.Style := OldStyle;
end;
// positionne X et Y
tiY := tiHauteurPage div 10;
tiX := 0;
end;

end.

Dans le programme qui l'utilise, il faut faire :
Imp := TImprimante.Create;
try
with Imp
do begin
// éventuellement le titre
Debut;
// ici tout le travail d'impression
Fin;
end;
finally Imp.Free; end;

Dans l'unité, tout ce qu'il faut pour mettre la fonte que l'on veut, centrer, etc.

jp

Merci armagnac32 3

Avec quelques mots c'est encore mieux Ajouter un commentaire

Codes Sources a aidé 91 internautes ce mois-ci

Commenter la réponse de armagnac32
Meilleure réponse
ni69 1529 Messages postés samedi 12 juin 2004Date d'inscription 5 juillet 2010 Dernière intervention - 20 août 2009 à 23:08
3
Merci
@ DenisPhil : merci de cliquer sur "Réponse Acceptée" pour clôturer cet échange

@+
Nico { www.ni69.info }

Merci ni69 3

Avec quelques mots c'est encore mieux Ajouter un commentaire

Codes Sources a aidé 91 internautes ce mois-ci

Commenter la réponse de ni69
Meilleure réponse
Bacterius 3869 Messages postés samedi 22 décembre 2007Date d'inscription 3 juin 2016 Dernière intervention - 20 août 2009 à 23:12
3
Merci
Ouais faut en finir là ...

Cordialement, Bacterius !

Merci Bacterius 3

Avec quelques mots c'est encore mieux Ajouter un commentaire

Codes Sources a aidé 91 internautes ce mois-ci

Commenter la réponse de Bacterius
DenisPhil 20 Messages postés mardi 13 mai 2008Date d'inscription 21 août 2009 Dernière intervention - 30 juil. 2009 à 00:42
0
Merci
Merci ni69, merci Bacterius de ces infos.
J'ai vu pour le saut de page, merci, mais il reste un pb, tout de même...
Dans la liste des paramètres à utiliser, où dois-je placer les lignes à imprimer ?
Entre un BeginDoc et un EndDoc ? Du genre :
[i]Printer.Orientation := poLandscape;
Printer.Copies := 1;
Printer.BeginDoc;
Printer.Canvas.Font.Tahoma := Tahoma; <=== ça sert à quoi ?
writeln(P, ma_ligne); < === c'est ça ?
Printer.EndDoc; /i

Le AssignPrn() et Rewrite() ne servent plus dans ce cas ?

Merci de me donner qq précisions...
Denis
Commenter la réponse de DenisPhil
DenisPhil 20 Messages postés mardi 13 mai 2008Date d'inscription 21 août 2009 Dernière intervention - 30 juil. 2009 à 23:14
0
Merci
Merci de ces détails clairs et précis.
Mon impression est maintenant au point.
J'ai du tout de même modifié l'écriture du TextOut car la forme :
Printer.Canvas.TextOut(15, 15, MaStrLst[u])
dans une boucle, me donne UNE SEULE ligne imprimée...
En écrivant :
Printer.Canvas.TextOut(15, u*15, MaStrLst[u])
les lignes sont imprimées l'une au-dessous de l'autre (sur le papier).

Je n'ai pas encore testé le saut de page (avec un chr(12) je suppose ?) mais cela ne saurait tarder.

Encore merci de ces infos et conseils.
Denis
Commenter la réponse de DenisPhil

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.