Nimbus JButton: Zeilenumbruch korrigieren?

  • Themenstarter Themenstarter tuxedo
  • Beginndatum Beginndatum
T

tuxedo

Gast
Servus,

hab da ein kleines Problem:

Ich verwende das Nimbus LaF und möchte auf einen JButton etwas Text anzeigen.

Aktuell sieht das zum Teil so aus:

Java:
text="abcdefgh 12345";
myButton.setText("<html><center>" + text + "</center></html>"); // der Text soll auf dem Buttion zentriert dargestellt werden

Und im UI, welches im Fullscreen-Modus läuft, hat der Button dann eine Dimension von 107,82 Pixeln und sieht so aus wie im Anhang gezeigt.

Leider wird der Text auf dem Button vom benutzer eingestellt und kann durchaus, wie in diesem Beispiel, etwas ungeschickt gewählt sein, so dass Zeilenumbruch und allg. der Platz etwas zu klein ist.
Offensichtlich passt die Berechnung der Textausrichtung/Darstellung von Nimbus nicht ganz zu meinen Vorstellungen.... denn so sieht's irgendwie schlecht aus.

Ich würde das nun gerne Verbesserung und bin am schauen wie ich das am einfachsten erledige.

Meine erste Idee wäre gewesen, einen eigenen Button zu implementieren und dann selbst zu zeichnen und den Zeilenumbruch etwas geschickter zu gestalten. Den eigenen Button zu implementieren ist nicht das Problem.

Der Nachteil an der Sache ist aber: Das passt dann wohl eher weniger zum restlichen Nimbus Style. Oder ich müsste den Nimbus-Button so exakt wie möglich optisch "nachbauen". Aber vielleicht will ich morgen auf ein anderes LaF wechseln? Dann müsste ich wieder alles anpassen :-(

Wie würdet ihr das Problem lösen? Oder gibt's eine Möglichkeit dem aktuellen LaF da etwas unterzuschieben das die Textausrichtung übernimmt?

Stehe da gerade etwas auf dem Schlauch ...

Gruß
Alex


[EDIT]Hmm, okay. hab etwas experimentiert. Ich kann natürlich auch ein JLabel auf den JButton draufklatschen und da den Text reinhängen. Das würde immerhin mal bewirken dass der text nicht auf den Button-Rand geschrieben wird. Dafür wird jetzt der Text abgeschnitten.

Im endeffekt muss ich jetzt also nur noch rausfinden wie ich den Text auf dem JLabel nun so behandle, dass er für mich okay ist. Wie das nun genau aussieht: Gute Frage. Evtl. die Schriftgröße autom. reduzieren oder den Text mit vorzeitig "..." enden lassen wenn er droht über die Label-Begrenzung hinaus zu ragen. Mal schauen.

Oder gibt's für solche Fälle schon eine fertige Lösung von der ich nix weiß?[/EDIT]
 

Anhänge

  • NimbusButtonTextLineBreak.png
    NimbusButtonTextLineBreak.png
    2,8 KB · Aufrufe: 48
Zuletzt bearbeitet von einem Moderator:
Hmmpf,

bin jetzt fast am Ziel, aber Nimbus ärgert mich:

Ist vielleicht etwas "dirty", aber JTextArea kann alles was ich suche (Zeilenumbruch am entsprechenden Character, ...). Das kann man prima auf einen JButton klatschen, transparent machen und die Rahmen eliminieren. Ohne Nimbus sieht's dann wieder aus wie ein "normaler Button mit Text drauf". Nur hat Nimbus die doofe eigenart im transparenten Zustand doch wieder Rahmen zu zeichnen :-(

Muss ich wohl doch JLabel überschreiben und den Zeilenumbruch selbst machen ...
 
Kannst du vielleicht etwas mit
Code:
setBorder
oder
Code:
setMargin
bewirken um den Rand (der JTextArea) anzupassen?
 
Code:
setBorder
hab ich probiert. Aber sobald das Nimbus LaF JTextArea transparent gemacht wird, ist der Rahmen dennoch da. setMargin hab ich nciht probiert, aber ich geh mal stark davon aus dass das nix helfen wird da

a) der Platz nach außen hin beschränkt ist
b) der Platz nach innen hin gebraucht wird

Werde jetzt JLabel erweitern und mit FontMetrics und der zur Verfügung stehenden Breite den String rechtzeitig umbrechen. Wenn der String dermaßen lang ist dass er unten aus dem Button hinausragt, werde ich ihn mit "..." abkürzen. Das ganze verheirate ich dann mit einer eigenen JButton-Klasse und schwups hab ich einen eigenen Button dem man beliebig viel Text verpassen kann. Naja, "schwups" ist vielleicht etwas übertrieben. Wird schon etwas dauern bis das mit dem umrechen alles so funktioniert wie ich mir das vorstelle. Aber wenigstens bin ich dann LaF unabhängig und habe keine "dirty workarounds".

- Alex
 
