Seite 1 von 1

Ausgabe auf den Drucker

Verfasst: Mi, 16. Apr 2008 12:53
von Daniel
Hi

Ich schlage mich seit ein paar Tagen mit dem Drucken in XBase++ herum.
Eine bereits im Hybridmodus auf XBase++ umgestellte Applikation sollte jetzt auf einen USB-Drucker drucken. Bis jetzt ging es im CL*PPER-Stil zu:

Code: Alles auswählen

 Set Printer to LPT1
@prow()+1, col() SAY "Schöner Ausdruck!"
In einer Testapplikation habe ich es jetzt geschafft *uff*, drei Zeilen Text mit dem Sample "GraStringAT()" aus der XBase++-Hilfe in einem CRT-Fenster anzuzeigen. (Da gibt's auch Fonts und Attribute drin, die brauche ich aber nicht.)

Nun sollte man noch irgendwas mit dem Presentation Space abändern.
Das oPS ist hier erst mal NIL, deshalb wird es auf den CRT-Fenster ausgegeben.

Könnte mir mal jemand kurz erklären, wie man das nun auf den Drucker sendet?
Vielleicht noch kurz was zu PresSpace(), AppDesktop(), SetAppWindow() und so? Was man wie braucht?

Verfasst: Mi, 16. Apr 2008 13:08
von brandelh
Hi,

ich vermute mal du kennst dich mit Clipper aus. Zur Migration auch mit Drucker (mit meiner kostenlosen Druckerklasse HB_PrinterX) habe ich in der Wissenbasis gerade meinen Vortrag zur Migration auf der DEVCON 2007 zur Verfügung gestellt.

oPS ( ein Presentationspace() ) muss beim Drucken ein XbpPrinter Druckerobjekt zugewiesen werden (oPS:device := ...) . Beispiele dazu findest du in der online Hilfe unter XbpPrintDialog() (Druckerauswahl ...) oder XbpPrinter().

Meine Druckerklasse baut auf beidem auf, wobei ich eine Vorschau integriert habe und vieles einfacher geht (Ausrichtung, Unterstreichen, Schrift drehen etc.).

Verfasst: Mi, 16. Apr 2008 17:02
von Daniel
Hallo Hubert

danke, die Migrationsbeispiele und Deine HBPrinter-Klasse sind aber eine geballte Ladung!
Musste mich da erst mal etwas orientieren.
Die Migrationsbeispiele sind ja eher generell.

Für Deine HBPrinter-Klasse soll man wohl am Besten das Project erstellen und das Programm "Test.exe" als Beispiel nehmen, wie die Klasse HBPrinter eingebunden wird?

Im HBPrint.prg machst du zu Beginn ja ganz schön viele Anmerkungen! :shock: die sollte man schon alle ansehen, oder?

Also vielen Dank und Gruss
Daniel

Verfasst: Mi, 16. Apr 2008 17:37
von brandelh
Hallo Daniel,

wenn du nur einige GraStr... Befehle brauchst und Schriftart und Ausrichtung des Textes keine Rolle spielen, geht es mit den genannten Beispielen aus der Online-Hilfe am schnellsten. Mittlerweile (1.90) hat ja Alaska seine Druckerklasse und die Druckerauswahl erweitert und verbessert.

Der DEVCON Vortrag ist eher allgemein.

Meine Druckerklasse ist schon umfangreich, aber die Anmerkungen braucht man nicht wirklich zu lesen um einfache Sachen damit zu machen. Natürlich ist es interessant und die Syntax gibt es dort auch wie das alles gemacht wird. Aber zum Anfangen reicht es aus, die PRGs im Projektfile einzubinden und wie in TEST.PRG etc. einfach damit zu arbeiten. DER Vorteil meiner Klasse ist es, dass ich intern die links unten Ecke auf links oben umsetze und die physikalischen Druckerränder berücksichtige. Somit wird der Ausdruck auf jedem korrekten Windowsdrucker (fast) gleich aussehen und imme die Ränder einhalten.

Ausrichtung und Drehungen von Schriften erledige ich in einer Zeile ...
dadurch spare ich mir viel Arbeit im Vergleich zu den reinen GraFunktionen, die immer einen anderen Abstand zum Rand haben und links unten 0,0 kennen.
Auch der Ausdruck von Grafiken (BMP etc.) oder von mehrzeiligen Texten im Block- oder Flattersatz mit einer Zeile oP:PrintMemo(...) mit automatischem Umbruch etc. wo gibt es das sonst noch ;-)

