Größe eines Strings in Pixel

[Jhue89]

Guten Morgen Zusammen,

kennt einer eine einfache möglichkeit wie ich am schnellsten die Größe eines Strings in Pixel bekomme.
Ich muss die Breite eines Textes wissen, damit ich den mittig über eine Linie Positionieren kann.

 

[Jw456]

ein Label in etwa so wenn es mittig sein soll.

 text.setHorizontalAlignment(JLabel.CENTER);

 

[Jhue89]

hier ist der Code das macht es glaub ich einfacher.

package GLDrawer;

import java.awt.FontMetrics;
import java.awt.Graphics;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;

import javax.swing.JLabel;
import javax.swing.JTextField;

import com.jogamp.graph.curve.Region;
import com.jogamp.graph.curve.opengl.RegionRenderer;
import com.jogamp.graph.curve.opengl.RenderState;
import com.jogamp.graph.curve.opengl.TextRegionUtil;
import com.jogamp.graph.font.Font;
import com.jogamp.graph.font.FontFactory;
import com.jogamp.graph.geom.SVertex;
import com.jogamp.opengl.GL;
import com.jogamp.opengl.GL2;
import com.jogamp.opengl.GL2ES2;
import com.jogamp.opengl.fixedfunc.GLMatrixFunc;
import com.jogamp.opengl.util.PMVMatrix;
import GLObjects.LinesObj;
import GLObjects.LinienListe;
import StringProcessing.StringProcessing;
import settings.SettingsBD;

public class TextDrawer {
    private SettingsBD set;
    private StringProcessing StPro;

    public TextDrawer(SettingsBD set, StringProcessing StPro) {
        this.set = set;
        this.StPro = StPro;
        fontSize = set.getFontSize();
    }

    private List<maßAngabe> PosListe = new ArrayList<maßAngabe>();

    public static final int Horizontal = 1;
    public static final int Vertikal = 2;
    ///////

    // Text renderer variables
    private TextRegionUtil textRegionUtil;
    private RenderState renderState;
    private RegionRenderer regionRenderer;
    private Font font;
    private volatile float weight = 1.0f;
    private float fontSize;
    private int[] sampleCount = new int[] { 4 };
    private int renderModes = Region.VARWEIGHT_RENDERING_BIT;