Kleine Anmerkung noch: Bei mir wird kein Rahmen von der JTextArea angezeigt, wenn ich ihn mit setBorder auf null setze und die Hintergrundfarbe auf 0,0,0,0. Aber etwas problematischer sehe ich hier das weiterleiten der Events für den Button.
 
Mit einem "Nicht Nimbus LaF" klappt das bei mir auch. Aber sobald ich Nimbus verwende sehe ich wieder einen Rahmen. Soweit ich herausgefunden habe ist das ein bekannter "Bug", oder zumindest eine Einschränlung seitens Nimbus.

- Alex
 
Hab schon Nimbus verwendet (über VM Argument):

Java:
public class ButtonTest {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        ButtonTest buttonTest = new ButtonTest();
        
        buttonTest.createFrame();
    }
    
    private void createFrame() {
        final JFrame frame = new JFrame("ButtonTest");
        frame.setBounds(300,300,300,300);
        
        frame.setLayout(null);
        
        final JTextArea textArea = new JTextArea();
        
        
        textArea.setLineWrap(true);
        textArea.setEditable(false);
        final JButton userButton = new JButton();
        textArea.setText("abcdefgh 12345sfsdfsdfsdffjjhjhjkjkjjljkjkjkjkljklkkkkkkkkkkkkkkkkkkkkkkkkkkkkk");
        userButton.add(textArea);
        textArea.setOpaque(false);
        textArea.setBackground(new Color(0,0,0,0));
        textArea.setBorder(null);
        textArea.addMouseListener(new MouseAdapter() {
            public void mousePressed(MouseEvent e) {
                userButton.doClick();
            }
        });
        textArea.addMouseMotionListener(new MouseAdapter() {
            public void mouseEntered(MouseEvent e) {
                userButton.setFocusPainted(true);
            }
            
            public void mouseExited(MouseEvent e) {
                userButton.setFocusPainted(false);
            }
        });
        textArea.setFocusable(false);
        
        userButton.setLocation(100, 100);
        userButton.setSize(107, 82);
        
        userButton.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                System.out.println(textArea.getText());
            }
        });
        //userButton.setHorizontalAlignment(SwingConstants.CENTER);
        userButton.setMargin(new Insets(0,0,0,0));
        
        frame.add(userButton);
        
        frame.addWindowListener(new WindowAdapter() {
            public void windowClosing(WindowEvent e) {
                frame.dispose();
            }
        });
        
        frame.setVisible(true);
    }
}

Bitte nicht wegen abmurksen wegen dem Code, der ist nur auf die Schnelle entstanden und da sind noch Versuche drin, die Events weiter zu leiten... geht bestimmt auch eleganter.
 

Anhänge

  • ButtonTest.jpg
    ButtonTest.jpg
    17,2 KB · Aufrufe: 31
Welche Java Version?

Hab hier 1.7.0_01 64bit unter Debian Linux. Vielleicht verhält sich das nochmal anders als deins?

Aber wie du oben schon erkannt hast: Die Sache mit den Mouseevents wird mit dem JTextArea etwas hässlich. Habs aktuell noch nicht hinbekommen.

Denke die JLabel-Lösung ist nach wie vor die beste...
 
Hab hier 1.7.0_04 64bit Windows. Ja glaub auch, dass es sich von den Events her nicht lohnt auf JTextArea zu setzen, wollt mir nur auch mal ansehen auf welche Probleme man da so stößt. Wirklich gut fand ich bisher keine Lösung. Hatte es auch mal mit JLabel ausprobiert usw. Da muss man halt selbst was basteln.
 
So, ich hab jetzt mal ein einigermaßen brauchbares ergebnis fertig:

Java:
import java.awt.Color;
import java.awt.FontMetrics;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.util.ArrayList;
import javax.swing.JButton;
import javax.swing.JLabel;
import javax.swing.SwingConstants;

/**
 *
 * @author achr
 */
public class JLineBreakButton extends JButton implements MouseListener {

    class LineBreakLabel extends JLabel {

        private boolean charWrap;
        private boolean wordWrap;
        private final String CUT_TAIL = "...";

        public boolean isCharWrap() {
            return charWrap;
        }

        public void setCharWrap(boolean charWrap) {
            this.charWrap = charWrap;
        }

        public boolean isWordWrap() {
            return wordWrap;
        }

        public void setWordWrap(boolean wordWrap) {
            this.wordWrap = wordWrap;
        }