Eventuell ist aber auch ein Reportgenerator besser für dich, das kann ich nicht beurteilen, ich drucke lieber mit meiner Druckerklasse :D

Verfasst: Mi, 16. Apr 2008 18:30
von Jan
Hubert,

nur so nebenbei (auch, weil wir da schon mal drüber gesprochen hatten): Drucken mit ObenLinks geht natürlich auch. Ich bau das bei mir so ein

Code: Alles auswählen

oPS:create(oPrinter, aSize, GRA_PU_LOMETRIC + GRA_PO_ORGTOPLEFT)
Aber, wie damals schon angemerkt: Noch undokumentiert. Aber halt auch einwandfrei.
Jan

Verfasst: Do, 17. Apr 2008 9:39
von brandelh
Hallo Jan,

sobald Alaska das freigibt, baue ich es sofort in meine Druckerklasse ein. Gerade unsauber programmierte Druckertreiber sorgen dafür, dass meine Druckerklasse die obere Zeile nicht immer sauber halten kann.
Zum Glück sind die recht selten geworden.

Aber ich nutzte das Oben Links erst wenn es offiziell freigegeben ist, dann aber in allen Programmen :D hoffentlich kommt das bald.

Verfasst: Mo, 21. Apr 2008 11:46
von Daniel
brandelh hat geschrieben:Wenn du nur einige GraStr... Befehle brauchst und Schriftart und Ausrichtung des Textes keine Rolle spielen, geht es mit den genannten Beispielen aus der Online-Hilfe am schnellsten. Mittlerweile (1.90) hat ja Alaska seine Druckerklasse und die Druckerauswahl erweitert und verbessert.
Das werde ich mal ausprobieren. Man sollte ja wissen, wie das grundsätzlich geht. ;)
Nicht so einfach, das erste Mal...
Aber zum Anfangen reicht es aus, die PRGs im Projektfile einzubinden und wie in TEST.PRG etc. einfach damit zu arbeiten. DER Vorteil meiner Klasse ist es, dass ich intern die links unten Ecke auf links oben umsetze und die physikalischen Druckerränder berücksichtige. Somit wird der Ausdruck auf jedem korrekten Windowsdrucker (fast) gleich aussehen und imme die Ränder einhalten.
Auch das müsste ich mal ausprobieren.
Ist natürlich gut, wenn die Seite oben beginnt. Was für ein Irrwitz von M$, das zu ändern :roll: Auch beim Bildschirm, auch im Formdesigner von Alaska! Brauche ich in einer Maske mehr Platz, so muss ich alles wieder hinaufschieben... :P

Vermutlich werde ich dann einen einfachen Reportgenerator einsetzen, denn es gibt ja dann noch weitere Herausforderungen wie Zahlen rechtsbündig in Spalten, Gruppenbrüche, ev. mehrzeilig, ...

Verfasst: Mo, 21. Apr 2008 12:54
von brandelh
Daniel hat geschrieben:Ist natürlich gut, wenn die Seite oben beginnt. Was für ein Irrwitz von M$, das zu ändern :roll: Auch beim Bildschirm, auch im Formdesigner von Alaska! Brauche ich in einer Maske mehr Platz, so muss ich alles wieder hinaufschieben... :P
Da kann M$ ausnahmsweise mal nichts dazu. Laut Alaska war das bei OS/2 die Standardeinstellung (wie in Mathe wenn man einen Graph zeichnen soll). Für ein Programmiersystem war es schon immer schlecht. Wir leben nun einmal von links oben nach rechts unten ;-)
Daniel hat geschrieben:Vermutlich werde ich dann einen einfachen Reportgenerator einsetzen, denn es gibt ja dann noch weitere Herausforderungen wie Zahlen rechtsbündig in Spalten, Gruppenbrüche, ev. mehrzeilig, ...
Text rechtsbündig (sollte rechts natürlich keine Blanks haben !):

Code: Alles auswählen

