/layout/svg/renderer/src/libart/nsSVGLibartGlyphMetricsFT.cpp

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* ----- BEGIN LICENSE BLOCK -----
 * Version: MPL 1.1/GPL 2.0/LGPL 2.1
 *
 * The contents of this file are subject to 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://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is the Mozilla SVG project.
 *
 * The Initial Developer of the Original Code is 
 * .
 * Portions created by the Initial Developer are Copyright (C) 2002
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 *    Leon Sha <leon.sha@sun.com>
 *    Alex Fritze <alex@croczilla.com>
 *
 * Alternatively, the contents of this file may be used under the terms of
 * either the GNU General Public License Version 2 or later (the "GPL"), or 
 * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
 * in which case the provisions of the GPL or the LGPL are applicable instead
 * of those above. If you wish to allow use of your version of this file only
 * under the terms of either the GPL or the LGPL, and not to allow others to
 * use your version of this file under the terms of the NPL, indicate your
 * decision by deleting the provisions above and replace them with the notice
 * and other provisions required by the GPL or the LGPL. If you do not delete
 * the provisions above, a recipient may use your version of this file under
 * the terms of any one of the MPL, the GPL or the LGPL.
 *
 * ----- END LICENSE BLOCK ----- */

#include "nsCOMPtr.h"
#include "nsISVGGlyphMetricsSource.h"
#include "nsISVGRendererGlyphMetrics.h"
#include "nsPromiseFlatString.h"
#include "nsFont.h"
#include "nsIFontMetrics.h"
#include "nsIPresContext.h"
#include "float.h"
#include "nsIDOMSVGMatrix.h"
#include "nsIDOMSVGRect.h"
#include "nsSVGTypeCIDs.h"
#include "nsIComponentManager.h"
#include "nsISVGLibartGlyphMetricsFT.h"
#include "nsIDeviceContext.h"
#include "nsFreeType.h"
#include "nsIServiceManager.h"
#include "libart-incs.h"
#include "nsArray.h"
#include "nsDataHashtable.h"
#include "nsIPromptService.h"



class nsSVGLibartGlyphMetricsFT : public nsISVGLibartGlyphMetricsFT
{
protected:
  friend nsresult NS_NewSVGLibartGlyphMetrics(nsISVGRendererGlyphMetrics **result,
                                              nsISVGGlyphMetricsSource *src);
  friend void NS_InitSVGLibartGlyphMetricsGlobals();
  friend void NS_FreeSVGLibartGlyphMetricsGlobals();

  nsSVGLibartGlyphMetricsFT(nsISVGGlyphMetricsSource *src);
  ~nsSVGLibartGlyphMetricsFT();

  // nsISupports interface:
  NS_DECL_ISUPPORTS

  // nsISVGRendererGlyphMetrics interface:
  NS_DECL_NSISVGRENDERERGLYPHMETRICS

  // nsISVGLibartGlyphMetrics interface:
  NS_IMETHOD_(FT_Face) GetFTFace();
  NS_IMETHOD_(float) GetPixelScale();
  NS_IMETHOD_(float) GetTwipsToPixels();
  NS_IMETHOD GetBoundingMetrics(PRInt32* aLeftBearing,
                                PRInt32* aRightBearing,
                                PRInt32* aAscent,
                                PRInt32* aDescent,
                                PRInt32* aWidth);

  // helpers :
  void ClearFontInfo() { mImageDesc.font.face_id=nsnull; }
  void InitializeFontInfo();
  
private:
  PRUint16 mPixelSize;
  FTC_Image_Desc mImageDesc;
  nsCOMPtr<nsISVGGlyphMetricsSource> mSource;
  
  static nsCOMPtr<nsIFreeType2> sFt2;
  static PRBool sFontErrorShown;
public:
  static nsDataHashtable<nsStringHashKey,nsDependentString*> sFontAliases;  
};

//----------------------------------------------------------------------
// implementation:

nsCOMPtr<nsIFreeType2> nsSVGLibartGlyphMetricsFT::sFt2;
PRBool nsSVGLibartGlyphMetricsFT::sFontErrorShown = PR_FALSE;