    public void createPosList(List<LinesObj> LinieList) {
        PosListe = new ArrayList<maßAngabe>();
        for (int i = 0; i < LinieList.size(); i++) {
            LinesObj Line = LinieList.get(i);
            if (Line.getSchnittart().equals("Hilfslinie") && !Line.Deleted) {
                maßAngabe maßA = new maßAngabe();
                Double[] pos1 = Line.getPosBeginAbs();
                Double[] pos2 = Line.getPosEndeAbs();
                String[] pos1s = Line.getPosBeginRef();
//                String[] pos1s = {
//                        StPro.getLineObjByName(StPro.getFirstReverenzenName(Line.getPosBeginRef()[0]), LinieList)
//                                .getPosBeginRef()[0],
//                        StPro.getLineObjByName(StPro.getFirstReverenzenName(Line.getPosBeginRef()[1]), LinieList)
//                                .getPosBeginRef()[1],
//                        "0" };

                Integer orintation = Line.getAusrichtung();

                if ((orintation.equals(Horizontal) || (!pos1[0].equals(pos2[0]) && pos1[1].equals(pos2[1])))
                        && !(pos2[1] == 0)) {
                    maßA.posX1 = 0d;
                    maßA.posX2 = 0d;
                    maßA.posY1 = StPro.Process(StPro.getFirstReverenzen(pos1s[1]), LinieList);
                    maßA.posY2 = StPro.Process(pos1s[1], LinieList);

                    if (maßA.posY2 < maßA.posY1) {
                        Double zs1 = maßA.posY2;
                        Double zs2 = maßA.posY1;
                        maßA.posY1 = zs1;
                        maßA.posY2 = zs2;

                        maßA.posY1s = pos1s[1];
                        maßA.posY2s = StPro.removeFirstReverenzen(pos1s[1]);
                    } else {
                        maßA.posY1s = StPro.removeFirstReverenzen(pos1s[1]);
                        maßA.posY2s = pos1s[1];
                    }

                    maßA.posX1s = "0";
                    maßA.posX2s = "0";

                    maßA.maß = StPro.Process(StPro.removeFirstReverenzen(pos1s[1]), LinieList);
                    maßA.maßs = StPro.removeFirstReverenzen(pos1s[1]);

                    maßA.maßPositionX = 0d;
                    maßA.maßPositionY = (maßA.posY2 - Math.abs(maßA.maß / 2));

                    maßA.maßShort = StPro.getSMaßangabe(pos1s[1]);
                    maßA.orientierung = Horizontal;
//                    System.out.println("X1:"+maßA.posX1+" Y1:"+maßA.posY1+" X2:"+maßA.posX2+" Y2:"+maßA.posY2);

                    maßA.versatz = 1;
                    for (maßAngabe maßAngabe : PosListe) {
                        maßAngabe m = maßAngabe;
                        if (m.orientierung == Horizontal) {
                            if (
                            // p1a zwischen p2a und p2e
                            (maßA.posY1 >= m.posY1 && maßA.posY1 < m.posY2)
                                    // p1a < p2a und p1e > p2e
                                    || (maßA.posY1 < m.posY1 && maßA.posY2 > m.posY2)) {

                                maßA.versatz = m.versatz + 1;

                            } else if (((maßA.posY2 - maßA.posY1) < 50) && ((m.posY2 - m.posY1) < 50)
                                    && (maßA.posY1 == m.posY2 || maßA.posY2 == m.posY1)) {

                                maßA.versatz = m.versatz + 1;

                            }
                        }
                    }

                }

                if (orintation.equals(Vertikal)
                        || (pos1[0].equals(pos2[0]) && !pos1[1].equals(pos2[1])) && !(pos2[0] == 0)) {
                    maßA.posX1 = StPro.Process(StPro.getFirstReverenzen(pos1s[0]), LinieList);
                    maßA.posX2 = StPro.Process(pos1s[0], LinieList);
                    maßA.posY1 = 0d;
                    maßA.posY2 = 0d;

                    if (maßA.posX2 < maßA.posX1) {
                        Double zs1 = maßA.posX2;
                        Double zs2 = maßA.posX1;
                        maßA.posX1 = zs1;
                        maßA.posX2 = zs2;

                        maßA.posX1s = pos1s[1];
                        maßA.posX2s = StPro.removeFirstReverenzen(pos1s[0]);
                    } else {
                        maßA.posX1s = StPro.removeFirstReverenzen(pos1s[0]);
                        maßA.posX2s = pos1s[1];
                    }

//                    maßA.posX1s = StPro.removeFirstReverenzen(pos1s[0]);
//                    maßA.posX2s = pos1s[0];
                    maßA.posY1s = "0";
                    maßA.posY2s = "0";

                    maßA.maß = StPro.Process(StPro.removeFirstReverenzen(pos1s[0]), LinieList);
                    maßA.maßs = StPro.removeFirstReverenzen(pos1s[0]);

                    maßA.maßPositionX = (maßA.posX2 - Math.abs(maßA.maß / 2));
                    maßA.maßPositionY = 0d;

                    maßA.maßShort = StPro.getSMaßangabe(pos1s[0]);
                    maßA.orientierung = Vertikal;

                    maßA.versatz = 1;
                    for (maßAngabe maßAngabe : PosListe) {
                        maßAngabe m = maßAngabe;
                        if (m.orientierung == Vertikal) {
                            if (maßA.posX1 >= m.posX1 && maßA.posX1 < m.posX2
                                    || (maßA.posX1 < m.posX1 && maßA.posX2 > m.posX2)) {
                                maßA.versatz = m.versatz + 1;

                            } else if (((maßA.posX2 - maßA.posX1) < 50) && ((m.posX2 - m.posX1) < 50)
                                    && (maßA.posX1.equals(m.posX2) || maßA.posX2.equals(m.posX1))) {

                                maßA.versatz = m.versatz + 1;

                            }
                        }
                    }

                }
                PosListe.add(maßA);
            }
        }

    }