oHB:PrintText( nPosX, nPosY, alltrim(cTxt), "R" ) -> rechtsbündig
oHB:PrintText( nPosX, nPosY, transform(nWert,"999,999,999.99"), "R" ) -> Zahlen rechtsbündig
oHB:PrintText( nPosX+20, nPosY, "EUR" ) -> 2 mm daneben das EUR Zeichen
cMemo := field->MemoFeld // oder jeder längere Text
oHB:PrintMemo( nPosX, nPosY, alltrim(cMemo), cAusrichtung, ... )
Ausrichtung kann sein links, rechts, zentriert oder Blocksatz etc.
Die Bedienung eines Reportgenerators und das Zusammenspiel muss man auch erst mal lernen. Dazu gibt es hier seitenweise Abhandlungen was bzw. welcher besser ist. Wenn man einfache Listen oder Serienbriefe hat, sind diese schon einfach.

Ich z.B. habe mit meiner Druckerklasse für unsere Programme eine richtige Vorlagenklasse verwirklicht. Wenn ich nun eine Änderung an der richtigen Stelle mache, sind alle elektronischen Formulare automatisch angepaßt. Das war natürlich auch Arbeit ;-)

Verfasst: Di, 22. Apr 2008 9:54
von Daniel
Ok, gut, ich entschuldige mich bei M$ ;)
brandelh hat geschrieben:Wir leben nun einmal von links oben nach rechts unten ;-)
Arbeit ist aber erst das halbe Leben ;)

Danke, Hubert, für die konkreten Tipps und Bsp.!
Aber erst muss ich die verschiedenen Varianten und Möglichkeiten kennenlernen und ausprobieren.
brandelh hat geschrieben: Ich z.B. habe mit meiner Druckerklasse für unsere Programme eine richtige Vorlagenklasse verwirklicht. (...) Das war natürlich auch Arbeit ;-)
Klar, es lohnt sich auf jeden Fall, sich das Ganze gut zu überlegen und zu planen.

Unser Zürcher XUG-Kollege Hans-Peter hat da einen Reportgenerator ganz in XBase entwickelt, der auch die Uebergabe der Daten einfach macht.

Verfasst: Do, 24. Apr 2008 15:08
von Daniel
Trotzdem finde ich die Druckerei ganz schön kompliziert.
Technisch ist zwar alles bei Alaska einigermassen dokumentiert und es gibt auch Beispiele, aber einen wirklichen Einblick ins Prinzip des Vorgehens habe ich nirgends gefunden.

Wenn ich nun versuche, aus den Alaska-Samples und aus den Bsp der Hilfefunktion ein paar Versuche zu machen, so braucht das doch einen ziemlichen Aufwand, bis das läuft.

Also, verstehe ich das richtig? :
- Ich brauche ein Printerobjekt oPrinter (das ich auch in ein File umleiten kann)
- einen Präsentations-Space, auf dem die Inhalte dargestellt werden
- was zuerst, und was nachher?

