Home | History | Annotate | Download | only in ports 
      1 /*
      2  * Copyright 2013 Google Inc.
      3  *
      4  * Use of this source code is governed by a BSD-style license that can be
      5  * found in the LICENSE file.
      6  */
      7 
      8 #ifndef SkFontConfigInterface_DEFINED
      9 #define SkFontConfigInterface_DEFINED
     10 
     11 #include "SkDataTable.h"
     12 #include "SkFontStyle.h"
     13 #include "SkRefCnt.h"
     14 #include "SkTypeface.h"
     15 
     16 struct SkBaseMutex;
     17 
     18 /**
     19  *  \class SkFontConfigInterface
     20  *
     21  *  A simple interface for remotable font management.
     22  *  The global instance can be found with RefGlobal().
     23  */
     24 class SK_API SkFontConfigInterface : public SkRefCnt {
     25 public:
     26 
     27 
     28     /**
     29      *  Returns the global SkFontConfigInterface instance, and if it is not
     30      *  NULL, calls ref() on it. The caller must balance this with a call to
     31      *  unref().
     32      */
     33     static SkFontConfigInterface* RefGlobal();
     34 
     35     /**
     36      *  Replace the current global instance with the specified one, safely
     37      *  ref'ing the new instance, and unref'ing the previous. Returns its
     38      *  parameter (the new global instance).
     39      */
     40     static SkFontConfigInterface* SetGlobal(SkFontConfigInterface*);
     41 
     42     /**
     43      *  This should be treated as private to the impl of SkFontConfigInterface.
     44      *  Callers should not change or expect any particular values. It is meant
     45      *  to be a union of possible storage types to aid the impl.
     46      */
     47     struct FontIdentity {
     48         FontIdentity() : fID(0), fTTCIndex(0) {}
     49 
     50         bool operator==(const FontIdentity& other) const {
     51             return fID == other.fID &&
     52                    fTTCIndex == other.fTTCIndex &&
     53                    fString == other.fString;
     54         }
     55         bool operator!=(const FontIdentity& other) const {
     56             return !(*this == other);
     57         }
     58 
     59         uint32_t    fID;
     60         int32_t     fTTCIndex;
     61         SkString    fString;
     62         SkFontStyle fStyle;
     63 
     64         // If buffer is NULL, just return the number of bytes that would have
     65         // been written. Will pad contents to a multiple of 4.
     66         size_t writeToMemory(void* buffer = NULL) const;
     67 
     68         // Recreate from a flattened buffer, returning the number of bytes read.
     69         size_t readFromMemory(const void* buffer, size_t length);
     70     };
     71 
     72     /**
     73      *  Given a familyName and style, find the best match.
     74      *
     75      *  If a match is found, return true and set its outFontIdentifier.
     76      *      If outFamilyName is not null, assign the found familyName to it
     77      *          (which may differ from the requested familyName).
     78      *      If outStyle is not null, assign the found style to it
     79      *          (which may differ from the requested style).
     80      *
     81      *  If a match is not found, return false, and ignore all out parameters.
     82      */
     83     virtual bool matchFamilyName(const char familyName[],
     84                                  SkTypeface::Style requested,
     85                                  FontIdentity* outFontIdentifier,
     86                                  SkString* outFamilyName,
     87                                  SkTypeface::Style* outStyle) = 0;
     88 
     89     /**
     90      *  Given a FontRef, open a stream to access its data, or return null
     91      *  if the FontRef's data is not available. The caller is responsible for
     92      *  deleting the stream when it is done accessing the data.
     93      */
     94     virtual SkStreamAsset* openStream(const FontIdentity&) = 0;
     95 
     96     /**
     97      *  Return an SkTypeface for the given FontIdentity.
     98      *
     99      *  The default implementation simply returns a new typeface built using data obtained from
    100      *  openStream(), but derived classes may implement more complex caching schemes.
    101      *
    102      *  Callers are responsible for unref-ing the result.
    103      */
    104     virtual SkTypeface* createTypeface(const FontIdentity& identity) {
    105         return SkTypeface::CreateFromStream(this->openStream(identity), identity.fTTCIndex);
    106     }
    107 
    108     /**
    109      *  Return a singleton instance of a direct subclass that calls into
    110      *  libfontconfig. This does not affect the refcnt of the returned instance.
    111      *  The mutex may be used to guarantee the singleton is only constructed once.
    112      */
    113     static SkFontConfigInterface* GetSingletonDirectInterface(SkBaseMutex* mutex = NULL);
    114 
    115     // New APIS, which have default impls for now (which do nothing)
    116 
    117     virtual SkDataTable* getFamilyNames() { return SkDataTable::NewEmpty(); }
    118     typedef SkRefCnt INHERITED;
    119 };
    120 
    121 #endif
    122