    public void createTurnedPosList(LinienListe LinieList) {
        createPosList(LinieList.getLineListN());

        String[] MaxLB = LinieList.getMaxLaengeBreite(LinieList.getLineListN());
        List<maßAngabe> PosListeQ = new ArrayList<maßAngabe>();

        // max x und y finden

        Double maxX = StPro.Process(MaxLB[1], LinieList.getLineListN());
//        Double maxY = StPro.Process(MaxLB[0], LinieList.getLineListN());

//        for (maßAngabe m : PosListe) {
//            if (m.posX2 > maxX)
//                maxX = m.posX2;
//            if (m.posY2 > maxY)
//                maxY = m.posY2;
//        }

        for (maßAngabe m : PosListe) {
            maßAngabe nm = new maßAngabe();

            nm.maßs = m.maßs;
            nm.maß = m.maß;
            nm.maßPositionX = m.maßPositionY;
            nm.maßShort = m.maßShort;
            nm.posX1 = m.posY1;
            nm.posX2 = m.posY2;
            if (m.orientierung == Horizontal) {
                nm.orientierung = Vertikal;
                nm.maßPositionY = 0d;
                nm.posY1 = 0d;
                nm.posY2 = 0d;
            } else {
                nm.orientierung = Horizontal;
                nm.maßPositionY = maxX - m.maßPositionX;
                nm.posY1 = maxX - m.posX1;
                nm.posY2 = maxX - m.posX2;
            }
            nm.posX1s = m.posY1s;
            nm.posX2s = m.posY2s;
            nm.posY1s = m.posX1s;
            nm.posY2s = m.posX2s;
            nm.versatz = m.versatz;

            PosListeQ.add(nm);
        }
        PosListe = PosListeQ;
    }

    public void TextDrawerInit(GL2ES2 gl, Integer height, Integer width) {

        try {
            InputStream in = getClass().getResourceAsStream("/res/Fonts/roboto/Roboto-Medium.ttf");
            font = FontFactory.get(in, true);

        } catch (IOException e) {
            e.printStackTrace();
        }

        renderState = RenderState.createRenderState(SVertex.factory());

        Float[] color = set.getTextColor();
        renderState.setColorStatic(color[0], color[1], color[2], color[3]);

        renderState.setHintMask(RenderState.BITHINT_BLENDING_ENABLED);

        regionRenderer = RegionRenderer.create(renderState, /* GLCallback */ RegionRenderer.defaultBlendEnable,
                /* GLCallback */ RegionRenderer.defaultBlendDisable);

        textRegionUtil = new TextRegionUtil(renderModes);
        regionRenderer.reshapePerspective(90.0f, width, height, 5, 10000);
        regionRenderer.init(gl, renderModes);
        regionRenderer.enable(gl, false);

    }