Und wieso läuft es jetzt immer noch nicht richtig? ?( scheibe!

Verfasst: Do, 24. Apr 2008 15:41
von brandelh
Hi,

eigentlich ist drucken bei Windows das gleiche wie Schrift malen auf Fenstern. Bei Fenster leitet man ein Object von XbpDialog() ab, bei Drucker XbpPrinter(). Bei einem Fenster ist die Grafikkarte als Ausgabehardware festgelegt, beim Drucker kann man zwischen Standarddrucker und einem Namen für Druckertreiber auswählen.

Das gleiche Programm auf einem 1600x1200 Bildschirm wird wesentlich kleiner aussehen, als auf einem 800x600. Das ist auch so gewünscht. Bei einem Drucker muss aber der Ausdruck von der Größe her immer gleich aussehen, egal ob 1200x1200 oder 300x300 dpi.

Diese hardwareunabhänige Zwischenschicht ist der Presentationspace().
Gerade das Beispiel von XbpPrintDialog() ist doch recht einfach gehalten.
Wenn du mit dem Standarddrucker normal drucken willst, geht es noch einfacher:

Code: Alles auswählen

   #include "Gra.ch" 
   #include "Xbp.ch" 
   #pragma Library( "XppUI2.lib" ) 
 
   PROCEDURE Main 
      LOCAL oPrinter, oPS, aSize 
   
      oPrinter := XbpPrinter():New():create() // Standarddrucker
 
      IF oPrinter <> NIL   // Fehler bei der Erzeugung abfangen !
         // Neuen Presentation-Space erzeugen 
         oPS   := XbpPresSpace():new() 
 
         // Bedruckbarer Bereich auf dem Papier 
         aSize := oPrinter:paperSize() 
         aSize := { aSize[5] - aSize[3], ; 
                    aSize[6] - aSize[4]  } 
         oPS:create( oPrinter, aSize, GRA_PU_LOMETRIC ) 

         // Kleiner Druckjob 
         oPrinter:startDoc()  // oPrinter steuert die Ausgabe
         // was ausgegeben wird geht aber auf den oPS !
         GraStringAt( oPS, { 0, aSize[2]-50 }, "Hello World" )  
         ... hier können weitere GRA Funktionen aufgerufen werden.
         oPrinter:endDoc() 
 
         // Aufräumen 
         oPrinter:destroy() 
         oPS:destroy() 
      ENDIF 

   RETURN 
Etwas komplizierter macht es die Schriftauswahl, leider ist sich Windows nicht immer mit Xbase++ bzw. dem Programmierer einig, welche Schrift zu verwenden ist. Aber bei den Standard Größen und Schriften geht es meist ok.

Meine Druckerklasse ist eine Mischung zwischen XbpPrinter() und XbpPresSpace(). Dort wird immer über das Objekt, das mit HB_PrinterX erstellt wurde und ausschließlich mit Methoden gearbeitet.

Verfasst: Do, 24. Apr 2008 16:49
von Rolf Ramacher
Hi Daniel,


ich hoffe es verwirrt dich jetzt nicht zu sehr. Ich zeige dir mal einen Ausschnitt aus meinem Code.

Hier drucke ich Texte + Barcode auf klebeetiketten.

Code: Alles auswählen

   oDlg := XbpPrintDialog():new() 

   // Druckausgabe nicht standardmäßig in Datei umleiten 
   oDlg:enablePrintToFile := .f. 
   oDlg:printToFile       := .f. 
   oDlg:create() 

   // Konfiguriertes Drucker Objekt erzeugen 
   oPrinter := oDlg:display() 
   oDlg:destroy() 

   IF oPrinter <> NIL 
		oPrinter:setOrientation(XBPPRN_ORIENT_LANDSCAPE)
      // Neuen Presentation-Space erzeugen 
      oPS   := XbpPresSpace():new() 
      // Bedruckbarer Bereich auf dem Papier 
      aSize := oPrinter:paperSize() 
      aSize := { aSize[5] - aSize[3],aSize[6] - aSize[4]  } 
      oPS:create( oPrinter, aSize, GRA_PU_LOMETRIC ) 

      oPrinter:startDoc()
		// Abfrage Startposition bei empty von Anfang an.
		If empty(cDruckPos) 
			aPos:={160,1830}
			aZPos:={130,1940}
			aNrPos:={120,1875}
*			nZaehler:=1940
			nSeitenZaehler:=0
			nCounter:=1
		Else
			aZPos:={130,1940}
			// Seitenzaehler bis 48 wird um 1 verringert, weil der Seitenzähler erst nach
			// dem druck erhöht wird.
			nSeitenZaehler:=val(cDruckPos)-1
			For x = 1 to  Len(aCounter)
				If val(cDruckPos)>= aCounter[x]
					nNum:=aCounter[x]
				Else				
					nZaehler:=x
					exit
				EndIf
			Next x
			nCounter:=val(cDruckPos)-nNum
			// nZaehler für die Zeilen um 1 weniger, da er beim zähler drucken soll und nicht
			// noch eine Erhöhung von aZPos hat.
			For j = 1 to nZaehler-1
				aZPos[02]-=250				
			Next j
			For j = 1+1 to nCounter
				aZPos[01]+=453
			Next j
			aNrPos:=AClone(aZPos)
			aNrPos[01]-=10
			aNrPos[02]-=65
			aPos:=AClone(aZPos)
			aPos[01]+=30
			aPos[02]-=90
		EndIf
		For i = 1 to Len(aSaetze)	
			If nSeitenZaehler==48
				oPrinter:NewPage()
				nSeitenZaehler:=0
				nCounter:=1
				aPos:={160,1830}
*				nZaehler:=1940
				aZPos:={130,1940}
				aNrPos:={120,1875}
			EndIf
			nSichPos:=aZPos[02]

			oFont := XbpFont():new():create( "18.Courier New" )
			GraSetFont( oPs, oFont )

			aZPos[01]-=10
			      GraStringAt( oPS, aZPos , aSaetze[i][1] ) 
					aZPos[02]-=25
					aZPos[01]+=10

	      GraStringAt( oPS, aZPos , aSaetze[i][2] ) 
			aPos[02]:=aZPos[02]-85

			oFont := XbpFont():new():create( "26.Arial" )
			oFont:bold:=.t.
			oFont:configure()
			GraSetFont( oPs, oFont )
	      GraStringAt( oPS, aNrPos , aSaetze[i][11] ) 

			If aSaetze[i][12]="000"
			Else
				aNrPos[02]-=25
				oFont := XbpFont():new():create( "18.Arial" )
				GraSetFont( oPs, oFont )
		      GraStringAt( oPS, aNrPos , aSaetze[i][12] ) 
				aNrPos[02]+=25
			EndIf
			
			// Barcode-Berechnung
			oFont := XbpFont():new():create( "40.Arial" )
			GraSetFont( oPs, oFont )

			uEan13_Nr:=aSaetze[i][3]+aSaetze[i][4]+aSaetze[i][10]
			uEan13_Nr+=GraBarcodeEAN13_CalcCheckDigit(uEan13_Nr)
     		// Startblock  start sentinel - linker Anfang
	      cBarCodeBlock := "101"
	      // 1. Stelle EAN13 wird nicht verschl

Verfasst: Fr, 25. Apr 2008 17:40
von Daniel
Hi Hubert

danke für die Erklärung und Vereinfachung.
Ja, das wird mir jetzt so langsam klar, und es fängt auch an zu laufen. ;-) :wink:
Ich hab mir aus den verschiedenen Bsp da so eine kleine Testklasse gemacht.

