Eigenes Textfeld

[Degush]

Hey,

ich möchte ein Textfeld erstellen und dafür kein Swing nutzen, sondern es selbst programmieren.
Das Problem, das ich habe, ist folgendes:
Um die Dimensionen eines Strings zu berechnen, damit ich ihn passend aufbrechen kann und Zeilenumbrüche einfügen, brauche ich bereits ein Graphics2D Objekt. Und ich weiß nicht, wie ich eins erstellen soll, wenn nicht über BufferedImage.createGraphics();
Ich möchte nämlich ein BufferedImage erstellen mit Breite des Strings und Höhe des Strings. Aber damit ich überhaupt die Größe berechnen kann, die ich im Konstruktor angeben will!, muss ich es schon haben.

MfG,
Schmalte

 

[Gast2]

Um die Dimensionen eines Strings zu berechnen, damit ich ihn passend aufbrechen kann und Zeilenumbrüche einfügen, brauche ich bereits ein Graphics2D Objekt.

Es gibt noch die Klasse FontMetrics, mit der kannst du auch die Ausmaße eines Strings berechnen.

 

[Robokopp]

Also ich wusste nicht wirklich wie das funktionieren soll. Buttons gehen ja noch klar,aber wie realisiert man die texteingabe?

Gesendet von meinem GT-I9100 mit Tapatalk 2

 

[Gast2]

Hey,

ich möchte ein Textfeld erstellen und dafür kein Swing nutzen, sondern es selbst programmieren.

Das will ich sehen, wie machst du das genau

 

[Luk10]

Ich habe das für eins meiner Programme mal gemacht. Zum Rendern habe ich RenderStrategy und "rohe" Pixeldaten verwendet. TextFelder und ScrollPanels sind meiner Meinung nach relativ Anspruchsvoll, da man auf sehr viel achten muss.

Unten ist meine Methode(n) mit der ich Strings in eine Bitmap [rohe Pixelsdaten als int[] + width und height] konvertiere:
Width und Height bestimmen die Ausmaße der Bitmap. Die Größe des Fonts richtet sich nach Height.

Um den Text wird eine variable Box aus Sprites, sowie ein Hintergrund gerendert. Tastatur und Mauseingabe ist leider zu spezifisch um das jetzt hier so einfach zu posten.

Vielleicht hiflt dir das hier aber ein bisschen:

	public static Bitmap textToBitmap(int width, int height, String text, Font font, Color color) {
		if (text.equals("")) return new Bitmap(1, height);
		BufferedImage img = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);
		Graphics2D g2 = setMaximumRenderingHints((Graphics2D) img.getGraphics());
		if (font == null) font = GopGraphicIO.getInstance().getFont(0); // Einen Default Font holen
		if (color == null) color = Color.BLACK;

		g2.setFont(font.deriveFont((float) height));
		g2.setColor(color);
		g2.drawString(text, 0, height - g2.getFontMetrics().getDescent());
		int whitespaceWidth = g2.getFontMetrics().charWidth(' ');
		g2.dispose();

		int whitespace = 0;
		for (Character c : text.toCharArray()) {
			whitespace = c == ' ' ? whitespace + 1 : 0;
		}
                // Das hier ist das fertige BufferedImage. Es wird dann nurnoch zu einer Bitmap umgewandelt.
		img = cutTextSurplus(img, whitespace * whitespaceWidth);

		return new Bitmap(img, false);
	}

	private static BufferedImage cutTextSurplus(BufferedImage img, int whitespace) {
		for (int x = img.getWidth() - 1; x >= 0; x--) {
			boolean opaque = true;
			for (int y = 0; y < img.getHeight(); y++) {
				if (img.getRGB(x, y) >>> 24 != 0) {
					opaque = false;
					break;
				}
			}
			if (!opaque) {
				// TODO: Cuts 1 Pixel to much
				// Quickfix: width + 1
				img = img.getSubimage(0, 0, x + whitespace + 1, img.getHeight());
				break;
			}
		}
		return img;
	}

	public static Graphics2D setMaximumRenderingHints(Graphics2D g2) {
		g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
		g2.setRenderingHint(RenderingHints.KEY_FRACTIONALMETRICS, RenderingHints.VALUE_FRACTIONALMETRICS_ON);
		g2.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
		g2.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
		g2.setRenderingHint(RenderingHints.KEY_ALPHA_INTERPOLATION, RenderingHints.VALUE_ALPHA_INTERPOLATION_QUALITY);
		g2.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC);
		g2.setRenderingHint(RenderingHints.KEY_DITHERING, RenderingHints.VALUE_DITHER_ENABLE);
		g2.setRenderingHint(RenderingHints.KEY_COLOR_RENDERING, RenderingHints.VALUE_COLOR_RENDER_QUALITY);
		return g2;

	}

