Sujet Précédent Sujet Suivant

Gérer les paramètres d'une impression d'un texte

Résolu
DenisPhil Messages postés 20 Date d'inscription mardi 13 mai 2008 Statut Membre Dernière intervention 21 août 2009 - 29 juil. 2009 à 18:54
Bacterius Messages postés 3792 Date d'inscription samedi 22 décembre 2007 Statut Membre Dernière intervention 3 juin 2016 - 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

11 réponses

Réponse 1 / 11
ni69 Messages postés 1418 Date d'inscription samedi 12 juin 2004 Statut Membre Dernière intervention 5 juillet 2010 12
29 juil. 2009 à 21:35
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 }
3
Réponse 2 / 11
Bacterius Messages postés 3792 Date d'inscription samedi 22 décembre 2007 Statut Membre Dernière intervention 3 juin 2016 10
29 juil. 2009 à 22:12
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 !
3
Réponse 3 / 11
ni69 Messages postés 1418 Date d'inscription samedi 12 juin 2004 Statut Membre Dernière intervention 5 juillet 2010 12
30 juil. 2009 à 00:15
Effectivement Bacterius, j'avais omis cette question !


@+
Nico { www.ni69.info }
3
Réponse 4 / 11
ni69 Messages postés 1418 Date d'inscription samedi 12 juin 2004 Statut Membre Dernière intervention 5 juillet 2010 12
30 juil. 2009 à 20:35
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 }
3

Vous n’avez pas trouvé la réponse que vous recherchez ?

Posez votre question
Réponse 5 / 11
Bacterius Messages postés 3792 Date d'inscription samedi 22 décembre 2007 Statut Membre Dernière intervention 3 juin 2016 10
30 juil. 2009 à 23:38
Oui oui chr(12) ou chr($C), ou encore #12

Cordialement, Bacterius !
3
Réponse 6 / 11
ni69 Messages postés 1418 Date d'inscription samedi 12 juin 2004 Statut Membre Dernière intervention 5 juillet 2010 12
31 juil. 2009 à 00:08
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 }
3
Réponse 7 / 11
armagnac32 Messages postés 1 Date d'inscription dimanche 3 octobre 2004 Statut Membre Dernière intervention 17 août 2009
17 août 2009 à 17:25
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
3
Réponse 8 / 11
ni69 Messages postés 1418 Date d'inscription samedi 12 juin 2004 Statut Membre Dernière intervention 5 juillet 2010 12
20 août 2009 à 23:08
@ DenisPhil : merci de cliquer sur "Réponse Acceptée" pour clôturer cet échange

@+
Nico { www.ni69.info }
3
Réponse 9 / 11
Bacterius Messages postés 3792 Date d'inscription samedi 22 décembre 2007 Statut Membre Dernière intervention 3 juin 2016 10
20 août 2009 à 23:12
Ouais faut en finir là ...

Cordialement, Bacterius !
3
Réponse 10 / 11
DenisPhil Messages postés 20 Date d'inscription mardi 13 mai 2008 Statut Membre Dernière intervention 21 août 2009
30 juil. 2009 à 00:42
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
0
Réponse 11 / 11
DenisPhil Messages postés 20 Date d'inscription mardi 13 mai 2008 Statut Membre Dernière intervention 21 août 2009
30 juil. 2009 à 23:14
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
0

Discussions similaires

gestion rendez vous+application open source
jahhouda -
Genildf -

4 réponses
interface pour gérer les rendez vous dans une clinique
Givenchy.plus -
BunoCS -

1 réponse
Projet de gestion d'un club sportif en C
landort -
Utilisateur anonyme -

5 réponses
coder un Tchat comme roulettechat.fr/chat/texte.php
samote152 -
samote152 -

2 réponses
Conjugaison 1er groupe
Immorta -
Dalfab -

2 réponses
Rejoignez-nous