nsDataHashtable<nsStringHashKey,nsDependentString*>
nsSVGLibartGlyphMetricsFT::sFontAliases;


nsSVGLibartGlyphMetricsFT::nsSVGLibartGlyphMetricsFT(nsISVGGlyphMetricsSource *src):mSource(src)
{
  mImageDesc.font.face_id=nsnull;
}

nsSVGLibartGlyphMetricsFT::~nsSVGLibartGlyphMetricsFT()
{
  ClearFontInfo();
}

nsresult
NS_NewSVGLibartGlyphMetrics(nsISVGRendererGlyphMetrics **result,
                             nsISVGGlyphMetricsSource *src)
{
  *result = new nsSVGLibartGlyphMetricsFT(src);
  if (!*result) return NS_ERROR_OUT_OF_MEMORY;
  
  NS_ADDREF(*result);
  return NS_OK;
}

void NS_InitSVGLibartGlyphMetricsGlobals()
{
  NS_ASSERTION(!nsSVGLibartGlyphMetricsFT::sFt2, "ft2 already initialized");
  nsSVGLibartGlyphMetricsFT::sFt2 = do_GetService(NS_FREETYPE2_CONTRACTID, &rv);
  
  NS_ASSERTION(!nsSVGLibartGlyphMetricsFT::sFontAliases.IsInitialized(),
               "font aliases already initialized");
  nsSVGLibartGlyphMetricsFT::sFontAliases.Init(3);

  static NS_NAMED_LITERAL_STRING(arial, "arial");
  nsSVGLibartGlyphMetricsFT::sFontAliases.Put(NS_LITERAL_STRING("helvetica"),
                                              &arial);

  static NS_NAMED_LITERAL_STRING(courier, "courier new");
  nsSVGLibartGlyphMetricsFT::sFontAliases.Put(NS_LITERAL_STRING("courier"),
                                              &courier);

  static NS_NAMED_LITERAL_STRING(times, "times new roman");
  nsSVGLibartGlyphMetricsFT::sFontAliases.Put(NS_LITERAL_STRING("times"),
                                              &times);
}

void NS_FreeSVGLibartGlyphMetricsGlobals()
{
  NS_ASSERTION(nsSVGLibartGlyphMetricsFT::sFt2, "ft2 never initialized");
  nsSVGLibartGlyphMetricsFT::sFt2 = nsnull;
  
  NS_ASSERTION(nsSVGLibartGlyphMetricsFT::sFontAliases.IsInitialized(),
               "font aliases never initialized");
  nsSVGLibartGlyphMetricsFT::sFontAliases.Clear();
}

//----------------------------------------------------------------------
// nsISupports methods:

NS_IMPL_ADDREF(nsSVGLibartGlyphMetricsFT)
NS_IMPL_RELEASE(nsSVGLibartGlyphMetricsFT)

NS_INTERFACE_MAP_BEGIN(nsSVGLibartGlyphMetricsFT)
  NS_INTERFACE_MAP_ENTRY(nsISVGRendererGlyphMetrics)
  NS_INTERFACE_MAP_ENTRY(nsISVGLibartGlyphMetricsFT)
  NS_INTERFACE_MAP_ENTRY(nsISupports)
NS_INTERFACE_MAP_END

//----------------------------------------------------------------------
// nsISVGRendererGlyphMetrics methods:

NS_IMETHODIMP
nsSVGLibartGlyphMetricsFT::GetBaselineOffset(PRUint16 baselineIdentifier, float *_retval)
{
  *_retval = 0.0f;
  
  switch (baselineIdentifier) {
    case BASELINE_TEXT_BEFORE_EDGE:
      break;
    case BASELINE_TEXT_AFTER_EDGE:
      break;
    case BASELINE_CENTRAL:
    case BASELINE_MIDDLE:
      break;
    case BASELINE_ALPHABETIC:
    default:
    break;
  }
  
  return NS_OK;
}