    public void drawBemßung(GL2ES2 gl, LinienListe lineList, double[] PosSystem) {
//        double[] Pos = JWindow.getRenderer().getPosition();
        Float[] color = set.getTextColor();
        regionRenderer.getRenderState().setColorStatic(color[0], color[1], color[2], color[3]);
//        Float aspect = (float) (JWindow.getRenderer().glCanvasWidth /    JWindow.getRenderer().glCanvasHeight);
//        regionRenderer.getRenderState().getMatrix().gluPerspective(90f, aspect, 5f, 10000f);
        Float FontDis = set.getFontDistance();

        // 0 off ausblenden, 1 Absolute Positions angaben, 2 Variablen angaben, 3
        // Absolute angaben
        if (set.getShowDimensions() == 1) {

            for (int i = 0; i < lineList.getLineList().size(); i++) {
                LinesObj linie = lineList.getLineList().get(i);
                if (linie.getSchnittart().equals("Hilfslinie") && !linie.getDeleted()) {
                    Double[] pos1 = linie.getPosBeginAbs();
                    Double[] pos2 = linie.getPosEndeAbs();

                    Float PosX1 = (float) (((PosSystem[0] + pos1[0]) * FontDis) / PosSystem[2]);
                    Float PosY1 = (float) (((PosSystem[1] + pos1[1]) * FontDis) / PosSystem[2]);
                    Float PosZ1 = FontDis;
                    renderText(gl, pos1[0] + " ; " + pos1[1], PosX1, PosY1, PosZ1, set.getTextScale(), 0f);

                    Float PosX2 = (float) (((PosSystem[0] + pos2[0]) * FontDis) / PosSystem[2]);
                    Float PosY2 = (float) (((PosSystem[1] + pos2[1]) * FontDis) / PosSystem[2]);
                    Float PosZ2 = FontDis;
                    renderText(gl, pos2[0] + " ; " + pos2[1], PosX2, PosY2, PosZ2, set.getTextScale(), 0f);
                }
            }
        }
        // 0 off ausblenden, 1 Absolute Positions angaben, 2 Variablen angaben, 3
        // Absolute angaben
        if (set.getShowDimensions() == 2) {
            for (int i = 0; i < PosListe.size(); i++) {
                maßAngabe Maß = PosListe.get(i);
                Float rotate = 0f;
                Float PosX = (float) (((PosSystem[0] + Maß.maßPositionX) * (FontDis)) / PosSystem[2]);
                Float PosY = (float) (((PosSystem[1] + Maß.maßPositionY) * (FontDis)) / PosSystem[2]);
                Float PosZ = FontDis;

                System.out.println( Maß.maßShort.toUpperCase());
                System.out.println("PosX: " + PosX);
                System.out.println("PosY: " +PosY);
                System.out.println("PosZ: " +PosZ);
                
                Float PosX1Begin = (float) (((PosSystem[0] + Maß.posX1) * (FontDis)) / PosSystem[2] - PosSystem[0]);
                Float PosY1Begin = (float) (((PosSystem[1] + Maß.posY1) * (FontDis)) / PosSystem[2] - PosSystem[1]);
                Float PosX2Begin = (float) (((PosSystem[0] + Maß.posX2) * (FontDis)) / PosSystem[2] - PosSystem[0]);
                Float PosY2Begin = (float) (((PosSystem[1] + Maß.posY2) * (FontDis)) / PosSystem[2] - PosSystem[1]);

                Float[] pos1B = { PosX1Begin, PosY1Begin, PosZ };
                Float[] pos2E = { PosX2Begin, PosY2Begin, PosZ };

                Integer versatz = Maß.versatz;

                dimLine(gl, pos1B, pos2E, Maß.orientierung, versatz, PosSystem);

                if (Maß.orientierung == Horizontal) {
                    PosX = PosX - 6 - 14f * (versatz - 1) * set.getTextScale();
                    rotate = 90f;
                }
                if (Maß.orientierung == Vertikal) {
                    PosY = PosY - (1 + 14f * set.getTextScale()) * versatz;
                }
                System.out.println("Masßsoc "+Maß.maßShort);
                System.out.println("PosMaß:"+PosX+","+PosY+","+PosZ);
                //Pos X  im zusammenhang moit der schriftgröße
                //Pos Y im Zusammenhang mit der schrftgröße und anzahl der zeichen um den text mittig auf der line zu bekommen
                float offset;
                //Offset um den Text mittig auf die linie zu bekommen
                
                
                offset= (Maß.maßShort.length()*set.getTextScale());
                
                
           [B]     // HIER MUSS ICH EINEN OFFSET ÜBERGEBEN [/B]
              [B]  renderText(gl, Maß.maßShort.toUpperCase(), PosX, (float) (PosY-(offset*3.2)), PosZ, set.getTextScale(), rotate);[/B]
            }
        }
        // 0 off ausblenden, 1 Absolute Positions angaben, 2 Variablen angaben, 3
        // Absolute angaben
        if (set.getShowDimensions() == 3) {
            for (int i = 0; i < PosListe.size(); i++) {
                maßAngabe Maß = PosListe.get(i);
                Float rotate = 0f;
                Float PosX = (float) (((PosSystem[0] + Maß.maßPositionX) * (FontDis)) / PosSystem[2]);
                Float PosY = (float) (((PosSystem[1] + Maß.maßPositionY) * (FontDis)) / PosSystem[2]);
                Float PosZ = FontDis;

                Float PosX1Begin = (float) (((PosSystem[0] + Maß.posX1) * (FontDis)) / PosSystem[2] - PosSystem[0]);
                Float PosY1Begin = (float) (((PosSystem[1] + Maß.posY1) * (FontDis)) / PosSystem[2] - PosSystem[1]);
                Float PosX2Begin = (float) (((PosSystem[0] + Maß.posX2) * (FontDis)) / PosSystem[2] - PosSystem[0]);
                Float PosY2Begin = (float) (((PosSystem[1] + Maß.posY2) * (FontDis)) / PosSystem[2] - PosSystem[1]);

                Float[] pos1B = { PosX1Begin, PosY1Begin, PosZ };
                Float[] pos2E = { PosX2Begin, PosY2Begin, PosZ };

                Integer versatz = Maß.versatz;

                dimLine(gl, pos1B, pos2E, Maß.orientierung, versatz, PosSystem);

                if (Maß.orientierung == Horizontal) {
                    PosX = PosX - 6 - 14f * (versatz - 1) * set.getTextScale();
                    rotate = 90f;
                }
                if (Maß.orientierung == Vertikal) {
                    PosY = PosY - (1 + 14f * set.getTextScale()) * versatz;
                }

//                System.out.println("PosMaß:"+PosX+","+PosY+","+PosZ);
                renderText(gl, Maß.maß.toString(), PosX, PosY, PosZ, set.getTextScale(), rotate);
            }
        }

    }

