Back to index

wims  3.65+svn20090927
FontInfo.java
Go to the documentation of this file.
00001 /*
00002 $Id: FontInfo.java,v 1.2 2003/02/18 11:48:48 sander Exp $
00003 */
00004 
00005 
00006 package fr.ove.utils;
00007 
00008 import java.awt.*;
00009 import java.io.Serializable;
00010 import java.awt.image.*;
00011 
00018 public class FontInfo implements Serializable {
00025     public static int getLineThickness(Component component, Font font) {
00026         // On créé une petite image contenant le caractère '-'.
00027         // Le fond de cette image est blanc, tandis que le charactère est écrit en noir.
00028         // Une fois l'image générée, on va en créer un tableau d'entier, que l'on va parcourir jusqu'à
00029         // trouver un entier dont la valeur est différente de la valeur du blanc. (cela correspond à tomber
00030         // sur le début du '-', l'image étant parcourrue de haut en bas). Tant que l'on trouve cette valeur,
00031         // on est sur le '-'. Dès que l'on retombe sur la valeur du blanc, c'est qu'on est sorti du '-'.
00032         // On a récupéré l'épaisseur du charactère.
00033         // L'alignement sur le '-' correspond à la distance du haut de l'image sur le début du '-' plus la moitié
00034         // de sa taille.
00035 
00036         Graphics g = component.getGraphics();
00037         // On récupère les caractéristiques de la police utilisée
00038         FontMetrics fontMetrics = g.getFontMetrics(font);
00039         int height = fontMetrics.getHeight();
00040         int width = fontMetrics.stringWidth("-");
00041         
00042         // On créé l'image où l'on va écrire les '|'
00043         Image image = component.createImage(1, height);
00044         g = image.getGraphics();
00045         // Le fond est blanc et...
00046         g.setColor(Color.white);
00047         g.fillRect(0, 0, 1, height);
00048         // ...on écrit en noir
00049         g.setColor(Color.black);
00050         g.setFont(font);
00051         g.drawString("-", -width/2, fontMetrics.getAscent());
00052 
00053         // On récupère un tableau d'entier de l'image
00054            int img[] = new int[height];
00055         PixelGrabber grabber = new PixelGrabber(image, 0, 0, 1, height, img, 0, 1);
00056         try {
00057            grabber.grabPixels();
00058            }
00059            catch (InterruptedException e) {
00060            System.err.println("interrupted waiting for pixels!");
00061                return -1;
00062        }
00063 
00064        if ((grabber.getStatus() & ImageObserver.ABORT) != 0) {
00065                System.err.println("image fetch aborted or errored");
00066                return -1;
00067        }
00068 
00069        int blanc = img[0];
00070        int thickness = 0;
00071        for (int i = 0; i < height; i++) {
00072            if (img[i] == blanc) {
00073                if (thickness == 0)
00074                       continue;  // depuis le début on est sur du blanc, on continue le parcours de l'image
00075                   else
00076                       break; // on a trouvé du noir, et on retrouve du blanc, on a l'épaisseur, on arrête.
00077               }
00078 
00079               thickness++;
00080         }
00081 
00082         return (thickness > 0) ? thickness : 1;
00083     }
00084     
00091     public static int getStringWidth(Component component, Font font, String str) {
00092         Graphics g = component.getGraphics();
00093         FontMetrics fontMetrics = g.getFontMetrics(font);
00094         return fontMetrics.stringWidth(str);
00095     }
00096     
00102     public static int getMinusAlignment(Component component, Font font) {
00103         // On créé une petite image contenant le caractère '-'.
00104         // Le fond de cette image est blanc, tandis que le charactère est écrit en noir.
00105         // Une fois l'image générée, on va en créer un tableau d'entier, que l'on va parcourir jusqu'à
00106         // trouver un entier dont la valeur est différente de la valeur du blanc. (cela correspond à tomber
00107         // sur le début du '-', l'image étant parcourrue de haut en bas). Tant que l'on trouve cette valeur,
00108         // on est sur le '-'. Dès que l'on retombe sur la valeur du blanc, c'est qu'on est sorti du '-'.
00109         // On a récupéré l'épaisseur du charactère.
00110         // L'alignement sur le '-' correspond à la distance du haut de l'image sur le début du '-' plus la moitié
00111         // de sa taille.
00112 
00113         Graphics g = component.getGraphics();
00114         // On récupère les caractéristiques de la police utilisée
00115         FontMetrics fontMetrics = g.getFontMetrics(font);
00116         int height = fontMetrics.getHeight();
00117         int width = fontMetrics.stringWidth("-");
00118         
00119         // On créé l'image où l'on va écrire les '|'
00120         Image image = component.createImage(1, height);
00121         g = image.getGraphics();
00122         // Le fond est blanc et...
00123         g.setColor(Color.white);
00124         g.fillRect(0, 0, 1, height);
00125         // ...on écrit en noir
00126         g.setColor(Color.black);
00127         g.setFont(font);
00128         g.drawString("-", -width/2, fontMetrics.getAscent());
00129 
00130         // On récupère un tableau d'entier de l'image
00131            int img[] = new int[height];
00132         PixelGrabber grabber = new PixelGrabber(image, 0, 0, 1, height, img, 0, 1);
00133         try {
00134            grabber.grabPixels();
00135            }
00136            catch (InterruptedException e) {
00137            System.err.println("interrupted waiting for pixels!");
00138                return -1;
00139        }
00140 
00141        if ((grabber.getStatus() & ImageObserver.ABORT) != 0) {
00142                System.err.println("image fetch aborted or errored");
00143                return -1;
00144        }
00145 
00146        int blanc = img[0];
00147        int thickness = 0;
00148        int startMinus = 0;
00149        for (int i = 0; i < height; i++) {
00150            if (img[i] == blanc) {
00151                if (thickness == 0) {
00152                    startMinus++;
00153                       continue;  // depuis le début on est sur du blanc, on continue le parcours de l'image
00154                 }
00155                   else
00156                       break; // on a trouvé du noir, et on retrouve du blanc, on a l'épaisseur, on arrête.
00157               }
00158 
00159               thickness++;
00160         }
00161         
00162         thickness /= 2;
00163         thickness = (thickness > 0) ? thickness : 1;
00164         
00165         return startMinus + thickness;
00166     }
00167     public static int getPlusAlignment(Component component, Font font) {
00168         // On créé une petite image contenant le caractère '-'.
00169         // Le fond de cette image est blanc, tandis que le charactère est écrit en noir.
00170         // Une fois l'image générée, on va en créer un tableau d'entier, que l'on va parcourir jusqu'à
00171         // trouver un entier dont la valeur est différente de la valeur du blanc. (cela correspond à tomber
00172         // sur le début du '-', l'image étant parcourrue de haut en bas). Tant que l'on trouve cette valeur,
00173         // on est sur le '-'. Dès que l'on retombe sur la valeur du blanc, c'est qu'on est sorti du '-'.
00174         // On a récupéré l'épaisseur du charactère.
00175         // L'alignement sur le '-' correspond à la distance du haut de l'image sur le début du '-' plus la moitié
00176         // de sa taille.
00177 
00178         Graphics g = component.getGraphics();
00179         // On récupère les caractéristiques de la police utilisée
00180         FontMetrics fontMetrics = g.getFontMetrics(font);
00181         int height = fontMetrics.getHeight();
00182         int width = fontMetrics.stringWidth("+");
00183         
00184         // On créé l'image où l'on va écrire les '|'
00185         Image image = component.createImage(1, height);
00186         g = image.getGraphics();
00187         // Le fond est blanc et...
00188         g.setColor(Color.white);
00189         g.fillRect(0, 0, 1, height);
00190         // ...on écrit en noir
00191         g.setColor(Color.black);
00192         g.setFont(font);
00193         g.drawString("+", -width/2, fontMetrics.getAscent());
00194 
00195         // On récupère un tableau d'entier de l'image
00196            int img[] = new int[height];
00197         PixelGrabber grabber = new PixelGrabber(image, 0, 0, 1, height, img, 0, 1);
00198         try {
00199            grabber.grabPixels();
00200            }
00201            catch (InterruptedException e) {
00202            System.err.println("interrupted waiting for pixels!");
00203                return -1;
00204        }
00205 
00206        if ((grabber.getStatus() & ImageObserver.ABORT) != 0) {
00207                System.err.println("image fetch aborted or errored");
00208                return -1;
00209        }
00210 
00211        int blanc = img[0];
00212        int thickness = 0;
00213        int startMinus = 0;
00214        for (int i = 0; i < height; i++) {
00215            if (img[i] == blanc) {
00216                if (thickness == 0) {
00217                    startMinus++;
00218                       continue;  // depuis le début on est sur du blanc, on continue le parcours de l'image
00219                 }
00220                   else
00221                       break; // on a trouvé du noir, et on retrouve du blanc, on a l'épaisseur, on arrête.
00222               }
00223 
00224               thickness++;
00225         }
00226         
00227         thickness /= 2;
00228         thickness = (thickness > 0) ? thickness : 1;
00229         
00230         return startMinus + thickness;
00231     }
00232 }