Höhe von eines Strings in Pixeln (nicht Höhe einer Zeile)

[Mario]

Hallo, ich bin gerade dabei eine Klasse zu schreiben, die die Schriftgröße eines übergebenen Font-Objects soweit vergrößert/verkleinert, dass ein bestimmter String möglichst genau bestimmte Ausmaße (Dimension) annimmt.

Ist der String z.B. kleiner als die angegebene Dimension, soll er soweit vergrößert werden, bis er entweder zu hoch oder zu breit ist.
(Und dann die Schriftgröße natürlich wieder um eins verkleinern.) Aber da ist schon mein erstes, kleineres, Problem.
deriveFont akzeptiert int und float Werte. Welche Genauigkeit ist bei float sinnvoll? Sieht ein Text der Schriftgröße 10.1f anders aus als der Größe 10, oder wird z.B. der float-Wert auf einen int-Wert gerundet..?

Mein eigentliches Problem ist jedoch ein anderes. Die Breite des Strings herauszufinden scheint ganz gut zu klappen mit <FontMetrics>.stringWidth(<String>), die Höhe macht mir da sehr viel mehr Schwierigkeiten:
Mit

fm.getStringBounds(String, context).getHeight();

sowie

fm.stringHeight(String)

und allem was ich noch probiert habe (z.B. mit ascent und descent) bekomm ich für den String "E" das selbe Ergebnis wie für "e" oder ".".

Die Folge ist, viele Strings werden als zu hoch bewertet und die Schriftgröße verkleinert, obwohl über einem String wie "..." noch sehr viel Platz ist. Sogar bei Großbuchstaben ist oben noch Platz. (Den Fehler, dass die Schriftgröße nur aufgrund der Breite und nicht der Höhe verkleinert wurde hab ich nicht gemacht.)

(Bei einer Funktion, die die richtige Höhe liefert, muss ich dann auch noch wissen, wie weit unter dem obersten Pixel die baseline liegt.)

Gibt es eine Möglichkeit die Höhe von Chars bzw. eines Strings in Pixeln (im Gegensatz zu der Höhe einer Zeile) zu ermitteln?



Ich hoffe ich habmein Problem verständlich dargelegt, für alle Fälle hier nochmal der Code:

 private Component paintOn;
 private String Text;
 private Dimension Size;
 private Point Corner;
 private int xPadding;
 private int yPadding;
 private Dimension TextSize;
 private int X;
 private int Y;
 private Font useFont;
 private float accuracy;


 private void Berechnen()
 {
  FontMetrics fm;
  Rectangle2D StringBounds;
  Graphics context = paintOn.getGraphics();  

  
  //FontMetrics-Objekt der aktuellen Schrift(größe)
  fm = paintOn.getFontMetrics(useFont);
  StringBounds = fm.getStringBounds(Text, context);
  //Schriftgröße schätzen, je nachdem Höhe oder Breite
  useFont = useFont.deriveFont(useFont.getSize2D() * (float) Math.min(TextSize.width / StringBounds.getWidth(), TextSize.height / StringBounds.getHeight())); 
  //FontMetrics-Objekt aktualisieren
  fm = paintOn.getFontMetrics(useFont);
  StringBounds = fm.getStringBounds(Text, context);
  
  //vergrößern wenn zu klein, (Ergebnis größer/gleich)
  while (StringBounds.getWidth() < TextSize.width && StringBounds.getHeight() < TextSize.height)
  {
   //vergrößern
   useFont = useFont.deriveFont(useFont.getSize2D() + accuracy);
   
   //FontMetrics-Objekt aktualisieren
   fm = paintOn.getFontMetrics(useFont);
   StringBounds = fm.getStringBounds(Text, context);
  }
  
  //verkleinern wenn zu groß, (Ergebnis kleiner/gleich)
  while (StringBounds.getWidth() > TextSize.width || StringBounds.getHeight() > TextSize.height)
  {
   //verkleinern
   useFont = useFont.deriveFont(useFont.getSize2D() - accuracy);
   
   //FontMetrics-Objekt aktualisieren
   fm = paintOn.getFontMetrics(useFont);
   StringBounds = fm.getStringBounds(Text, context);
  }
  
  //zentrieren, Übergabepunkt für DrawString bestimmen
  X = Corner.x + (int) Math.floor((Size.width - StringBounds.getWidth()) / 2);
     //Y = Corner.y + (int) StringBounds.getHeight() + (int) Math.floor((Size.height - StringBounds.getHeight()) / 2);  
 }

 