NS_IMETHODIMP
nsSVGLibartGlyphMetricsFT::GetAdvance(float *aAdvance)
{
  *aAdvance = 0.0f;
  return NS_OK;
}

NS_IMETHODIMP
nsSVGLibartGlyphMetricsFT::GetBoundingBox(nsIDOMSVGRect * *aBoundingBox)
{
  *aBoundingBox = nsnull;

  nsCOMPtr<nsIDOMSVGRect> rect = do_CreateInstance(NS_SVGRECT_CONTRACTID);

  NS_ASSERTION(rect, "could not create rect");
  if (!rect) return NS_ERROR_FAILURE;
  
  rect->SetX(0);
  rect->SetY(0);
  rect->SetWidth(0);
  rect->SetHeight(0);

  *aBoundingBox = rect;
  NS_ADDREF(*aBoundingBox);
  
  return NS_OK;
}

NS_IMETHODIMP
nsSVGLibartGlyphMetricsFT::GetExtentOfChar(PRUint32 charnum, nsIDOMSVGRect **_retval)
{
  *_retval = nsnull;

  nsCOMPtr<nsIDOMSVGRect> rect = do_CreateInstance(NS_SVGRECT_CONTRACTID);

  NS_ASSERTION(rect, "could not create rect");
  if (!rect) return NS_ERROR_FAILURE;
  
  rect->SetX(0);
  rect->SetY(0);
  rect->SetWidth(0);
  rect->SetHeight(0);

  *_retval = rect;
  NS_ADDREF(*_retval);
  
  return NS_OK;
}

NS_IMETHODIMP
nsSVGLibartGlyphMetricsFT::Update(PRUint32 updatemask, PRBool *_retval)
{
  *_retval = PR_FALSE;
  return NS_OK;
}

//----------------------------------------------------------------------
// nsISVGLibartGlyphMetrics methods:

NS_IMETHODIMP_(FT_Face)
nsSVGLibartGlyphMetricsFT::GetFTFace()
{
  InitializeFontInfo();
  nsresult rv;
  FT_Face face = nsnull;
  FTC_Manager mgr;
  sFt2->GetFTCacheManager(&mgr);
  rv = sFt2->ManagerLookupSize(mgr, &mImageDesc.font, &face, nsnull);
  NS_ASSERTION(NS_SUCCEEDED(rv), "failed to get face/size");
  if (NS_FAILED(rv))
    return nsnull;
  return face;
}

NS_IMETHODIMP_(float)
nsSVGLibartGlyphMetricsFT::GetPixelScale()
{
  nsCOMPtr<nsIPresContext> presContext;
  mSource->GetPresContext(getter_AddRefs(presContext));
  if (!presContext) {
    NS_ERROR("null prescontext");
    return 1.0f;
  }

  nsCOMPtr<nsIDeviceContext> devicecontext;
  presContext->GetDeviceContext(getter_AddRefs(devicecontext));

  float scale;
  devicecontext->GetCanonicalPixelScale(scale);
  return scale;
}  

NS_IMETHODIMP_(float)
nsSVGLibartGlyphMetricsFT::GetTwipsToPixels()
{
  nsCOMPtr<nsIPresContext> presContext;
  mSource->GetPresContext(getter_AddRefs(presContext));
  if (!presContext) {
    NS_ERROR("null prescontext");
    return 1.0f;
  }
  float twipstopixel;
  presContext->GetTwipsToPixels(&twipstopixel);
  return twipstopixel;
}  