Luk10

 

[Gast2]

Und das soll was für einen Vorteil haben?

Ja gut verwendest anstatt Swing halt awt libs.

 

[Luk10]

Naja du hast halt mehr Möglichkeiten was das Aussehen deines TextFeldes angeht.

 

[Ebenius]

Naja du hast halt mehr Möglichkeiten was das Aussehen deines TextFeldes angeht.

Ich gehe mal nicht auf die eigentliche Frage ein: Das Aussehen und verhalten einer Swing-Komponente bestimmt immer deren UI. Das hat so ziemlich jede Freiheit. Dazu implementierst Du ein javax.swing.plaf.TextUI (from Scratch ist das kompliziert, aber oft reicht es, von javax.swing.plaf.basic.BasicTextFieldUI zu erben) und setzt es mit [c]JTextField.setUI(TextUI)[/c].

Textdarstellung ist wesentlich komplizierter als oft gedacht. Umschreib doch mal eben, was Du eigentlich erreichen möchtest. Vielleicht musst Du gar nicht so viel selbst machen wie Du denkst…

Ebenius

 

[Degush]

Die Methode von Luk gefällt mir eigentlich ganz gut.
Aber um mal konkreter zu werden: Ich habe eine eigene kleine 2D Grafik-Engine.
Mithilfe dieser Engine möchte ich eine ansprechende Benutzeroberfläche machen. Dadurch dass ich eine 2D-Engine für das GUI benutze, kann ich überall flüssige Animationen usw. einbauen.
Jetzt möchte ich ein undecorated Vollbild-JFrame programmieren, auf dem Bilder und Texte angezeigt werden, sowie eine Möglichkeit diese mit Daumen hoch oder Daumen runter zu bewerten.
Dafür brauche ich irgendeine Möglichkeit, diese Texte darzustellen.
Die Grafikengine nimmt BufferedImages, damit das Zeichnen grafikkartenbeschleunigt und schnell geht und anspruchsvollere Grafik als das Zeichen von Quadraten und Linien usw möglich ist.
Um diese Texte darzustellen, möchte ich deshalb ein kleines BufferedImage erstellen, auf dem dieser Text steht.

Dabei möchte ich allerdings, dass man von dem Textfeld nur eine Breite angibt, keine Höhe. Die Höhe des BufferedImages soll dann automatisch berechnet werden und bevor ein Wort die Pixelbreite sprengt, wird es in die nächste Zeile geschrieben.

In dieses Textfeld soll man nicht schreiben können. In gewisser Weise ist es ein mehrzeiliges JLabel. Aber selbst wenn man was schreiben können sollte: Meine Engine feuert ein Event, wenn eine Komponente angeklickt wird.

public CarbonixTextfield(int width, String text, Font font, Color color)
    {
        Graphics2D g2d = new BufferedImage(1,1,BufferedImage.TYPE_INT_ARGB).createGraphics();
        g2d.setFont(font);
        
        FontMetrics fm = g2d.getFontMetrics();
        String[] tokens = text.split(" ");
.........

        MengineImage img = new MengineImage(width, height);
        g2d = img.createGraphics();
        
        g2d.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,
                         RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
        g2d.setColor(color);
        g2d.setFont(font);
        
        for(int i = 0; i < lines.size(); i++)
        {
            System.out.println(lines.get(i));
            System.out.println(fm.getStringBounds(lines.get(i), g2d).getWidth()+"");
            g2d.drawString(lines.get(i), 0, (int)(i*30) );
        }

Dieser Ansatz von mir ist nicht besonders schön.

Wichtig ist also die Mehrzeiligkeit