/*
    * Copyright 1999-2006 Faculty of Mathematics, Physics
    * and Informatics, Comenius University, Bratislava. This file is protected by
    * the Mozilla Public License version 1.1 (the License); you may not use this
    * file except in compliance with the License. You may obtain a copy of the
    * License at http://euromath2.sourceforge.net/license.html Unless required by
    * applicable law or agreed to in writing, software distributed under the
    * License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
    * OF ANY KIND, either express or implied. See the License for the specific
   * language governing permissions and limitations under the License.
   */
  package sk.uniba.euromath.foTools;
  
  import java.util.HashMap;
  import java.util.Map;
  
  import org.apache.fop.fonts.FontType;
  import org.eclipse.draw2d.FigureUtilities;
  import org.eclipse.draw2d.geometry.Dimension;
  import org.eclipse.swt.SWT;
  import org.eclipse.swt.graphics.Font;
  import org.eclipse.swt.graphics.FontData;
  import org.eclipse.swt.graphics.FontMetrics;
  
  /***
   * Description of SWT font of given name(family name), style and weight for
   * different sizes.
   */
  public class SWTFontMetrics implements org.apache.fop.fonts.FontMetrics {
  
          private static final float FF = 750.0f * 1000.0f; // Font Factor
  
          private String fontName;
  
          private int fontStyle;
  
          private SWTFontRepository repository;
  
          /***
           * Cach for created font metrics for concrete sizes.
           */
          private Map<Integer, FontMetrics> sizeMetricsMap = new HashMap<Integer, FontMetrics>();
  
          /***
           * Constructor.
           * 
           * @param fontData
           * @param repository
           */
          public SWTFontMetrics(FontData fontData, SWTFontRepository repository) {
                  this.repository = repository;
                  this.fontName = fontData.getName();
                  this.fontStyle = fontData.getStyle();
          }
  
          public SWTFontMetrics(String fontName, int fontStyle,
                          SWTFontRepository repository) {
                  this.repository = repository;
                  this.fontName = fontName;
                  this.fontStyle = fontStyle;
          }
  
          protected int convert(float f) {
                  return Math.round(f + 0.5f);
          }
  
          protected int convertInput(int size) {
                  float dpi = 96.0f;
                  float result = size;
  
                  result /= 1000.0f; // --> to points
                  // result /= 72.0f; // --> to inches
                  // result *= dpi; // --> to pixels
  
                  return Math.round(result);
          }
  
          public int getAscender(int size) {
                  size = convertInput(size);
  
                  return convert((getSWTFontMetrics(size).getHeight()
                                  - getSWTFontMetrics(size).getDescent()) * FF);
          }
  
          public int getCapHeight(int size) {
                  return getXHeight(size);
          }
  
          /***
           * Returns SWT metrics of font of concrete size. Results are cached.
           * 
           * @param size
           * @return
           */
          private FontMetrics getSWTFontMetrics(int size) {
                  // look into cach first
                  FontMetrics fontMetrics = this.sizeMetricsMap.get(new Integer(
                                  size));
                  if (fontMetrics != null)
                         return fontMetrics;
 
                 // not present in cach, create and cach it
                 fontMetrics = FigureUtilities.getFontMetrics(repository
                                 .getFont(fontName, size, fontStyle));
                 this.sizeMetricsMap.put(new Integer(size), fontMetrics);
                 return fontMetrics;
 
         }
 
         public int getDescender(int size) {
                 size = convertInput(size);
 
                 return Math.round(-1 * getSWTFontMetrics(size).getDescent()
                                 * FF);
         }
 
         public String getFontName() {
                 return fontName;
         }
 
         public FontType getFontType() {
                 return FontType.TRUETYPE;
         }
 
         public Map getKerningInfo() {
                 return null;
         }
 
         public int getWidth(int i, int size) {
                 size = convertInput(size);
 
                 StringBuffer buffer = new StringBuffer(100);
                 for (int count = 0; count < 100; count++) {
                         buffer.append((char) i);
                 }
 
                 float w = FigureUtilities.getStringExtents(buffer.toString(),
                                 getFont(size)).width;
                 // w = computeByAWT(buffer.toString());
 
                 // return convert(w/EMPTY_L * 0.85f);
                 return convert((w / 100.0f) * FF);
         }
 
         public int[] getWidths() {
                 return null;
         }
 
         public int getXHeight(int size) {
                 size = convertInput(size);
 
                 Dimension d = FigureUtilities.getStringExtents("X",
                                 getFont(size));
                 return convert(d.height * FF);
         }
 
         /*
          * (non-Javadoc)
          * 
          * @see org.apache.fop.fonts.FontMetrics#hasKerningInfo()
          */
         public boolean hasKerningInfo() {
                 return false;
         }
 
         /***
          * Returns SWT font of this metric and given size.
          * 
          * @param size
          *                size(height) of font
          */
         public Font getFont(int size) {
                 return this.repository.getFont(this.fontName, size,
                                 this.fontStyle);
         }
         
         /***
          * Converts SWT style to FOP font style.
          * 
          * @param SWTStyle
          *                to convert
          * @return
          */
         public static String convertSWTFontStyleToFopFontStyle(int SWTStyle) {
                 switch (SWTStyle) {
                 case SWT.NORMAL:
                         return "normal";
                 case SWT.BOLD:
                         return "bold";
                 case SWT.ITALIC:
                         return "italic";
                 }
                 // TODO Studva italic bold                
                 return "normal";
         }
 
 }