        @Override
        protected void paintComponent(Graphics g) {

            if (getText() == null || getText().length() == 0) {
                return;
            }

            Graphics2D g2d = (Graphics2D) g;
            g2d.setFont(getFont());

            g2d.setColor(getForeground());

            // see: [url=http://docs.oracle.com/javase/tutorial/2d/text/measuringtext.html]Measuring Text (The Java™ Tutorials > 2D Graphics > Working with Text APIs)[/url]
            FontMetrics fontMetrics = getFontMetrics(getFont());

            int width = getWidth();
            int higth = getHeight();

            int maxLines = higth / fontMetrics.getHeight();

            if (isCharWrap()) {

                // find out at which index to wrap to next line
                ArrayList<String> lines = new ArrayList<>();

                String completeText = getText();
                while (completeText.length() > 0) {
                    String line = completeText;
                    while (fontMetrics.stringWidth(line) > width) {
                        line = line.substring(0, line.length() - 1);
                    }
                    lines.add(line);
                    completeText = completeText.substring(line.length());
                }


                if (lines.size() >= maxLines) {
                    String remainingString = "";
                    while (lines.size() > maxLines - 1) {
                        remainingString = lines.remove(lines.size() - 1) + remainingString;
                    }
                    lines.add(cutString(remainingString, fontMetrics, width));
                }

                drawLines(fontMetrics, lines, g2d);


            } else if (isWordWrap()) {

                // wrap at each white-space char
                ArrayList<String> lines = new ArrayList<>();

                String[] lineArray = getText().split(" ");

                for (int i = 0; i < lineArray.length; i++) {
                    lines.add(cutString(lineArray[i], fontMetrics, width));
                }

                if (lines.size() >= maxLines) {
                    String remainingString = "";
                    while (lines.size() > maxLines - 1) {
                        remainingString = lines.remove(lines.size() - 1) + remainingString;
                    }
                    lines.add(cutString(remainingString, fontMetrics, width));
                }

                drawLines(fontMetrics, lines, g2d);

            } else {

                // do not wrap at all, just cut
                if (fontMetrics.stringWidth(getText()) > width) {
                    g2d.drawString(cutString(getText(), fontMetrics, width), 0, fontMetrics.getAscent());
                }

            }

        }

        private void drawLines(FontMetrics fontMetrics, ArrayList<String> lines, Graphics2D g2d) {

            int y = fontMetrics.getAscent();
            if (getVerticalAlignment() == SwingConstants.CENTER) {
                y = (getHeight() - (lines.size() * fontMetrics.getHeight())) / 2 + fontMetrics.getAscent();
            }

            for (String line : lines) {

                int x = 0;
                if (getHorizontalAlignment() == SwingConstants.CENTER) {
                    int lineWidth = fontMetrics.stringWidth(line);
                    x = (getWidth() - lineWidth) / 2;
                }

                g2d.drawString(line, x, y);
                y += fontMetrics.getHeight();
            }
        }

        private String cutString(String text, FontMetrics fontMetrics, int width) {
            // need to cut?
            boolean tooLong = fontMetrics.stringWidth(text) > width;
            if (tooLong) {
                // find max chars
                String cutString = text;
                while (tooLong) {
                    cutString = cutString.substring(0, cutString.length() - 1);
                    if (fontMetrics.stringWidth(cutString + CUT_TAIL) <= width) {
                        tooLong = false;
                    }
                }
                text = cutString + CUT_TAIL;
            }
            return text;
        }
    }
    
    
    // gap between button border and label border
    private int bordergap = 5;
    private LineBreakLabel label = new LineBreakLabel();

    public JLineBreakButton() {
        setLayout(null);
        label.setHorizontalAlignment(JLabel.CENTER);
        label.setVerticalAlignment(JLabel.CENTER);
        
//        label.setCharWrap(true);
        label.setWordWrap(true);

        add(label);

        setBackground(Color.GREEN);
        addMouseListener(this);
    }

    @Override
    public void setText(String text) {
        label.setText(text);
    }

    @Override
    public void doLayout() {
        super.doLayout();
        label.setBounds(bordergap, bordergap, getWidth() - (2 * bordergap), getHeight() - (2 * bordergap));
    }

    @Override
    public void mousePressed(MouseEvent e) {
        setBackground(getBackground().darker());
    }

    @Override
    public void mouseReleased(MouseEvent e) {
        setBackground(getBackground().brighter());
    }
    
    @Override
    public void mouseClicked(MouseEvent e) {
    }

    @Override
    public void mouseEntered(MouseEvent e) {
    }

    @Override
    public void mouseExited(MouseEvent e) {
    }

}

Es gibt drei Wrap-Modis:

Word-Wrap und Char-Wrap und No-Wrap.

Bei Word-Wrap wird bei _jedem_ Wort umgebrochen. Ist eine Zeile für sich zu lang, wird mit "..." abgekürzt".
Dieses Wrap-Verhalten mag nicht für jeden okay sein, für meine Anwendung ist das aber perfekt.

Bei Char-Wrap wird geschaut wieviele Zeichen in eine Zeile passen und dann passend umgebrochen. Ist selbst die letzte Zeile noch zu lang, wird diese mit "..." am Ende abgekürzt.

Bei No-Wrap wird gar nicht umgebrochen. Da wird lediglich die Zeile mit "..." abgekürzt, sollte sie zu lang sein.

Die Ausrichtung des Textes kann man Horizontal entweder CENTER oder LEFT, und Vertikal entweder TOP oder CENTER einstellen. RIGHT und BOTTOM ist (noch) nicht berücksichtigt.

Ist wie gesagt noch nicht perfekt und an allen Stellen 1a gelöst, aber für's erste funktioniert's und vielleicht kann's ja jemand gebrauchen ....
 

Neue Themen


Zurück
Oben