Fragen sind noch:
Was macht GRA_PU_LOMETRIC ? Hab ich noch nicht gefunden.
Wie ist der Schriftfont, der hier gedruckt wird? Bei mir kommt die Schrift extrem winzig.
Ich kann mir noch nicht recht vorstellen, wie man jetzt ein paar Zeilen druckt, ohne immer die Positionen ausrechnen zu müssen.

Und wie würde sowas jetzt mit deiner HBPrinter-Klasse aussehen?
Wäre das möglich, auch so ein ähnliches Bsp zu machen?

Verfasst: Fr, 25. Apr 2008 17:42
von Daniel
Hi Rolf

danke für dein ausführliches und differenziertes Muster!

Ich werde das auch noch genauer anschauen.
Jetzt will ich erst mal ein paar Dinge ausprobieren.

Verfasst: Fr, 25. Apr 2008 18:15
von Jan
Hallo Daniel,

zuerst Deine Frage: GRA_PU_LOMETRIC stellt auf metrische Maße, sprich mm ein. Daß musst Du machen, damit das auf jedem Drucker, egal welche Auflösung, immer gleich aussieht.

Grundsätzlich: Zuerst erschlägt einen die ganze Druckgeschichte. Es ist einfach verwirrend. Aber: Das ist nur deswegen so, weil Du so viel machen kannst. Es ist nicht verwirrend sondern vielfältig. Du kannst Schriften und Schirftgrößen mischen, das ganze links- und rechtsbündig oder Zentriert drucken, Linien zeichnen wie blöde, Schriften drehen, alles farbig machen, Bilder einfügen, mit den Zeilenabständen spielen, etc. usw.

Was ich z. B stark finde ist, daß man z. B. die nicht bedruckbaren Ränder auslesen kann. Ich kann also meine Formulare so erstellen, daß sie immer den Druckbereich ausfüllen. Egal welcher Drucker das ist und was der an druckbarem Bereich hat. Ich arbeite sonst beruflich leider mit einem anderen System. Und hab ständig Ärger damit, daß das bei einem neuen Druckerkauf schon wieder Probleme gibt. Nicht so bei Xbase++ (wenn Du es denn in Deinem Programm entsprechend umsetzt).

Genau wie die Möglichkeit, die tatsächlichen Schrifthöhen zu nutzen. Egal wie der Drucker das gerade umsetzt - Du kannst über die Schrifthöhe z. B. den dazu passenden Zeilenabstand nutzen. Keine Überschneidungen der Zeilen mehr, keine unnatürlichen Auseinanderzerrungen mehr. Nur weil die Schirft auf dem Drucker nun einmal etwas anders wirkt. Oder Due die Schriftgröße um 1 Punkt vergrößert hast, weil Du das einfach schick fandest.

Die Schirftgröße kannst Du auf mehrere Arten einstellen. Z. B. so:

Code: Alles auswählen

   oFont:FamilyName := "Times New Roman"
   oFont:nominalPointSize := 12
Jan

Verfasst: Sa, 26. Apr 2008 9:26
von brandelh
Hi,

ok gehen wir davon aus, dass du meine Druckerklasse direkt nutzen willst (also nicht ableiten und ::Print() und ::PrintForm() Methoden schreiben):

Code: Alles auswählen

#include "Gra.ch"
#include "Xbp.ch"
#include "Common.ch"
#include "Appevent.ch"
#include "Font.ch"

*---------------- Fonts nur einmal erzeugen ------
procedure main
local oHBPrinter, nPosY, cTxt

oHBPrinter := HBPrinter():New():create()   // Standarddrucker

if oHBPrinter:IsPrinterError()     // Fehler verhindern, avoid errors
   ? "Drucker ist nicht verf

Verfasst: Sa, 26. Apr 2008 9:28
von brandelh
Jan hat geschrieben:Hallo Daniel,
zuerst Deine Frage: GRA_PU_LOMETRIC stellt auf metrische Maße, sprich mm ein.
Hallo Daniel,

es sind 1/10 mm, d.h. du must 10 schreiben, wenn du 1 mm willst.
Diese Auflösung ist recht brauchbar, man könnte auch GRA_PU_LOMETRIC nehmen, aber das erhöht die Datenmenge die an den Drucker geht (vermute ich mal) und ist unübersichtlicher, da dann die Zahlen größer sind.
Ich weiß im Moment gar nicht ob 1/100 oder 1/1000 mm ...

Verfasst: Sa, 26. Apr 2008 10:28
von Jan
Hubert,

Recht hast Du. Das hätte ich deutlicher hervorheben sollen. ich wollte nur ausdrücken, daß GRA_PU_LOMETRIC in mm rechnet.

Gültige Ausdrücke sind übrigens lt. Onlinehilfe (was auch Deine andere Frage beantwortet):

Code: Alles auswählen

  GRA_PU_ARBITRARY  Beliebige Einheit. Das Koordinatensystem    
                    wird auf den Viewport skaliert.             
  GRA_PU_PIXEL *)   Eine Einheit ist ein Pixel                  
  GRA_PU_LOMETRIC   Eine Einheit ist 0.1 Millimeter             
  GRA_PU_HIMETRIC   Eine Einheit ist 0.01 Millimeter            
  GRA_PU_LOENGLISH  Eine Einheit ist 0.01 Inch                  
  GRA_PU_HIENGLISH  Eine Einheit ist 0.001 Inch                 
  GRA_PU_TWIPS      Eine Einheit ist 1/1440 Inch 
 *) Standardwert
Jan

Verfasst: Fr, 09. Mai 2008 15:54
von Daniel
Hi

danke für eure Erläuterungen und Bsp.
Also, wenn wir jetzt das obige Standard-Beispiel von XbpPrintDialog() nehmen, so drucken wir die erste Zeile in der oberen linken Ecke mit:

Code: Alles auswählen

  GraStringAt( ::oPS, { 0, ::aPaperSize[2]-65 }, "Hello World" )
Hier wird eine recht grosse Schrift erzeugt. Weshalb und wie?
Bei aPaperSize[2]-50 wird bei mir die Schrift oben abgeschnitten, desh. "-65".

Wie schreibe ich jetzt die nächste Zeile in 12.Arial?
Muss ich da erst ausrechnen, wieviele Zehntelsmillimeter weiter unten die nächste Zeile folgt, und wie hoch sie in diesem Font sein wird?

Mache ich folgendes:

Code: Alles auswählen

   oFont := XbpFont():new():create( "12.Arial.normal" )

   GraStringAt( ::oPS, { 0, ::aPaperSize[2]-65 }, "Hello World" )
   GraSetFont(  ::oPS, oFont )
   GraStringAt( ::oPS,   , "Hello World" )   
dann druckt er mir wieder gross, dann gleich daneben (logisch, bei leerer Position) winzig klein, also keineswegs mit 12.Arial, eher mit 3pt!