NS_IMETHODIMP
nsSVGLibartGlyphMetricsFT::GetBoundingMetrics(PRInt32* aLeftBearing,
                                              PRInt32* aRightBearing,
                                              PRInt32* aAscent,
                                              PRInt32* aDescent,
                                              PRInt32* aWidth)
{
  *aLeftBearing = 0;
  *aRightBearing = 0;
  *aAscent = 0;
  *aDescent = 0;
  *aWidth = 0;
  nsresult rv;
  FT_BBox bbox;
  // initialize to "uninitialized" values
  bbox.xMin = bbox.yMin = 32000;
  bbox.xMax = bbox.yMax = -32000;

  // get the face/size from the FreeType cache
  FT_Face face = GetFTFace();
  if (!face) {
    NS_ERROR("could not get face");
    return NS_ERROR_FAILURE;
  }
  
  FT_GlyphSlot glyphslot=face->glyph;

  FT_UInt glyph_index;
  FT_Glyph glyph;
  FT_BBox glyph_bbox;

  nsAutoString mtext;
  mSource->GetCharacterData(mtext);
  nsAString::const_iterator start, end;
  mtext.BeginReading(start);
  mtext.EndReading(end);
  PRUint32 size, i;
  
  FT_Pos advance,pos=0;

  for ( ; start != end; start.advance(size)) 
  {
    const PRUnichar* buf = start.get();
    size = start.size_forward();
    pos=advance=0;
    if (size < 1) {
      return NS_ERROR_FAILURE;
    }
    // fragment at 'buf' is 'size' characters long
    for (i=0; i<size; ++i)
    {
      PRUnichar tt=*buf++;
      sFt2->GetCharIndex(face, (FT_ULong)tt, &glyph_index);
      NS_ASSERTION(glyph_index,"failed to get glyph");
//      if (glyph_index) {
      rv = sFt2->LoadGlyph(face,glyph_index,FT_LOAD_RENDER);
      NS_ASSERTION(NS_SUCCEEDED(rv),"error loading glyph bitmap");
      rv = sFt2->GetGlyph(glyphslot,&glyph);
      NS_ASSERTION(NS_SUCCEEDED(rv),"error get glyph");
      sFt2->GlyphGetCBox(glyph, ft_glyph_bbox_pixels, &glyph_bbox);
      advance = ((glyph->advance.x)>>16);
//      }
      bbox.xMin = PR_MIN(pos+glyph_bbox.xMin, bbox.xMin);
      bbox.xMax = PR_MAX(pos+glyph_bbox.xMax, bbox.xMax);
      bbox.yMin = PR_MIN(glyph_bbox.yMin, bbox.yMin);
      bbox.yMax = PR_MAX(glyph_bbox.yMax, bbox.yMax);
      pos += advance;
    }
  } 
  if (bbox.xMin > bbox.xMax)
    bbox.xMin = bbox.xMax = bbox.yMin = bbox.yMax = 0;
  *aLeftBearing  = bbox.xMin;
  *aRightBearing = bbox.xMax;
  *aAscent       = bbox.yMax;
  *aDescent      = -bbox.yMin;
  *aWidth        = pos;
  return NS_OK;
}

//----------------------------------------------------------------------
// Implementation helpers:


struct FindFontStruct {
  nsCOMPtr<nsIFontCatalogService> catalog;
  nsCOMPtr<nsITrueTypeFontCatalogEntry> font_entry;
  nsFont font;
};

