Public API Reference

csplugincommon/canvas/fontcache.h

Go to the documentation of this file.

/*
    Copyright (C) 2003 by Jorrit Tyberghein
              (C) 2003 by Frank Richter

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public
    License along with this library; if not, write to the Free
    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#ifndef __CS_CSPLUGINCOMMON_CANVAS_FONTCACHE_H__
#define __CS_CSPLUGINCOMMON_CANVAS_FONTCACHE_H__

#include "csextern.h"

#include "csutil/blockallocator.h"
#include "csutil/csunicode.h"
#include "csutil/scf_implementation.h"
#include "csutil/set.h"
#include "ivideo/fontserv.h"


#define GLYPH_INDEX_UPPER_SHIFT     9
#define GLYPH_INDEX_LOWER_COUNT     512
#define GLYPH_INDEX_LOWER_MASK      0x1ff

#define RELEVANT_WRITE_FLAGS        CS_WRITE_NOANTIALIAS

class CS_CRYSTALSPACE_EXPORT csFontCache
{
public:
  struct KnownFont;
  struct GlyphCacheData
  {
    KnownFont* font;
    utf32_char glyph;
    csGlyphMetrics glyphMetrics;
    bool hasGlyph;
    uint flags;
  };

protected:
  struct LRUEntry
  {
    LRUEntry* next;
    LRUEntry* prev;

    GlyphCacheData* cacheData;
  };
  LRUEntry* head;
  LRUEntry* tail;

  csBlockAllocator<LRUEntry> LRUAlloc;

  struct PlaneGlyphs
  {
    LRUEntry* entries[GLYPH_INDEX_LOWER_COUNT];
    int usedGlyphs;

    PlaneGlyphs ()
    {
      memset (entries, 0, sizeof (entries));
      usedGlyphs = 0;
    }
  };

  class PlaneGlyphElementHandler : public csArrayElementHandler<PlaneGlyphs*>
  {
  public:
    static void Construct (PlaneGlyphs** address, PlaneGlyphs* const& src)
    {
      *address = src;
    }

    static void Destroy (PlaneGlyphs** /*address*/)
    {
    }

    static void InitRegion (PlaneGlyphs** address, size_t count)
    {
      memset (address, 0, count * sizeof (PlaneGlyphs*));
    }
  };

  typedef csArray<PlaneGlyphs*, PlaneGlyphElementHandler> PlaneGlyphsArray;
public:
  struct KnownFont
  {
    iFont* font;
    float fontSize;
    PlaneGlyphsArray planeGlyphs;
  };
  int ClipX1, ClipY1, ClipX2, ClipY2;
protected:

  csArray<KnownFont*> knownFonts;
  csSet<csPtrKey<KnownFont> > purgeableFonts;

  LRUEntry* FindLRUEntry (KnownFont* font, utf32_char glyph);
  LRUEntry* FindLRUEntry (GlyphCacheData* cacheData);

  static int KnownFontArrayCompareItems (KnownFont* const& item1, 
    KnownFont* const& item2);
  static int KnownFontArrayCompareToKey (KnownFont* const& item1, 
    iFont* const& item2);
  static csArrayCmp<KnownFont*,iFont*> KnownFontArrayKeyFunctor(iFont* f)
    { return csArrayCmp<KnownFont*,iFont*>(f, KnownFontArrayCompareToKey); }

  virtual GlyphCacheData* InternalCacheGlyph (KnownFont* font,
    utf32_char glyph, uint flags);
  virtual void InternalUncacheGlyph (GlyphCacheData* cacheData);

  GlyphCacheData* CacheGlyphUnsafe (KnownFont* font, 
    utf32_char glyph, uint flags);
  void SetupCacheData (GlyphCacheData* cacheData,
    KnownFont* font, utf32_char glyph, uint flags);

  void AddCacheData (KnownFont* font, utf32_char glyph, GlyphCacheData* cacheData);
  void RemoveCacheData (GlyphCacheData* cacheData);
  void RemoveLRUEntry (LRUEntry* entry);
  GlyphCacheData* InternalGetCacheData (KnownFont* font, utf32_char glyph);

  struct FontDeleteNotify : public scfImplementation1<FontDeleteNotify, 
                                                      iFontDeleteNotify>
  {
    csFontCache* cache;
    
    FontDeleteNotify (csFontCache* cache);
    virtual ~FontDeleteNotify ();

    virtual void BeforeDelete (iFont* font);
  };
  FontDeleteNotify* deleteCallback;

  void CleanupCache ();
public:
  csFontCache ();
  virtual ~csFontCache ();
  
  GlyphCacheData* CacheGlyph (KnownFont* font, utf32_char glyph,
    uint flags);
  void UncacheGlyph (GlyphCacheData* cacheData);

  KnownFont* GetCachedFont (iFont* font);
  KnownFont* CacheFont (iFont* font);
  void UncacheFont (iFont* font);
  GlyphCacheData* GetCacheData (KnownFont* font, utf32_char glyph, 
    uint flags);
  GlyphCacheData* GetLeastUsed ();

  void PurgeEmptyPlanes ();

  void SetClipRect (int x1, int y1, int x2, int y2)
  { 
    ClipX1 = x1; ClipY1 = y1; ClipX2 = x2; ClipY2 = y2; 
  }


  virtual void WriteString (iFont *font, int x, int y, int fg, int bg, 
    const void* text, bool isWide, uint flags);
};

#endif // __CS_CSPLUGINCOMMON_CANVAS_FONTCACHE_H__

---