Sorry, dass ich so dumme Fragen stelle, aber als Programmentwickler mit über ein Dutzend Jahren kommt man sich da blöd vor :? :(

P.S. Nachher mache ich dann weiter mit Deiner HB-Printerklasse.
Deine Musterprogramme habe ich ausprobiert.

Verfasst: Fr, 09. Mai 2008 16:04
von Jan
Daniel,

Du kannst das machen, wie Du das gepostet hast. Aber das hat den Nachteil, daß Du dann sprachgebunden bist. Und außerdem kann das garnicht funktioneiren, ich bin mir sicher, Du hast kein "12.Arial.normal" auf dem Rechner. Eher ein "12.Arial". Und wo es etwas nicht gibt, macht Xbase etwas, was Du so vermutlich nicht wolltest.

Außerdem mußt Du schauen, in welcher Ausrichtung Du druckst. Das stellst Du z. B. zentriert über

Code: Alles auswählen

aAttrString[GRA_AS_HORIZALIGN] := GRA_HALIGN_CENTER
GraSetAttrString(oPs, aAttrString)
ein. Natürlich musst Du vorher aAttrString gefüllt haben, das geht mit

Code: Alles auswählen

aAttrString := Array(GRA_AS_COUNT) 
Außerdem: Die Zeilenhöhe. ich mache das so, daß ich zu dem gerade aktiven Font die zeilenhöhe auslese. Das geht so:

Code: Alles auswählen

nFontHeight := oPS:setFont():height 
Und dann kannst Du z. B. eine Variable nY nehmen, die die Entfernung von Oben angibt, und mit

Code: Alles auswählen

nY += nFontHeight 
hochrechnen.

Achso: Das in Deinem Beispiel mit 2 Schriftgrößen gedruckt wird ist klar. Denn Dein

Code: Alles auswählen

GraSetFont(  ::oPS, oFont )
Kommt zwischen zwei zeilen. Die 1. wird also ohne den neu eingestellten Font gedruckt, die zweite aber mit.

Jan

Verfasst: Fr, 09. Mai 2008 16:17
von Rolf Ramacher
Hi Daniel,

hier ein Auszug von mir beim setzen der Schriftart.

Code: Alles auswählen

	oFont := XbpFont():new():create( "26.Arial" )
			oFont:bold:=.t.
			oFont:configure()
			GraSetFont( oPs, oFont )
mit oFont:bold:=.t. druckst du FETT

Verfasst: Fr, 09. Mai 2008 16:55
von brandelh
Hi,

auch ich kann nur davon abraten den FETT Druck bei Create einzuschalten.

Ich meine aber dass bei deiner Angabe

"12.Arial.normal"

der eine Punkt zuviel ist (zumindest laut den englischen Beispielen in der Hilfe):

"12.Arial normal"

In meiner Druckerklasse kann man für BOLD und ITALIC bei :AddFont() statt dem String (z.b "12.Arial") ein Array angeben. Aus diesem Array bildet die Funktion FontWahl(cFontName,nFontHoehe,lBold,lItalic) den richtigen Font und speichert diesen im HB_Printer-Object. Natürlich könnte man diese Funktion auch herausschneiden ;-)

PS: unter OS/2 funktionierte damals ausschließlich diese Funktion, da die Stringangabe ziemlich lange falsche Größen lieferte.
Wenn irgendetwas (jede Kleinigkeit !) nicht stimmt, wird irgendein Font zurückgegeben, angeblich der am besten passende ...

Drucken auf USB-Drucker.

Verfasst: Do, 15. Mai 2008 20:27
von Juergen
Hallo Daniel, am schnellsten geht das mit DOS-Print.

Siehe:
http://www.xbaseforum.de/viewtopic.php? ... d3ad210cbf

Gruß Jürgen

Verfasst: Sa, 07. Jun 2008 12:11
von Ewald
Hallo Daniel,
ich bin seinerzeit nur wegen dem Drucken von Clipper auf Xbase++ umgestiegen. Da ich damals richtige Meter machen mußte, habe ich nach der einfachsten Möglichkeit gesucht und bin auf Express++ gestoßen. Da ich nicht sehen kann, ob du dich damit schon mal beschäftigt hast, stelle ich dein Clipper-Druck-Beispiel hier mal in Express++ dar.

Code: Alles auswählen

dcprint on to oprinter
@ dc_printrow()+1,10 dcprint say "Schöner Text"
dcprint off
Das Beispiel ruft das Windows-Druckermenu auf, und man kann sich einen Windowsdrucker auswählen.
Der Code läßt sich um Fonts, Formatierungen, Grafiken etc. ergänzen.

Express++ finde ich schlicht und einfach genial ...
Gruß
Ewald