Kylix und drucken

[Brujah]

Hallo Leute,

ich möchte einen Teil meines Haupt Forms ausdrucken,
gibt es dazu eine einfache Möglichkeit ?

[TheDodger]

wie ausdrucken?
als sourcecode, oder als screenshot?

[Brujah]

Als Screenshot. Also alle Elemente samt eingegebene Daten.

[Mattburger]

bin leider (noch) VCL/WIN32 Profi noch kein qt/VCX Profi.

Aber bei Win32 war es einfach Form.print.
Hiermit wurde dann das entsprechende Formular auf den
Canvas des Printers geschreiben.

[Brujah]

Habe das gestern auch in einem Delphi 3 Buch gelesen. In meinem
Kylix Buch wird garnix über drucken geschrieben :-( War denen wohl auch zu abgefahren.

Habe mal einn kleinen Test zum Ascii druck geschrieben:

AssignFile(MyFile);
ReWrite(MyFile);
Writeln(MyFile,'Dies ist ein Test');
CloseFile(MyFile);

Das tut aber auch net ... Da kommt ein Fehler der irgendwas mit Pipe heisst ...

Ist wohl alles net so einfach :-(

Hat hier schonmal jemand unter Kylix überhaupt irgendwas ausgedruckt bekommen ?

Markus

[Mattburger]

Bei Windows läuft alles über die GDI (Graphik Device Interface)- Bibliothek.
Es besteht deshalb theoretisch (und zu 99% auch Praktisch) kein Unterschied
zwischen Bildschirm und Drucker.
Bei Linux wurde hier der Postscript-Standard benutzt. D.H. für Dich du must
Postscript auswendig lernen.
Jedoch gibt es auch die Möglichkeit direkt eine Druckersprache anzusprechen.
Da war dein Ansatz fast richtig. Ich kanns leider nicht ausprobieren, dürfte jedoch
so gehen:

var
MyFile: TextFile;
begin
AssignPrn(MyFile);
Rewrite(MyFile);
Writeln(MyFile, 'Dieser Text wird gedruckt.');
System.CloseFile(MyFile);


Ich hab jedoch in der Bibliothek in einem Kylix Buch auch den Ansatz über Canvas
gefunden.
Anscheinend haben die Borlander es fertig gebracht die Canvas-ausgabe weitestgehend auf Postscript umzubigen. Echt genial. Du must also doch nicht
Postscript auswendig lernen, sondern kannst bei TCanvas bleiben.

Leider bekomme ich erst nächste Woche mein Kylix.

viel Spass

[anda_skoa]

Bei Windows läuft alles über die GDI (Graphik Device Interface)- Bibliothek.
Es besteht deshalb theoretisch (und zu 99% auch Praktisch) kein Unterschied
zwischen Bildschirm und Drucker.
Bei Linux wurde hier der Postscript-Standard benutzt. D.H. für Dich du must
Postscript auswendig lernen.

Das haöte ich für ein Gerücht. Du mußt Postscript nur direkt erzeugen, wenn du etwas ganz spezielle machen willst.

Wenn man zB Qt verwendet, zeichnet man in einen QPrinter genauso wie in ein Pixmap oder ein Widget.

Die QPrinter Klasse übernimmt in ihrem Fall das umsetzten der Zeichenbefehle. Unter Windows auf eine Context des Druckers, unter Unix erzeugt es Postscript.

Nachdem Kylix ja, Qt verwendet, kann es sein, dass dazu die entsprechenden ObjectPascal Interfaces existieren.

Ich hab jedoch in der Bibliothek in einem Kylix Buch auch den Ansatz über Canvas
gefunden.
Anscheinend haben die Borlander es fertig gebracht die Canvas-ausgabe weitestgehend auf Postscript umzubigen. Echt genial. Du must also doch nicht
Postscript auswendig lernen, sondern kannst bei TCanvas bleiben.

Sag ich ja ;-)
Ist aber der Verdienst der Trolltech Entwickler.

Ciao,
_

[Brujah]

Also das ausdrucken eines Ascii Textes mit dem Beispiel weiter oben
hat bei mir jetzt funktioniert.
Jetzt ist mir aber immer noch nicht klar wie ich die Elemente eines
Forms in das Cancas übernehmen kann. In meinem Buch wird nur
beschrieben wie man da Kreise, Dreiecke und so nen Zeug malt. Und eben Bilder druckt, aber kein Wort über Formulare.
Hat mir da vielleicht jemand nen Delphi Beispiel ?

[Mattburger]

Heut bekomm ich mein Kylix - Juhu

Das hilft dir zwar noch nicht mit Deinem Problem, aber ich wollte mich ohnehin dieser Problematik widmen und werde dir bei Erfolg bescheid geben.

Also unter Windows bzw. der VCL musstest du hierfuer sowas wie eine
"draw" - routine mit deinem Canvas aufrufen.
Den Canvas kannst du direkt von printer.canvas verwenden.
Das ist jetzt aber wirklich aus der Hueffte geschossen.


printer.BeginnDoc;
myform.draw( printer .canvas );
printer.EndDoc;

[Brujah]

Es läuft immer noch net ...
Habe jetzt mal eine Vorabversion mit reinem Textdruck erstellt. So hat man wenigstens etwas in der Hand.

Das einzige was ich bisher noch zu diesem Thema gefunden habe war folgendes Beispiel auf der Borland Seite:
(das bekomme ich aber unter Kylix bisher auch noch net zum laufen :-( )

-------------------------------------------------

TI1412D.txt - A Better Way To Print a Form

Category :Printing
Platform :All-32Bit
Product :All32Bit,

Description:

The following TI details a better way to print the contents of
a form, by getting the device independent bits in 256 colors
from the form, and using those bits to print the form to the
printer.

In addition, a check is made to see if the screen or printer
is a palette device, and if so, palette handling for the device
is enabled. If the screen device is a palette device, an additional
step is taken to fill the bitmap's palette from the system palette,
overcoming some buggy video drivers who don't fill the palette in.

Note: Since this code does a screen shot of the form, the form must
be the topmost window and the whole from must be viewable when the
form shot is made.




unit Prntit;

interface

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

type
TForm1 = class(TForm)
Button1: TButton;
Image1: TImage;
procedure Button1Click(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
end;

var
Form1: TForm1;

implementation

{$R *.DFM}


uses Printers;


procedure TForm1.Button1Click(Sender: TObject);
var
dc: HDC;
isDcPalDevice : BOOL;
MemDc :hdc;
MemBitmap : hBitmap;
OldMemBitmap : hBitmap;
hDibHeader : Thandle;
pDibHeader : pointer;
hBits : Thandle;
pBits : pointer;
ScaleX : Double;
ScaleY : Double;
ppal : PLOGPALETTE;
pal : hPalette;
Oldpal : hPalette;
i : integer;
begin
{Get the screen dc}
dc := GetDc(0);
{Create a compatible dc}
MemDc := CreateCompatibleDc(dc);
{create a bitmap}
MemBitmap := CreateCompatibleBitmap(Dc,
form1.width,
form1.height);
{select the bitmap into the dc}
OldMemBitmap := SelectObject(MemDc, MemBitmap);

{Lets prepare to try a fixup for broken video drivers}
isDcPalDevice := false;
if GetDeviceCaps(dc, RASTERCAPS) and
RC_PALETTE = RC_PALETTE then begin
GetMem(pPal, sizeof(TLOGPALETTE) +
(255 * sizeof(TPALETTEENTRY)));
FillChar(pPal^, sizeof(TLOGPALETTE) +
(255 * sizeof(TPALETTEENTRY)), #0);
pPal^.palVersion := $300;
pPal^.palNumEntries :=
GetSystemPaletteEntries(dc,
0,
256,
pPal^.palPalEntry);
if pPal^.PalNumEntries <> 0 then begin
pal := CreatePalette(pPal^);
oldPal := SelectPalette(MemDc, Pal, false);
isDcPalDevice := true
end else
FreeMem(pPal, sizeof(TLOGPALETTE) +
(255 * sizeof(TPALETTEENTRY)));
end;

{copy from the screen to the memdc/bitmap}
BitBlt(MemDc,
0, 0,
form1.width, form1.height,
Dc,
form1.left, form1.top,
SrcCopy);

if isDcPalDevice = true then begin
SelectPalette(MemDc, OldPal, false);
DeleteObject(Pal);
end;

{unselect the bitmap}
SelectObject(MemDc, OldMemBitmap);
{delete the memory dc}
DeleteDc(MemDc);
{Allocate memory for a DIB structure}
hDibHeader := GlobalAlloc(GHND,
sizeof(TBITMAPINFO) +
(sizeof(TRGBQUAD) * 256));
{get a pointer to the alloced memory}
pDibHeader := GlobalLock(hDibHeader);

{fill in the dib structure with info on the way we want the DIB}
FillChar(pDibHeader^,
sizeof(TBITMAPINFO) + (sizeof(TRGBQUAD) * 256),
#0);
PBITMAPINFOHEADER(pDibHeader)^.biSize :=
sizeof(TBITMAPINFOHEADER);
PBITMAPINFOHEADER(pDibHeader)^.biPlanes := 1;
PBITMAPINFOHEADER(pDibHeader)^.biBitCount := 8;
PBITMAPINFOHEADER(pDibHeader)^.biWidth := form1.width;
PBITMAPINFOHEADER(pDibHeader)^.biHeight := form1.height;
PBITMAPINFOHEADER(pDibHeader)^.biCompression := BI_RGB;

{find out how much memory for the bits}
GetDIBits(dc,
MemBitmap,
0,
form1.height,
nil,
TBitmapInfo(pDibHeader^),
DIB_RGB_COLORS);

{Alloc memory for the bits}
hBits := GlobalAlloc(GHND,
PBitmapInfoHeader(pDibHeader)^.BiSizeImage);
{Get a pointer to the bits}
pBits := GlobalLock(hBits);

{Call fn again, but this time give us the bits!}
GetDIBits(dc,
MemBitmap,
0,
form1.height,
pBits,
PBitmapInfo(pDibHeader)^,
DIB_RGB_COLORS);

{Lets try a fixup for broken video drivers}
if isDcPalDevice = true then begin
for i := 0 to (pPal^.PalNumEntries - 1) do begin
PBitmapInfo(pDibHeader)^.bmiColors[i].rgbRed :=
pPal^.palPalEntry[i].peRed;
PBitmapInfo(pDibHeader)^.bmiColors[i].rgbGreen :=
pPal^.palPalEntry[i].peGreen;
PBitmapInfo(pDibHeader)^.bmiColors[i].rgbBlue :=
pPal^.palPalEntry[i].peBlue;
end;
FreeMem(pPal, sizeof(TLOGPALETTE) +
(255 * sizeof(TPALETTEENTRY)));
end;

{Release the screen dc}
ReleaseDc(0, dc);
{Delete the bitmap}
DeleteObject(MemBitmap);

{Start print job}
Printer.BeginDoc;

{Scale print size}
if Printer.PageWidth < Printer.PageHeight then begin
ScaleX := Printer.PageWidth;
ScaleY := Form1.Height * (Printer.PageWidth / Form1.Width);
end else begin
ScaleX := Form1.Width * (Printer.PageHeight / Form1.Height);
ScaleY := Printer.PageHeight;
end;


{Just incase the printer drver is a palette device}
isDcPalDevice := false;
if GetDeviceCaps(Printer.Canvas.Handle, RASTERCAPS) and
RC_PALETTE = RC_PALETTE then begin
{Create palette from dib}
GetMem(pPal, sizeof(TLOGPALETTE) +
(255 * sizeof(TPALETTEENTRY)));
FillChar(pPal^, sizeof(TLOGPALETTE) +
(255 * sizeof(TPALETTEENTRY)), #0);
pPal^.palVersion := $300;
pPal^.palNumEntries := 256;
for i := 0 to (pPal^.PalNumEntries - 1) do begin
pPal^.palPalEntry[i].peRed :=
PBitmapInfo(pDibHeader)^.bmiColors[i].rgbRed;
pPal^.palPalEntry[i].peGreen :=
PBitmapInfo(pDibHeader)^.bmiColors[i].rgbGreen;
pPal^.palPalEntry[i].peBlue :=
PBitmapInfo(pDibHeader)^.bmiColors[i].rgbBlue;
end;
pal := CreatePalette(pPal^);
FreeMem(pPal, sizeof(TLOGPALETTE) +
(255 * sizeof(TPALETTEENTRY)));
oldPal := SelectPalette(Printer.Canvas.Handle, Pal, false);
isDcPalDevice := true
end;

{send the bits to the printer}
StretchDiBits(Printer.Canvas.Handle,
0, 0,
Round(scaleX), Round(scaleY),
0, 0,
Form1.Width, Form1.Height,
pBits,
PBitmapInfo(pDibHeader)^,
DIB_RGB_COLORS,
SRCCOPY);

{Just incase you printer drver is a palette device}
if isDcPalDevice = true then begin
SelectPalette(Printer.Canvas.Handle, oldPal, false);
DeleteObject(Pal);
end;


{Clean up allocated memory}
GlobalUnlock(hBits);
GlobalFree(hBits);
GlobalUnlock(hDibHeader);
GlobalFree(hDibHeader);


{End the print job}
Printer.EndDoc;


end;

[Brujah]

Jetzt hab ich in den Newsgroups nochmal was gefunden. Ist etwas kürzer ...
Läuft aber auch net so ohne weiteres in Kylix ...
(Vielleicht bekommt es ja hier einer zum laufen ...)

-------------------------------

The following code simulates a ALT-PRINT SCREEN key press, gets the
bitmap image from the Clipboard, then prints the bitmap.

VAR SnapShot: TBitmap;
begin
{ Simulte a Print-Screen Key with the keybd_event API function.
0 for a snapshot of the full screen or 1 for a snapshot of the
active window }
keybd_event(VK_SNAPSHOT, 1, 0, 0);
//SnapShot is put into the clipboard
SnapShot:= TBitmap.Create; //Creating the Bitmap of the SnapShot
{ Save the SnapShot into your BitMap }

SnapShot.LoadFromClipBoardFormat(cf_BitMap,ClipBoa rd.GetAsHandle(cf_Bitmap),
0);
Printer.BeginDoc;

DrawImage(Printer.Canvas,RECT({top},{left},{width} ,{height}),SnapShot);
Printer.EndDoc;
end;

With DrawImage defined as: ( code snagged from these newsgroups }

Procedure DrawImage(Canvas: TCanvas; DestRect: TRect; ABitmap: TBitmap);
Var
Header, Bits: Pointer;
HeaderSize: DWord;
BitsSize : DWord;
Begin
GetDIBSizes(ABitmap.Handle, HeaderSize, BitsSize);
Header := AllocMem(HeaderSize);
GetMem(Bits,BitsSize);
Try
GetDIB(ABitmap.Handle, ABitmap.Palette, Header^, Bits^);
StretchDIBits(Canvas.Handle, DestRect.Left, DestRect.Top,
DestRect.Right - DestRect.Left, DestRect.Bottom - DestRect.Top,
0, 0, ABitmap.Width, ABitmap.Height, Bits, TBitmapInfo(Header^),
DIB_RGB_COLORS, SRCCOPY);
Finally
MemFree(Header, HeaderSize);
MemFree(Bits, BitsSize);
End;
End;

[Mattburger]

Ausgaben auf den Drucker erfolgen ja eigentlich ganz simple via Canvas-Zugriffe.
Hier ist in den Borland-handbuechern auch ein Beispiel gegeben.
Die Frage ist nun, wie ein Bitmap der aktuellen Form erzeugt wird.

Hier dient die function GetFormImage welche von TCustomForm stammt.

Das Beispiel oben gibt bereits die vom Clipboard erzeugte Bitmap aus.

Beides zusammen duerfte zum Erfolg "das Formular auf den Printer ausgeben" fuehren.

[Brujah]

Probiere gerade daran herum. Eine function getformimage habe ich nicht gefunden...
Scheint mal wieder nur unter delphi zu funktionieren. Ich kenn mich da halt auch net aus.
Vielleicht kannst du ja mal dein Beispiel posten.