Initial commit

Uebung35Drucken.iml

+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>
+

src/de/itstall/Drucken.java

+package de.itstall;
+
+import java.awt.*;
+import java.awt.print.PageFormat;
+import java.awt.print.Printable;
+import java.awt.print.PrinterException;
+import java.awt.print.PrinterJob;
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+
+public class Drucken {
+	public String[] DruckText;
+
+	public Drucken(String fileName) {
+		PrinterJob job = PrinterJob.getPrinterJob();
+
+		this.readFile(fileName);
+
+		job.setPrintable(new DruckInhalt());
+
+		if(job.printDialog()) {
+			try {
+				job.print();
+			} catch (PrinterException e) {
+				e.printStackTrace();
+			}
+		}
+	}
+
+	public void readFile(String fileName) {
+		try {
+			FileReader f0 = new FileReader(fileName);
+			BufferedReader f = new BufferedReader(f0);
+
+			String line;
+			int index = 0;
+
+			while ((line = f.readLine()) != null) {
+				this.DruckText[index] = line;
+			}
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
+
+	private static class DruckInhalt implements Printable {
+
+		// Array welches die Positionen der Seitenumbrüche beinhaltet
+		private int[] pageBreaks;
+
+		/**
+		 * Diese Methode füllt ein String-Array mit 200 Einträgen.
+		 *
+		 * @return String-Array mit 200 Einträgen
+		 */
+		private String[] getText() {
+			String[] result = new String[200];
+
+			for (int i = 0; i < result.length; i++) {
+				result[i] = "Diese Zeile trägt die Zeilennummer: " + (i+1);
+			}
+
+			return result;
+		}
+
+		@Override
+		public int print(Graphics g, PageFormat pf, int page) throws PrinterException {
+			// Zu druckenden Text laden
+			String[] text = getText();
+
+			// Bestimmen des entsprechenden Platzbedarfs (Anzahl Zeilen pro Seite und Anzahl Seiten)
+			Font font = new Font("Serif", Font.PLAIN, 12);
+			FontMetrics metrics = g.getFontMetrics(font);
+			int zeilenhoehe = metrics.getHeight();
+
+			// Seitenumbrüche berechnen
+			if (pageBreaks == null) {
+				// Volle Zeilen pro Seite herausfinden
+				int anzahlZeilenProSeite = (int)pf.getImageableHeight() / zeilenhoehe;
+
+				/*
+				 * Beispiel: 200 Zeilen sind zu Drucken. 50 Zeilen passen auf eine Seite => 3
+				 * Seitenumbrüche werden benötigt Dies bedeutet, dass wir 4 Seiten drucken
+				 * werden.
+				 */
+
+				int anzahlSeitenumbrueche = (super.DruckText.length - 1) / anzahlZeilenProSeite;
+
+				// Seitenumbruch-Array initialisieren
+				pageBreaks = new int[anzahlSeitenumbrueche];
+
+				// Seitenumbrüche festlegen (Vor welchem Zeilenindex bzw. nach welcher Zeile
+				// muss ein Umbruch eingefügt werden
+				for (int i = 0; i < anzahlSeitenumbrueche; i++) {
+					pageBreaks[i] = anzahlZeilenProSeite * (i + 1);
+				}
+			}
+
+			/*
+			 * Die Anzahl der Seiten stimmt mit der Anzahl der Einträge im Array pageBreaks fast überein
+			 * Die genaue Anzahl der Seiten ist eins mehr als das PageBreaks-Array Einträge hat.
+			 * ABER: Die Länge des pageBreaks-Arrays ist gleich dem Index der letzten druckbaren Seite!
+			 * Beispiel: 4 seiten sind zu Drucken. Das pageBreaksArray beinhaltet also 3 Seitenumbrüche.
+			 * 			 Der Index der Seite 4 ist 3 und somit gleich der Länge des pageBreaks-Arrays.
+			 */
+			int maxSeitenIndex = pageBreaks.length;
+
+			if (page > maxSeitenIndex) {
+				return Printable.NO_SUCH_PAGE;
+			}
+
+			/*
+			 * Die Drucker können meist nicht an der Position (0,0) drucken, Daher muss eine
+			 * Umsetzung auf den Druckbereich stattfinden. Den Druckbereich können wir aus
+			 * dem PageFormat auslesen mit getImageableX() und getImageableY(), das bewirkt,
+			 * dass der 0,0-Punkt in den durch den ausgewählten Drucker druckbaren Bereich
+			 * verschoben wird.
+			 */
+			Graphics2D g2d = (Graphics2D) g;
+			g2d.translate(pf.getImageableX(), pf.getImageableY());
+
+			// Start- und Endzeile finden für die aktuell zu druckende Seite
+			int start = (page == 0) ? 0 : (pageBreaks[page - 1]);	// Ergebnis ist der Index im text-Array
+			int ende = (page == pageBreaks.length) ? (text.length) : pageBreaks[page]; // Ergebnis ist die zu druckende Zeile (Index wäre um eins niedriger!)
+
+			// Setzen jeder einzelnen Zeile
+			int y = 0;
+
+			// In einer Schleife die auszugebenden Texte durchgehen
+			for (int zeile = start ; zeile < ende; zeile++) {
+				/*
+				 * Da bei allen Grafikelementen die linke obere Ecke als Bezugspunkt genommen wird,
+				 * ist es offensichtlich nachvollziehbar, dass es bei den Texten die linke UNTERE Ecke ist :)
+				 *
+				 * Aus diesem Grund muss zunächst VOR der Ausgabe der Zeile die neue Position des
+				 * Textes berechnet werden:
+				 */
+				y += zeilenhoehe;
+
+				// Setzen des Textes auf das Graphics-Objekt
+				g2d.setFont(font);
+				g2d.drawString(text[zeile], 0, y);
+			}
+
+			// Beispiel einer Fußzeile. Die 340 ist nicht berechnet, sondern ausprobiert
+			g2d.drawString("Seite " + (page + 1) + " von " + (maxSeitenIndex + 1), 340, (int) pf.getImageableHeight());
+
+
+			/*
+			 * Als Rückgabe wird nun die Information zurückgegeben, dass hier eine Seite
+			 * existiert, die gerade geschrieben wird.
+			 */
+			return Printable.PAGE_EXISTS;
+		}
+	}
+}

src/de/itstall/Main.java

+package de.itstall;
+
+public class Main {
+
+    public static void main(String[] args) {
+        new Drucken("DruckText.txt");
+    }
+}