static PRBool
FindFont(const nsString& aFamily, PRBool aGeneric, void *aData)
{
  PRBool retval = PR_TRUE;
  
  FindFontStruct* &font_data = (FindFontStruct*) aData;
  
#ifdef DEBUG
  printf("trying to instantiate font %s, generic=%d\n", NS_ConvertUCS2toUTF8(aFamily).get(),
         aGeneric);
#endif

  nsCAutoString family_name;
  
  if (aGeneric) {
    PRUint8 id;
    nsFont::GetGenericID(aFamily, &id);
    switch (id) {
      case kGenericFont_serif:
        family_name = NS_LITERAL_CSTRING("times new roman");
        break;
      case kGenericFont_monospace:
        family_name = NS_LITERAL_CSTRING("courier new");
        break;
      case kGenericFont_sans_serif:
      default:
        family_name = NS_LITERAL_CSTRING("arial");
        break;
    }
  }
  else {
    family_name = NS_ConvertUCS2toUTF8(aFamily);
    ToLowerCase(family_name);
  }
  
  nsCAutoString language;
  PRUint16 slant = nsIFontCatalogService::kFCSlantRoman;
  if (font_data->font.style && NS_FONT_STYLE_ITALIC)
    slant = nsIFontCatalogService::kFCSlantItalic;
    
  nsCOMPtr<nsIArray> arr;
  font_data->catalog->GetFontCatalogEntries(family_name,
                                            language,
                                            font_data->font.weight,
                                            nsIFontCatalogService::kFCWeightAny,
                                            slant,
                                            nsIFontCatalogService::kFCSpacingAny,
                                            getter_AddRefs(arr));
  PRUint32 count;
  arr->GetLength(&count);
#ifdef DEBUG
  printf("FindFont(%s): number of fonts found: %d\n", family_name.get(), count);
#endif
  if (count>0) {
    retval =  PR_FALSE; // break
    // just take the first one for now:
    arr->QueryElementAt(0, NS_GET_IID(nsITrueTypeFontCatalogEntry),
                        getter_AddRefs(font_data->font_entry));
  }
  else {
    // try alias if there is one:
    nsDependentString *alias = nsnull;
    nsSVGLibartGlyphMetricsFT::sFontAliases.Get(NS_ConvertUTF8toUCS2(family_name),
                                                &alias);
    if (alias) {
      // XXX this might cause a stack-overflow if there are cyclic
      // aliases in sFontAliases
      retval = FindFont(nsString(*alias), PR_FALSE, aData);      
    }
  }
  
  return retval;      
}

void
nsSVGLibartGlyphMetricsFT::InitializeFontInfo()
{
  if (mImageDesc.font.face_id!=nsnull) return; // already initialized
  
  FindFontStruct font_data;
  mSource->GetFont(&font_data.font);

  font_data.catalog = do_GetService("@mozilla.org/gfx/xfontcatalogservice;1");  
  if (!font_data.catalog) {
    NS_ERROR("Font Catalog Service init failed\n");
    return;
  }  

#ifdef DEBUG
  {
    printf("Families available:\n");
    nsCAutoString empty;
    nsCOMPtr<nsIArray> arr;
    font_data.catalog->GetFontCatalogEntries(empty, empty, 0, 0, 0, 0, getter_AddRefs(arr));
    PRUint32 c;
    arr->GetLength(&c);
    for (PRUint32 i=0;i<c;++i) {
      nsCOMPtr<nsITrueTypeFontCatalogEntry> font = do_QueryElementAt(arr, i);
      nsCAutoString family, style, vendor;
      font->GetFamilyName(family);
      font->GetStyleName(style);
      font->GetVendorID(vendor);
      printf("* %s, %s, %s\n", family.get(), style.get(), vendor.get());
    }
  }
#endif

  font_data.font.EnumerateFamilies(FindFont, (void*)&font_data);

  if (!font_data.font_entry) {
    // try to find *any* font
    nsAutoString empty;
    FindFont(empty, PR_FALSE, (void*)&font_data);
  }
  
  if (!font_data.font_entry) {
//    NS_ERROR("svg libart renderer can't find a font (let alone a suitable one)");
    if (!sFontErrorShown) {
      nsCOMPtr<nsIPromptService> prompter(do_GetService("@mozilla.org/embedcomp/prompt-service;1"));
      nsXPIDLString title(NS_LITERAL_STRING("Font Configuration Error"));
      nsXPIDLString msg(NS_LITERAL_STRING("The Libart/Freetype SVG rendering backend can't find any truetype fonts on your system. "
                                          "Please go to http://www.mozilla.org/projects/fonts/unix/enabling_truetype.html and "
                                          "follow steps 2-7."));
      prompter->Alert(nsnull, title, msg);
      sFontErrorShown = PR_TRUE;
    }
    return;
  }

  // fill mImageDesc:
  mImageDesc.font.face_id=(void*)font_data.font_entry.get(); // XXX do we need to addref?
  float twipstopixel = GetTwipsToPixels();
  float scale = GetPixelScale();
  mImageDesc.font.pix_width = (int)((float)(font_data.font.size)*twipstopixel/scale);
  mImageDesc.font.pix_height = (int)((float)(font_data.font.size)*twipstopixel/scale);
  mImageDesc.image_type |= ftc_image_grays;
}

---