Swing Design-Frage: eigenes Line-Wrapping

[KrokoDiehl]

Hallo zusammen.

Nun wird's knifflig, befürchte ich, denn die Forumsuche und Google sagen mir: Hier gibt es mehr Suchende als Antworten
Aber ich habe erst einmal Fragen genereller Natur, vor allem wie ich meine Herangehensweise gestalten sollte.

Der Hintergrund
In der Anwendung unserer Firma gibt es Textkomponenten die theo. beliebig viel Text behinalten können. Für diese Komponenten sollen aktuell folgende Anforderungen gelten:
- Der Text ist einfacher (plain) Text, also nichts mit Formatierung (fett, kursiv), Färbung und Grafiken (-> Problem 1)
- Der Text hat eine feste Zeilenlänge, d.h. es muss ein automatischer Umbruch erfolgen, wenn eine Zeile länger wird (-> Problem 2)
- Die Textkomponente wird (unabhängig von der möglichen Länge des Textes) immer auf voller Breite angezeigt (-> Anmerkung 1)

Bisher also genügt eine JTextArea, nur dieser eigenwillige Zeilenumbruch (Problem 2) macht mir etwas sorgen.

Anmerkung 1 Layouting
Für den autom. Zeilenumbruch können wir leider nicht die Breite der Textkomponente
heranziehen. Zum Einen würde es Probleme beim Vergrößern des Fensters geben, zum Anderen passt es auch auf der Standardgröße nicht ganz. Es sieht nicht so aus, dass das Textfeld doppelt so breit ist, wie die mögliche Zeilenlänge, aber es ist z.B. so, dass 91 Zeichen in eine Zeile passen, aber nur 85 erlaubt sind.
Beim Speichern des Textes nämlich wird der Text in diese MaxZeilenLänge-Blöcke unterteilt und beim Laden entsprechend mit Zeilenumbrüchen wieder zusammengesetzt. Was
ich vermeiden muss ist, dass man Texte anders (formatiert was Leerzeichen, Zeilenumbrüche etc. anbelangt) zurückbekommt, als man sie gespeichert hat.
Aber vielleicht hat hierzu jemand weitere Anmerkungen, wie man es optisch besser hinbekommt. Die Textkomponente sitzt übrigens in einer JScrollPane, die nur vertikal scrollt.

Anmerkung 2 Priorität
Von meinem Problemen die höchste Priorität hat das Umbrechen, da RTF / HTML erstmal Zukunftsmusik ist. Die Textkomponente
(aktuell JEditorPane auf text/plain-Modus) wird bereits korrekt gelayoutet.


Problem 1 Texttyp
Wie bereits erwähnt haben wir bisher nur einfachen Text. Es gibt aber bereits Anfragen, bzw. das Vorhaben, dies *bald* zu erweitern, sodass man den Text einfach formatieren kann (fett, kursiv, Schriftfarbe) womit wir wohl zu sowas wie RTF kommen. In 10 Jahren kommt wahrscheinlich der Wunsch, HTML darstellen zu können
Meiner Meinung nach wäre es daher überflüssig, mit der JTextArea zu starten, sondern gleich eine JEditorPane zu haben, damit man nachher nicht womöglich viel umstellen muss.

Problem 2 Zeilenumbruch
Der Text soll automatisch umgebrochen werden, wenn eine Zeile länger als x Zeichen wird (meist ist x = 85, hat was mit den Speichermethoden zutun auf die ich leider wenig Einfluss habe).
Ich denke dass ich anhand der Anforderungen ein eigenes LineWrapping (was mit WordWrapping sein soll, weiß ich selbst noch nicht...) implementieren muss. Ich habe schonmal herumgespielt:

public class MyTextDocument extends DefaultStyledDocument
{
    protected int    m_lineLength = 85;
    protected String m_lineBreak  = System.getProperty("line.separator");
		
    public MyTextDocument(int linelength)
    {
        super();
        m_lineLength = linelength;	
    } //Konstruktor(int)
		