    public void renderText(GL2ES2 gl, String text, Float posX, Float posY, Float posZ, Float scale, Float rotate) {

        // the RegionRenderer PMVMatrix define where we want to render our shape

        PMVMatrix Pmv = regionRenderer.getMatrix();
        Pmv.glMatrixMode(GLMatrixFunc.GL_MODELVIEW);
        Pmv.glLoadIdentity();
        Pmv.glTranslatef(posX, posY, posZ);
        Pmv.glScalef(scale, scale, 1f);
        Pmv.glRotatef(rotate, 0f, 0f, 1);

        if (weight != regionRenderer.getRenderState().getWeight()) {
            regionRenderer.getRenderState().setWeight(weight);
        }

        // Draw the shape using RegionRenderer and TextRegionUtil
        regionRenderer.enable(gl, true);
        textRegionUtil.drawString3D(gl, regionRenderer, font, fontSize, text + " ", null, sampleCount);
        
        System.out.println("Fontsite : "+fontSize+" size: "+text +" : " );
        
        regionRenderer.enable(gl, false);
    }
// Damit wird die Line gezeichnet
    private void dimLine(GL2ES2 gl, Float[] Pos1, Float[] Pos2, Integer orientation, Integer versatz,
            double[] PosSystem) {
        GL2 gl2 = gl.getGL2();

//        double[] PosSystem = JWindow.getRenderer().getPosition();

        gl2.glColor3d(0d, 0d, 0d);
        gl2.glLineWidth(2f);

        if (versatz == null) {
            versatz = 1;
        }
        if (versatz == 0) {
            versatz = 1;
        }

        if (orientation == Vertikal) {

            gl2.glBegin(GL.GL_LINES);
            gl2.glVertex3f(Pos1[0], Pos1[1] - 2 - (1 + 14f * set.getTextScale()) * versatz,
                    (float) (-PosSystem[2] + Pos1[2]));
            gl2.glVertex3f(Pos2[0], Pos2[1] - 2 - (1 + 14f * set.getTextScale()) * versatz,
                    (float) (-PosSystem[2] + Pos2[2]));

            gl2.glVertex3f(Pos1[0] - 0.5f, Pos1[1] - 3 - (1 + 14f * set.getTextScale()) * versatz,
                    (float) (-PosSystem[2] + Pos1[2]));
            gl2.glVertex3f(Pos1[0] + 0.5f, Pos1[1] - 1 - (1 + 14f * set.getTextScale()) * versatz,
                    (float) (-PosSystem[2] + Pos2[2]));

            gl2.glVertex3f(Pos2[0] - 0.5f, Pos1[1] - 3 - (1 + 14f * set.getTextScale()) * versatz,
                    (float) (-PosSystem[2] + Pos1[2]));
            gl2.glVertex3f(Pos2[0] + 0.5f, Pos1[1] - 1 - (1 + 14f * set.getTextScale()) * versatz,
                    (float) (-PosSystem[2] + Pos2[2]));
            

//
//            gl2.glVertex3f(Pos1[0], Pos1[1] -3 - (1+ 14f * set.getTextScale() )* versatz,
//                    (float) (-PosSystem[2] + Pos1[2]));
//            gl2.glVertex3f(Pos1[0], Pos1[1] -1 - (1+ 14f * set.getTextScale() )* versatz,
//                    (float) (-PosSystem[2] + Pos2[2]));
//           
//            gl2.glVertex3f(Pos2[0], Pos1[1] -3 - (1+ 14f * set.getTextScale() )* versatz,
//                    (float) (-PosSystem[2] + Pos1[2]));
//            gl2.glVertex3f(Pos2[0], Pos1[1] -1 - (1+ 14f * set.getTextScale() )* versatz,
//                    (float) (-PosSystem[2] + Pos2[2]));

            gl2.glEnd();

            // maßpfeile
//            gl2.glBegin(GL.GL_TRIANGLES);
//            gl2.glVertex3f(Pos1[0], Pos1[1] - 2 - 14f * set.getTextScale() * versatz,
//                    (float) (-PosSystem[2] + Pos1[2]));
//            gl2.glVertex3f(Pos1[0] + 4, Pos1[1] - 2 - 14f * set.getTextScale() * versatz - 1,
//                    (float) (-PosSystem[2] + Pos1[2]));
//            gl2.glVertex3f(Pos1[0] + 4, Pos1[1] - 2 - 14f * set.getTextScale() * versatz + 1,
//                    (float) (-PosSystem[2] + Pos1[2]));
//
//            gl2.glVertex3f(Pos2[0], Pos2[1] - 2 - 14f * set.getTextScale() * versatz,
//                    (float) (-PosSystem[2] + Pos2[2]));
//            gl2.glVertex3f(Pos2[0] - 4, Pos2[1] - 2 - 14f * set.getTextScale() * versatz + 1,
//                    (float) (-PosSystem[2] + Pos2[2]));
//            gl2.glVertex3f(Pos2[0] - 4, Pos2[1] - 2 - 14f * set.getTextScale() * versatz - 1,
//                    (float) (-PosSystem[2] + Pos2[2]));
//            gl2.glEnd();

        }
        if (orientation == Horizontal) {
            gl2.glBegin(GL.GL_LINES);
            gl2.glVertex3f(Pos1[0] - 5 - (versatz - 1) * 14 * set.getTextScale(), Pos1[1],
                    (float) (-PosSystem[2] + Pos1[2]));
            gl2.glVertex3f(Pos2[0] - 5 - (versatz - 1) * 14 * set.getTextScale(), Pos2[1],
                    (float) (-PosSystem[2] + Pos2[2]));
//            gl2.glEnd();

            gl2.glVertex3f(Pos1[0] - 6 - (versatz - 1) * 14 * set.getTextScale(), Pos1[1] + 0.5f,
                    (float) (-PosSystem[2] + Pos1[2]));
            gl2.glVertex3f(Pos1[0] - 4 - (versatz - 1) * 14 * set.getTextScale(), Pos1[1] - 0.5f,
                    (float) (-PosSystem[2] + Pos2[2]));

            gl2.glVertex3f(Pos2[0] - 6 - (versatz - 1) * 14 * set.getTextScale(), Pos2[1] + 0.5f,
                    (float) (-PosSystem[2] + Pos1[2]));
            gl2.glVertex3f(Pos2[0] - 4 - (versatz - 1) * 14 * set.getTextScale(), Pos2[1] - 0.5f,
                    (float) (-PosSystem[2] + Pos2[2]));

//            gl2.glVertex3f(Pos1[0] - 6 - (versatz - 1) * 14 * set.getTextScale(), Pos1[1],
//                    (float) (-PosSystem[2] + Pos1[2]));
//            gl2.glVertex3f(Pos1[0] - 4 - (versatz - 1) * 14 * set.getTextScale(), Pos1[1],
//                    (float) (-PosSystem[2] + Pos2[2]));
//           
//            gl2.glVertex3f(Pos2[0] - 6 - (versatz - 1) * 14 * set.getTextScale(), Pos2[1],
//                    (float) (-PosSystem[2] + Pos1[2]));
//            gl2.glVertex3f(Pos2[0] - 4 - (versatz - 1) * 14 * set.getTextScale(), Pos2[1],
//                    (float) (-PosSystem[2] + Pos2[2]));
            gl2.glEnd();

            // maßpfeile
//            gl2.glBegin(GL.GL_TRIANGLES);
//            gl2.glVertex3f(Pos1[0] - 5 - (versatz - 1) * 14 * set.getTextScale(), Pos1[1],
//                    (float) (-PosSystem[2] + Pos1[2]));
//            gl2.glVertex3f(Pos1[0] - 4 - (versatz - 1) * 14 * set.getTextScale(), Pos1[1] + 4,
//                    (float) (-PosSystem[2] + Pos1[2]));
//            gl2.glVertex3f(Pos1[0] - 6 - (versatz - 1) * 14 * set.getTextScale(), Pos1[1] + 4,
//                    (float) (-PosSystem[2] + Pos1[2]));
//
//            gl2.glVertex3f(Pos2[0] - 5 - (versatz - 1) * 14 * set.getTextScale(), Pos2[1],
//                    (float) (-PosSystem[2] + Pos2[2]));
//            gl2.glVertex3f(Pos2[0] - 6 - (versatz - 1) * 14 * set.getTextScale(), Pos2[1] - 4,
//                    (float) (-PosSystem[2] + Pos2[2]));
//            gl2.glVertex3f(Pos2[0] - 4 - (versatz - 1) * 14 * set.getTextScale(), Pos2[1] - 4,
//                    (float) (-PosSystem[2] + Pos2[2]));
//            gl2.glEnd();
        }

    }
    
}

