Je cherche à réaliser des impressions et leur aperçus en respectant la résolution de l'imprimante.
Pour l'instant, j'arrive à sauvegarder des fichiers images suivant une résolution donnée. J'envisage pour l'instant d'écrire une API C pour imprimer ses fichiers car je n'ai pas réussi à trouver la méthode en java pour pouvoir imprimer ses fichiers à la bonne résolution. Je me suis attaqué ensuite au problème de l'aperçu avant impression. J'ai un objet de rendu qui implémente une méthode draw(Graphics2D graphics, int width, int height) qui fait un rendu en fonction des dimensions du rectangle. Ainsi pour le preview, j'applique un scale sur le graphics que je transmet à cette méthode. Tout marche bien sauf pour l'affichage du texte qui n'est pas du tout à l'échelle.

La méthode la plus facile est d'introduire un paramètre fontScale qui permet de corriger la taille de police. Mais on se retrouve avec une taille de police modulo point (1/72 d'inches).

J'ai donc tenté d'émuler dans l'objet Graphics une résolution autre que du 72 DPI.

J'ai essayé de redéfinir un FontRenderContext avec une transformation personnalisée mais apparemment cette transformation est systématiquement ignorée par les API utilisant un FontRenderContext (comme les TextLayout par exemple).


Finalement, j'en suis arrivé à écrire une méthode :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
 
public static void drawText(Graphics2D g, Font font, FontRenderContext frc, String text, int x, int y){
            TextLayout textLayout = new TextLayout(text, g.getFont(), frc);
            Rectangle rect = textLayout.getBounds().getBounds();
 
           int offset = x;
 
           char [] car = new char[1];
           for (int i = 0; i < text.length(); i++){
               text.getChars(i, i+1, car, 0);
               GlyphVector vector = font.createGlyphVector(frc, car);
               int w = vector.getGlyphMetrics(0).getBounds2D().getBounds().width;
 
 
               Shape temp;
               int avance = 0;
               if (frc.isTransformed()){
                   temp = vector.getGlyphOutline(0);
                   AffineTransform tr = frc.getTransform();
                   PathIterator iter = temp.getPathIterator(tr);
                   Path2D.Double path = new Path2D.Double();
                   path.append(iter, false);
                   g.translate(offset, y);
                   g.fill(path);
                   g.translate(-offset, -y);
                   Point2D.Float pt = new Point2D.Float(vector.getGlyphMetrics(0).getAdvanceX(), 0.0f);
                   Point2D.Float res = new Point2D.Float();
                   tr.transform(pt, res);
                   avance = (int)res.x;
 
 
               }
               else {
                   temp = vector.getGlyphOutline(0, offset, y);
                   avance = (int)vector.getGlyphMetrics(0).getAdvanceX();
               }
               offset += avance;
               g.fill(temp);
           }
        }
Existe-t'il une méthode plus facile pour émuler l'affichage du texte dans une résolution autre qu'en 72 DPI (la seule résolution qui me semble possible sur les objets Graphics) ?
Existe-t'il une API pour réaliser des impressions et des aperçus à des résolutions conforme aux imprimantes actuelles (ex 1200 DPI, etc...)?