    @Override
    public void insertString(int offset, String str, AttributeSet attrs) throws BadLocationException 
    {
        int rest = offset % m_lineLength;
        if (rest == 0 && offset != 0)
        {
            super.insertString(offset, m_lineBreak, attrs);
            offset += m_lineBreak.length();
        } //if

        super.insertString(offset, str, attrs);
    } //void insertString(int, String, AttributeSet)
		
} //class MyTextDocument

Das tut natürlich nur sehr grob das was man ich später erwartet, aber es ist ein Ansatz.

Anmerkung 3
Wie später dann Problem 1 und Problem 2 zusammenarbeiten sollen, ist mir etwas unklar. Durch zB HTML-Tag wird eine Zeile definitiv länger als der eigentliche Text wodurch eine Schere zwischen Darstellungszeilenlänge und Speicherzeilenlänge entsteht. Aber auch wenn beim Speichern alles in x-Zeichen-Blöcke zerhackt wird, dürfte es theo. kein Problem sein, wenn am Ende wieder ein gültiges HTML herauskommt. Was dann mit der Darstellungslänge von x Zeichen wird, steht noch offen, sprich womöglich wird sie aufgelöst.

Die Fragen
* Sollte ich direkt mit JEditorPane beginnen, in Hinblick auf die Zukunft, oder erst einmal die einfachere JTextArea? Und würde das eine oder andere mir beim eigensinnigen Umbrechen mehr helfen?

* Zum Implementieren des eigenen Wrappings ist der o.g. Ansatz über ein eigenes java.text.Document sinnvoll oder sollte man eher ein EditorKit implementieren?
(Mir fehlen hierzu Erfahrungen bzgl dieser Swing-Komponenten aber ich möchte auch von der Programmierung her sauber bleiden und meine daher, dass das Umbrechen
eine Sache des Models (Document) ist.)

* Hat jemand Anmerkungen zur generellen Vorgehensweise / Ideen / etc. Ich würde also mit einer JEditorPane und eigener Document-Klasse beginnen.
Hier schon das StyledDocument, damit man später eher Formatierungen anzeigen kann.

* Und, vielleicht am wichtigsten, kennt jmd Literatur/Links zu dem Thema?


So, ich schreibe immer sehr ausführlich und hoffe niemanden damit zu verwirren oder abzuschrecken. Ich freue mich jedenfalls auf Rückmeldungen

 

[madboy]

Ich habe zwar keine Lösung (vor allem wohl, weil ich nicht alles gelesen habe ;-) ) aber eine Empfehlung: fasse das möglichst kurz und prägnant zusammen, was du willst und was du hast. Vermutlich geht es den meisten Leuten hier wie mir und sie lesen sich nicht alles durch bzw. hören gleich auf zu lesen wenn sie sehen wie viel da steht.

 

[KrokoDiehl]

Ja ich habe sowas schon befürchtet, aber du hast natürlich Recht.

In Kürze
Ich muss ein mehrzeiliges Textfeld implementieren, dass eine maximale Zeilenlänge von x (meistens 85) Zeichen hat. In der Darstellung aber bietet das Textfeld meist mehr Platz (für ca. 91 Zeichen).
Ich möchte eine JEditorPane benutzen, da ich (irgendwann) mal RTF oder HTML benutzen möchte, also keine JTextArea.

Meine Fragen
- Soll ich für mein selfmade-Line-Wrapping eher das java.text.Document (vgl. Bsp im ersten Post) oder das EditorKit erweitern?
- Was ist sinnvoller, bzw. korrekter. Vom MVC-Prinzip her gehört die max. Zeilenlänge her imho zum Modell, sprich dem Dokument.
- Hat jmd Links/Literatur/Infos zu diesem Thema (außer der Java-API)?

Ich hoffe so ist's besser

 

[mvitz]

Ich persönlich würde die maximale Zeilenlänge tendenziell eher in die View packen.

Weil eigentlich ist das ja eine Eigenschaft der Anzeige, nach wievielen Zeichen ein "zwangs Zeilenumbruch" stattfindet.

 

[KrokoDiehl]

So ihr Leud!
Ich will euch über meine Ergebnisse informieren, ob ihr wollt oder nicht