[m@nu]

ich hatte das problem auch...
hier die lösung:

TextLayout textLayout = new TextLayout("Mein Text", meineFont, g2.getFontRenderContext());
Rectangle2D bounds = textLayout.getBounds();

über das Rectangle2D "bounds" hast zu zugriff auf die wirkliche pixel-grösse des strings

 

[Mario]

Danke, ich bekomme jetzt die Pixelgröße meines Strings, aber ich finde die baseline nicht.

Wo muss der Startpunkt von drawString hin?



p.s. Ich habe mein Graphics2D so bekommen:
Graphics2D g2d = (Graphics2D) <Component>.getGraphics();

doch frage ich mich warum das funktioniert, ist das Graphics-Objekt von Component eigentlich ein Graphics2D-Objekt?

 

[m@nu]

sobald du die werte vom TextLayout verwendest, sind die informationen über die baseline etc. "verloren" ... über die bounds hast quasi wirklich ein rechteck mit deinem text drin.
ich denke aber, wenn du nicht das TextLayout zeichnest, sondern das TextLayout nur zur höhenbestimmung verwendest, solltest du auch weiterhin die baseline von deinen FontMetrics entsprechend verwenden können.

per getGraphics() erhälst du ein "normales" Graphics.
dein vorgehen über das casten ist richtig Graphics2D leitet von Graphics ab. somit kann eine Graphic-Instanz in ein Graphics2D "gequetscht" werden

 

[Mario]

Der Punkt ist, dass ich das TextLayout benutze um zu schauen, wie groß die Schriftgröße sein muss, dass ein String (möglichst) genau in ein Rechteck passt, (z.B. ein JPanel, oder in meinem konkreten Fall, ein bestimmter Bereich in einem JPanel um den ich mit drawRect(a, b, c, d) einen Rahmen gezogen hab.)

So, jetzt nachdem ich weiß welche Schriftgröße mein Text haben muss, der genau in dieses Rechteck passt, muss ich ihn nur noch da rein zeichnen.. Da hilft mir doch dann FontMetrics nicht weiter, oder doch?
Oder kann man vielleicht das TextLayout wie ein Bild einzeichen (mit angabe des Punktes oben-links (a, b)<die gleichen a, b wie bei drawRect>)?


p.s. Ach ich dachte das mit dem Casten funktioniert nur so:
Graphics g = (Graphics) new Graphics2D(...);
Graphics2D g2 = (Graphics2D) g;

nicht aber Graphics2D g2 = (Graphics2D) new Graphics(...);

naja, praktisch..

 

[Mario]

Ich hab's mit der draw-Methode des TextLayout-Objects versucht, aber das funktioniert nicht, es wird nichts gezeichnet..

 

[Mario]

Oh, ich muss mich korrigiren, es zeichnet doch aber es verschwindet (fast) immer sofort wieder..

Außerdem braucht man hier ebenfalls die baseline..

Schriftzug.draw(this); //in paintComponent

//in meiner Klasse
 public void draw(Component paintOn)
 {
  Graphics2D g2d = (Graphics2D) paintOn.getGraphics();
  
  if (berechnet == false)
  {
   Berechnen(g2d);
  }
  
  textLayout.draw(g2d, Corner.x, Corner.y+(float)textLayout.getBounds().getHeight()); //hier bräuchte ich die baseline
 }

 

[m@nu]

versuch einmal, anstatt die referenz auf deine Component, die referenz auf die Graphics-instanz zu einer draw-methode weiterzugegben.