//http://forum.jogamp.org/Text-without-AWT-td4037684.html

 

[Jhue89]

Der Text wird an einen Drawer übergeben. Der Drawer benötigt an Koordinaten angabe, wo der Text positioniert werden soll.
Dazu benötige ich einen entsprechenden offset wenn ich einen Text irgendwo mittig positionieren will.

Oder seht ihr einen ander Möglichkeit?

 

[mihe7]

Für die Anzeige reicht es normalerweise, wenn Du Dir die FontMetrics holst und dessen stringWidth(String)-Methode verwendest.

 

[mihe7]

Zum Beispiel:

private void drawString(Graphics g, String text, int anchorX, int anchorY, int hAlignment) {
    int x = anchorX;
    int y = anchorY;
    int stringWidth = g.getFontMetrics().stringWidth(text);
    if (hAlignment == SwingConstants.RIGHT) {
        x -= stringWidth;
    } else if (hAlignment == SwingConstants.CENTER) {
        x -= stringWidth / 2;
    }
    g.drawString(text, x, y);
}

 

[Jhue89]

Ja das versuche ich grade. Funktioniert aber noch nicht ganz.

Mein gedanke war ein Textfeld zu erzeugen, die Font zuzuweisen und mir die info wegzuspeichern

JTextField test = new JTextField();
                test.setText(Maß.maßShort.toUpperCase());
                test.getFont();
                
                java.awt.Font f = null;
                        try {
                             f = java.awt.Font.createFont(java.awt.Font.PLAIN, getClass().getResourceAsStream("/res/Fonts/roboto/Roboto-Medium.ttf"));
                        } catch (FontFormatException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        } catch (IOException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                
                
                
                //font.getMetrics().
                test.setFont(f);
                System.out.println("Font:" + test.getFont().getFontName());
                float textlen =test.getFontMetrics(test.getFont()).stringWidth(Maß.maßShort.toUpperCase());
            
                offset= (textlen*set.getTextScale());
                System.out.println("Textlänge" + textlen);

 

[mihe7]

Ja das versuche ich grade. Funktioniert aber noch nicht ganz.

Was funktioniert nicht?

 

[Jhue89]

Das was ich grade versuche.

 

[Jw456]

wenn du dir die länge eines stings speichern willst müsstest du das ja für jeden string machen.
Wenn ein Wort zB 5 Buchstaben hatt , hatt es nicht immer genau die gleiche Pixel länge.

ein "i" und "m" zB haben nicht gleiche Pixel anzahl. Da immer den gleichen Offset zubenutzen wird nicht sinnvoll sein.

 

[Jhue89]

wenn du dir die länge eines stings speichern willst müsstest du das ja für jeden sting machen.
denn ein Wort zB 5 Buchstaben hatt , hatt es nicht immer genau die gleiche Pixel länge.

ein "i" und "m" zB haben nicht gleiche Pixel anzahl. Da immer den gleichen Offset zubenutzen wird nicht sinnvoll sein.

Deswegen will ich ja die länge des eingeben Strings wissen und nicht die Anzahl der Zeichen.

 

[mihe7]

Deswegen will ich ja die länge des eingeben Strings wissen und nicht die Anzahl der Zeichen.

Hast Du den Code aus #6 gesehen?

Mein gedanke war ein Textfeld zu erzeugen, die Font zuzuweisen und mir die info wegzuspeichern

Brauchst Du nicht.

Das was ich grade versuche.

Wer hätte das gedacht...

 

[Jhue89]

Wie muss ich die Methode befüllen?

 

[mihe7]

Erstens sehe ich keine Methode, zweitens weiß ich nicht, was Du da oben vorhast. Darum hatte ich vorhin auch gefragt, was nicht funktioniert.

Ich weiß nur, dass Du die Breite eines Strings in Pixel ermitteln willst, und das machst Du eben am einfachsten über die stringWidth()-Methode der Klase FontMetrics.

Wenn Du was spezielles brauchst, müsstest Du schon sagen, was genau. Dann könnte ich Dir ggf. auch schnell ein Beispiel runtertippen.

 

[Jhue89]

Also eigentlich verwende ich ja genau das was du in deinem Bespiel machst

int stringWidth = g.getFontMetrics().stringWidth(text);

nur das ich mir die FontMetrics aus einem JTextfeld hole. Da die Länge ja abhängig von der Schriftart und der Größe ist, lade ich mir das Fontdesign aus den Projektresourcen.

Weil das auch in dem Drawer verwendet wird.

float textlen =test.getFontMetrics(test.getFont()).stringWidth("123.0");

wenn ich diesen Code durchlaufen lasse

bekomme ich eine länge von 4 zurück. egal ob ich die Schriftgröße änder oder nicht.

wenn ich

float textlen =test.getFontMetrics(test.getFont()).stringWidth("....");

eingebe

bekomme ich ein länge von 0 zurück.

Das verstehe ich nicht so ganz.

Ich hatte das eigentlich so verstanden das getFontMetrics.StringWidth mir die Breite der Zeichenkette zurückgibt.

 

[mihe7]

nur das ich mir die FontMetrics aus einem JTextfeld hole.

"Nur" ist gut. Die FontMetrics brauchen einen FontRenderContext, um Text zu messen. So lange das JTextField nicht realisiert wurde, dürfte der nicht zur Verfügung stehen, da dieser ja vom Ausgabegerät abhängig ist.

Hast Du eine Komponente, in der Du die Textbreite messen musst?

 

[Jhue89]

Ich verwende com.jogamp.opengl.GL für diesen Teil.

Für die Bemassung in dem Screenshot benötige ich eine breite von dem Text, damit ich den Offset für die X-Y-Z Koordinaten angeben kann. ansonsten liegt der Text nicht mittig auf der Linie.

 

[mihe7]

Ach so... dann würde ich das mal ganz anders versuchen.

In Kommentar #3, Zeile 241 verwendest Du doch eine FontFactory, die eine Font (jogl-Font) liefert. Wenn Du da einfach mal

System.out.println(font.getMetricWidth("Ein Text", 30f));

aufrufst, kommt da evtl. was vernünftiges raus?

 

[Jhue89]

jep, da kommt was vernüftiges raus.

Jetzt funktioniert das auch.