1) Breite der Editor-Pane
Der häufigste Weg, bei einer JEditorPane einen Zeilenumbruch zu erreichen ist über die Breite der Pane. Das sagen die meisten Foren/Hilfen im Internet. Das haut bei mir leider nicht hin, weil das Feld aus Layout-Gründen eine gewisse Breite haben muss. Also keine Lösung für mich.

2) Document-Klasse
Da in meinem (leider speziellen) Fall die Modellierung eines Textes in Java-Pseudo-Code wie folgt ausschaut:

ArrayList< Character[85] >

, sprich eine beliebige, geordnete Menge von Strings die maximal 85 Zeichen lang sind, war meine Idee: Sauber programmiert ist dies eine Eigenschaft des Modells und nicht des Views. Daher versuchte ich die

insertString()

-Methode von DefaultStyledDocument zu überschreiben, bzw. um eine entsprechende Prüfung zu erweitern.
Das hat grob geklappt, um nicht zu sagen: Es klappte nicht, bzw. wurde zu aufwenig es für alle Fälle sauber zu implementieren (Einfügen großer Texte, Entfernen von Texten, ...). Leider habe ich auch nicht die Zeit mich in die javax.swing.text.Document-API einzuarbeiten, bzw. merkte, dass es mehr Zeit braucht.

3) EditorKit
Tja, hätte ich mal auf habi55 gehört Naja gut, ich bin eigentlich immernoch davon überzeugt, dass es ins Modell gehört. Die letztliche Lösung aber ist ein eigenes EditorKit. Große Hilfe leistete folgender Beispielcode.
Genaugenommen musste ich nur dafür sorgen, dass ein eigener LabelView benutzt wird:

    protected class MaxLineView extends LabelView 
    {
        public MaxLineView(Element elem)
        {
            super(elem);
        } //Konstruktor(Element)

        @Override
        public int getBreakWeight(int axis, float pos, float len) 
        {
            if (axis == View.X_AXIS) 
            {
                this.checkPainter();
                int p0 = this.getStartOffset();
                int p1 = this.getGlyphPainter().getBoundedPosition(this, p0, pos, len);
                if (p1 == p0)
                {
                    // Bereich ist viel zu schmal
                    return View.BadBreakWeight;
                } //if
                
                try 
                {
                    String text = this.getDocument().getText(p0, p1-p0);
                    // +1 für die Cursorposition
                    if (text.length() > ABSTextEditorKit.this.getMaxLineLength()+1)
                        return View.ForcedBreakWeight;
                } //try
                catch (BadLocationException BLexc)
                {}
            } // //if x-Achse
            return super.getBreakWeight(axis, pos, len);
        } //int getBreakWeight(int, float, float)

        @Override
        public View breakView(int axis, int p0, float pos, float len) 
        {
            if (axis == View.X_AXIS) 
            {
                checkPainter();
                int p1 = getGlyphPainter().getBoundedPosition(this, p0, pos, len);
                try 
                {
                    String text = this.getDocument().getText(p0, p1-p0);
                    int    max  = ABSTextEditorKit.this.getMaxLineLength();
                    if (text.length() > max+1)
                    {
                        GlyphView v = (GlyphView) createFragment(p0, p0 + max);
                        return v;
                    } //if
                } //try
                catch (BadLocationException BLexc) 
                {}
            } //if x-Achse
            return super.breakView(axis, p0, pos, len);
        } //View breakView(int, int, float, float) 
        
    } //class LineWrapLineView

Im Nachklang muss ich nun beim Speichern des Textes dafür sorgen, dass er in 85er-Blöcke zerlegt wird.


So das war's dazu. Vielleicht kann mein Wissen jemanden diesbzgl. auch weiterhelfen. Nun könnt ihr auch mit den richtigen und sauberen Lösungen rausrücken

 

[mvitz]

Also jetzt, wo ich nochmal so drüber nachdenke, bin ich mir mit der Antwort "View" in deinem speziellen Fall nicht mehr sicher.

Im Normalfall gehört Word/LineWrapping definitiv in die View, da das Model zwar auch semantische Umbrüche enthalten kann, die erzwungenen jedoch wirklich nur für die View von Bedeutung sind.