wieso brauchst du die baseline überhaupt? vertikales zentrieren? sonst irgendeine positionierung?
... benutz' doch ganz gewöhnlich die drawString-methode von der Graphics-klasse.

 

[Mario]

Ja, klar die Graphics-instanz. Danke.

Aber das Problem mit der baseline existiert immernoch.
Wofür ich sie brauch ist ganz einfach:

drawString(String, x, y) zeichnet den String so, dass die baseline des Strings auf y liegt..
"The baseline of the leftmost character is at position (x, y) in this graphics context's coordinate system."

 

[m@nu]

ja aber wo liegt dann das problem?? ggg
du willst deinen string vertikal zentriert zeichnen?
dies habe ich bis jetzt nur über das textlayout hinbekommen

(höhe von container / 2) - (höhe von textlayout / 2)

die baseline ändert von schrift zu schrift... aus diesem grund glaube ich nicht, es ist möglich, mit der baseline für die zentrierung zu arbeiten....

 

[Mario]

Hi Manu,
ich glaub am besten mach ich dir mein Problem mit einen kleinen Beispielprogramm klar.
Einfach ausführen, man sieht schön, wie der Rahmen zwar die richtige Größe hat, aber einfach an der falschen Stelle ist..
(Bzw. eigentlich ist der Text an der falschen Stelle und in meinen Programm passt sich die Schriftgröße dem Rahmen an, aber zur Darstellung meines Problems tut das nichts zur Sache..)

import javax.swing.*;
import java.awt.*;
import java.awt.font.TextLayout;

public class Test {

	public static void main(String[] args)
	{
	 //myFrame Frame = new myFrame();
	 JFrame f = new JFrame();
	 f.setLayout(null);
	 f.setDefaultCloseOperation(f.EXIT_ON_CLOSE);
	 f.setBounds(100,100,500,500);
	 f.setVisible(true);
	 
	 myJPanel p = new myJPanel();
	 f.add(p);
	 p.setVisible(true);
	 p.setBounds(0,0,500,500);
	}
}

class myJPanel extends JPanel
{
	myJPanel()
	{
	 super();
	}
	
	protected void paintComponent(Graphics g)
	{
		super.paintComponent(g);
		
		Font useFont = g.getFont();
		Point Corner = new Point(100,100);
		
		String Text = "Test mit g";
		Graphics2D g2d = (Graphics2D) g;
		TextLayout textLayout = new TextLayout(Text, useFont, g2d.getFontRenderContext());

		g.drawRect(Corner.x, Corner.y, (int) textLayout.getBounds().getWidth(), (int) textLayout.getBounds().getHeight());

		textLayout.draw(g2d, Corner.x, Corner.y);
//		genauso mit
		g.setFont(useFont);
		g.drawString(Text, Corner.x, Corner.y);		
	}
}

 

[daLenz]

hi,

ist dir schon aufgefallen, dass bei drawString respektiv bei textLayout.draw der ausgangspunkt (x,y) unten/links ist, während bei drawRect von oben/links ausgegangen wird?

wenn du noch die höhe des strings zu y hinzufügst, ist es im rechteck:

textLayout.draw(g2d, Corner.x, Corner.y + (int)textLayout.getBounds().getHeight());

das g geht so jedoch über den rand...

so jedoch ist es genau im rechteck (bzw. genau auf der linie des rechtecks...):

 textLayout.draw(g2d, Corner.x, Corner.y + textLayout.getAscent() - textLayout.getDescent());

greetz

 

[Mario]

Hallo daLenz, ich war ziemlich überrascht, dass deine Variante funktioniert, da ich sie schon ausgeschlossen hatte, dann ist mir wieder klar geworden, warum ich sie ausgeschlossen hatte:

Benutz mal Teststrings, wie "aaa" oder "ggg" oder gar "..." dann geht's wieder schief.
Man bräuchte sowas wie eine getRealAscent-Methode, die aber bei "A" und "a" einen unterschiedlichen Wert liefert..