# Farbig schreiben



## Simon93 (27. Okt 2010)

Hey,
ich habe ein Programm und gebe Texte über System.out.println aus.
jetzt möchte ich mal die Farbe des Texts von schwarz auf rot ändern.
Wie mach ich das in bluej?
Oder geht das gar nicht, habe nichts gefunden, was in der Standartkonsole von java läuft.


----------



## AlexSpritze (27. Okt 2010)

Die Farbe des Textes, den du über println an die Konsole ausgibst, kannst du mit Java allein nicht ändern.


----------



## Runtime (27. Okt 2010)

```
System.err.println("Rot!");
```


----------



## Gast2 (27. Okt 2010)

Die "Standartkonsole von java" ist deine Windowskonsole.
Um dessen Schriftfarbe zu ändern brauchst du z.b. C++ mit JNI.


----------



## Simon93 (27. Okt 2010)

Dann steht es aber unter dem eigentlichen Text.
Mal was anderes nebenbei: ist es möglich, mein Konsolenfenster zu vergrößern, dass also mehr Text rein passt, weil das Ding ist im Moment überfordert.


----------



## ARadauer (27. Okt 2010)

du kannst die konsole mit java nicht verändern...

Mit Swing ein eigenes Fenster bauen und dort eine Textare einfügen ist die einzige sinnvolle lösung ;-)


----------



## Simon93 (27. Okt 2010)

Puh, das klingt nach viel Arbeit.
Aber ich denke mal, dass es auf Dauer nicht anders geht, weil ich habe so eine immens große Ausgabe, auf die man auch noch zurückscrollen können soll.
Schade hätt ja sein könn, dass es einen Befehl gibt, der sagt, wieviele Zeilen in das Fenster gehen...


----------



## Michael... (27. Okt 2010)

Sprichst Du vom Konsolenfenster in Windows?
Rechtsclick auf Titelleiste --> Eigenschaften --> Reiter "Layout" --> Fensterpuffergröße


----------



## henpara (28. Okt 2010)

ein fenster zu basteln, wo die konsolenausdrücke auch ausgegeben werden ist eig. super einfach.
hier ein beispiel: (bin selber noch recht neu in java, also bitte mit vorsicht genießen)

```
public class Repframe extends JFrame{
	JScrollPane jsp;
	TextArea text;
	Font f1;
	public Repframe(String titel){
		// INITIALISIERUNG
		text = new TextArea( "Hier wird das Log geschrieben." + System.getProperty("line.separator") );
		jsp = new JScrollPane(text);
		// POSITIONIERUNG 
		this.getContentPane().setLayout(null);
		this.setBounds(50, 50, 1000, 500);
		this.setResizable(false);
		this.setBackground(Color.lightGray);
		this.getContentPane().add(start);
	        this.getContentPane().add(jsp);
		jsp.setBounds(1, 35, 998, 380);
		// PARAMETER setzen
		f1 = new Font("Arial", Font.BOLD,  12);
		this.setTitle(titel);
		text.enableInputMethods(false); 
		//LISTENERS und EVENTS
	}
```
dann in der Klasse noch die Methode zum schreiben implementieren:

```
public  void writeToLogBox(String msg) {
		"DEIN_Repframe".text.append(msg);
	}
```

bei der Font kannst du dann entsprechend die Schriftart mit allem Klimbim so ändenr, daß dein text entsprechend ausgegeben wird. - musst die font natürlich noch der textarea zuordnen.


Hoffe das hilft dir schonmal n bischen

mfg


----------



## faetzminator (28. Okt 2010)

Man kann auch einfach Sysout / Syserr direkt im Programm oder auf der ausführenden Konsole [in eine Datei] umleiten...
Oder allenfalls unnötige[re] Informationen weglassen, um den Output zu verkleinern...


----------



## vladimir (28. Okt 2010)

Einen Ansatz gibt es noch! Du nimmst den System.out Stream und leitest dem auf deine TextArea oder TextPane um! Dort kannstdu die Ausgaben nach belieben formatieren. Suche mal in web da gibt es genug Beispiele. Ich gucke ob ich meine alten Sourcen finde!


----------



## Gast2 (28. Okt 2010)

EikeB hat gesagt.:


> Um dessen Schriftfarbe zu ändern brauchst du z.b. C++ mit JNI.


unter Windows ja - Windows hatte den ANSI Kram nur unter gewissen Vorraussetzungen direkt unterstützt (zusätzliche Treiber) ... ansonsten nur API-Aufrufe - was ja dann JNI wäre



AlexSpritze hat gesagt.:


> Die Farbe des Textes, den du über println an die Konsole ausgibst, kannst du mit Java allein nicht ändern.


doch - Colours ... ist zwar Bash - aber Konsole ist Konsole ... schließlich ist der Weg ja Standartisiert



Simon93 hat gesagt.:


> Aber ich denke mal, dass es auf Dauer nicht anders geht, weil ich habe so eine immens große Ausgabe, auf die man auch noch zurückscrollen können soll.


kommt darauf an was Du deinem Kunden anbieten willst ... wen er mit einer Konsole nicht zufrieden ist (ist kaum jemand) dann wirst Du um eine GUI basierte Lösung nicht herum kommen



> Schade hätt ja sein könn, dass es einen Befehl gibt, der sagt, wieviele Zeilen in das Fenster gehen...


müsste über den Befehle [c]mode[/c] unter Windows funktionieren

hand, mogel


----------



## vladimir (28. Okt 2010)

Hier der Kodeschnipsel, allerdings für SWT realisiert!

```
package essm.b2;

import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.custom.StyledText;

public class B2Console extends Composite {

	java.io.PrintStream consolenStream=null;
	java.io.PrintStream consolenErrorStream=null;
	java.io.PrintStream sysStreamer=null;
	java.io.PrintStream errStreamer=null;
	Display display = null;
	StyledText styledText = null;
    
	
	/**
	 * Main-Methode.<br>
	 */
	public static void main(String[] args) {
		Display display = Display.getDefault();
		Shell shell = new Shell(display);
		shell.setLayout(new FillLayout());
		shell.setSize(new Point(300, 200));
		B2Console thisClass = new B2Console(shell, SWT.NONE);
		shell.open();	
		
		
		thisClass.makeSysTestPrints(100);

		while (!shell.isDisposed()) {
			if (!display.readAndDispatch())
				display.sleep();
		}
		display.dispose();
	}
	
	public B2Console(Composite parent, int style) {		
		super(parent, style);
		display=parent.getDisplay();
		initialize();
		myInitialize();		
		
		System.out.println("Console gestartet!");

	}

	private void initialize() {		
		styledText = new StyledText(this, SWT.V_SCROLL | SWT.H_SCROLL);
		styledText.setEditable(false);
		this.setLayout(new FillLayout());
		setSize(new Point(300, 200));
		this.addDisposeListener(new org.eclipse.swt.events.DisposeListener() {
			public void widgetDisposed(org.eclipse.swt.events.DisposeEvent e) {
				System.setOut(sysStreamer);
				System.setErr(errStreamer);
			}
		});
	}
	
	private void myInitialize(){
        // neuer Stream der Alle println aufrufe nach foo.onEvent umleitet
		sysStreamer= new java.io.PrintStream(System.out);
        consolenStream = new java.io.PrintStream(System.out) {            
            @Override
			public void print(boolean b) {
            	onEvent(""+b);
			}
			@Override
			public void print(char c) {
				onEvent(""+c);
			}
			@Override
			public void print(double d) {
				onEvent(""+d);
			}
			@Override
			public void print(float f) {
				onEvent(""+f);
			}
			@Override
			public void print(int i) {
				onEvent(""+i);
			}
			@Override
			public void print(long l) {
				onEvent(""+l);
			}
			@Override
			public void print(Object obj) {
				onEvent(""+obj);
			}
			
			@Override
			public void println(boolean x) {
				onEventln(""+x);
			}
			@Override
			public void println(char x) {
				onEventln(""+x);
			}
			@Override
			public void println(double x) {
				onEventln(""+x);
			}
			@Override
			public void println(float x) {
				onEventln(""+x);
			}
			@Override
			public void println(int x) {
				onEventln(""+x);
			}
			@Override
			public void println(long x) {
				onEventln(""+x);
			}
			@Override
			public void println(Object x) {
				onEventln(""+x);
			}
			@Override
            public void print(String s) {
                onEvent(s);
            }            
            @Override
            public void println(String s) {
                onEventln(s);
            }
        };
        
        errStreamer= new java.io.PrintStream(System.err);
        consolenErrorStream = new java.io.PrintStream(System.err) {            
            @Override
			public void print(boolean b) {
            	onEventErr(""+b);
			}
			@Override
			public void print(char c) {
				onEventErr(""+c);
			}
			@Override
			public void print(double d) {
				onEventErr(""+d);
			}
			@Override
			public void print(float f) {
				onEventErr(""+f);
			}
			@Override
			public void print(int i) {
				onEventErr(""+i);
			}
			@Override
			public void print(long l) {
				onEventErr(""+l);
			}
			@Override
			public void print(Object obj) {
				onEventErr(""+obj);
			}
			
			@Override
			public void println(boolean x) {
				onEventlnErr(""+x);
			}
			@Override
			public void println(char x) {
				onEventlnErr(""+x);
			}
			@Override
			public void println(double x) {
				onEventlnErr(""+x);
			}
			@Override
			public void println(float x) {
				onEventlnErr(""+x);
			}
			@Override
			public void println(int x) {
				onEventlnErr(""+x);
			}
			@Override
			public void println(long x) {
				onEventlnErr(""+x);
			}
			@Override
			public void println(Object x) {
				onEventlnErr(""+x);
			}
			@Override
            public void print(String s) {
				onEventErr(s);
            }            
            @Override
            public void println(String s) {
            	onEventlnErr(s);
            }
        };

        System.setOut(consolenStream);
        System.setErr(consolenErrorStream);
	}

    public void makeSysTestPrints(int anzahl){
        for (int i = 0; i < anzahl; i++) {

           System.out.println(i+". "+Math.random());
            try {
                Thread.sleep(1);
            } catch (Exception e) {
            }

        }
    }
	
    /**
     * Fügt den String dem Textfeld hinzu
     *
     * @param str
     */
    void onEvent(String str) {    	
    	final String strM=str;
    	Thread tr = new Thread(new Runnable() {
        	public void run() {
    			display.syncExec(new Runnable() {
    		        public void run() {
    		        	styledText.append(strM);    		        	
    		        	}
    		    });
    		}
        },"printThread");
    	tr.start();
    }
               /**
     * Fügt den String dem Textfeld hinzu
     *
     * @param str
     */
    void onEventln(String str) {
    	final String strM=str;
    	Thread tr = new Thread(new Runnable() {
        	public void run() {
    			display.syncExec(new Runnable() {
    		        public void run() {
    		        	styledText.append(strM+"\n");
    		        }
    		    });
    		}
        },"printlnThread");
    	tr.start();
    } 
    
    /**
     * Fügt den String dem Textfeld hinzu
     *
     * @param str
     */
    void onEventErr(String str) {    	
    	final String strM=str;
    	Thread tr = new Thread(new Runnable() {
        	public void run() {
    			display.syncExec(new Runnable() {
    		        public void run() {
    		        	int indexFor=styledText.getText().length();
    		        	String st=strM;
    		        	styledText.append(strM);
    		        	int indexNach=st.length();
    		        	
    		        	org.eclipse.swt.custom.StyleRange styleRange 
    		        	= new org.eclipse.swt.custom.StyleRange();
    		        	styleRange.start = indexFor;
    		        	styleRange.length = indexNach;
    		        	styleRange.foreground = display.getSystemColor(SWT.COLOR_RED);
    		        	styledText.setStyleRange(styleRange);    		        	
    		        }
    		    });
    		}
        },"printThread");
    	tr.start();
    }
               /**
     * Fügt den String dem Textfeld hinzu
     *
     * @param str
     */
    void onEventlnErr(String str) {
    	final String strM=str;
    	Thread tr = new Thread(new Runnable() {
        	public void run() {
    			display.syncExec(new Runnable() {
    		        public void run() {    	
    		        	int indexFor=styledText.getText().length();
    		        	String st=strM+"\n";
    		        	styledText.append(strM+"\n");
    		        	int indexNach=st.length();
    		        	
    		        	org.eclipse.swt.custom.StyleRange styleRange 
    		        	= new org.eclipse.swt.custom.StyleRange();
    		        	styleRange.start = indexFor;
    		        	styleRange.length = indexNach;
    		        	styleRange.foreground = display.getSystemColor(SWT.COLOR_RED);
    		        	styledText.setStyleRange(styleRange);
    		        }
    		    });
    		}
        },"printlnThread");
    	tr.start();
    } 
}
```


----------



## Antoras (28. Okt 2010)

@vladimir

Die Methoden von PrintStream usw. zu überschreiben ist eine schlechte Idee, da sie unnötig ist:

```
PrintStream ps = new PrintStream(new BufferedOutputStream(new FileOutputStream(new File("output.txt"))), true);
System.setOut(ps);
```
Dies leitet den kompletten Code in eine Datei um. Kann man dann auch auf eine beliebige GUI-Komponente umleiten...


----------



## mariusbopp (28. Okt 2010)

ich glaube das ganze bringt ihm noch nicht so weiter, da ich annehme er hat erst mit java angefangen!


----------

