FontCache.h

// FontCache.h: interface for the CFontCache class.
//

#if !defined(LST_FONTCACHE_H__INCLUDED_)
#define LST_FONTCACHE_H__INCLUDED_

#pragma once

#include <string>
#include <vector>
#include <map>

#include "FontProperties.h"
#include "FontCacheEntry.h"
#include "Utility/LSTException.h"
#include "Utility/Config.h"
#include "Utility/wstring.h"

#include <ft2build.h>
#include FT_FREETYPE_H

#ifdef WIN32
#define SLASHC '\\'
static const wchar_t *cvFonts = L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Fonts";
static const wchar_t *cvT1fonts = L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Type 1 Installer\\Type 1 Fonts";
static const wchar_t *lstFontCacheDir = L"\\Larson Software Technology\\Common";
static const wchar_t *lstFontCacheFile = L"\\FontCache.dat";
static const wchar_t *baseFontPath = L""; // what else is needed after windows font registry
#endif

#ifdef LINUX
#define SLASHC '/'
static const wchar_t *cvFonts = L"";
static const wchar_t *cvT1fonts = L"";
static const wchar_t *lstFontCacheDir = L"/common";
static const wchar_t *lstFontCacheFile = L"/FontCache.dat";
static const wchar_t *baseFontPath = L"~/.larson/common/fonts;/usr/local/lib/larson/fonts;/usr/local/lib64/larson/fonts;~/.fonts;/usr/share/fonts;/usr/share/X11/fonts";
#endif

#ifdef EMSCRIPTEN
#define SLASHC '/'
static const wchar_t *cvFonts = L"";
static const wchar_t *cvT1fonts = L"";
static const wchar_t *lstFontCacheDir = L"/";
static const wchar_t *lstFontCacheFile = L"/FontCache.dat";
static const wchar_t *baseFontPath = L"/fonts";
#endif

#ifdef IOS
#define SLASHC '/'
static const wchar_t *cvFonts = L"";
static const wchar_t *cvT1fonts = L"";
static const wchar_t *lstFontCacheDir = L"/Larson Software Technology/Common";
static const wchar_t *lstFontCacheFile = L"/FontCache.dat";
// On IOS devices, simulator directory tends to be ..Font, device is ,,Fonts/Cache so search both
//  14apr2015 dml- on IOS 7 or 8 this changed to /System/Library/Fonts/Core
static const wchar_t *baseFontPath = L"/System/Library/Fonts;/System/Library/Fonts/Cache;/System/Library/Fonts/Core";
#endif

#ifdef ANDROID
#define SLASHC '/'
static const wchar_t *cvFonts = L"";
static const wchar_t *cvT1fonts = L"";
static const wchar_t *lstFontCacheDir = L""; // the "common data path" directory
static const wchar_t *lstFontCacheFile = L"/FontCache.dat";
static const wchar_t *baseFontPath = L"/system/fonts";
#endif


namespace Larson
{
        class MapEntry {
        public:
                MapEntry() { m_unicodeName = false; matchName = NULL; fontEntry = NULL; };

                bool                    m_unicodeName;
                std::wstring*           matchName;
                CFontCacheEntry *fontEntry;
        };

        typedef multimap <wchar_t, MapEntry, less<wchar_t> > cache_type;
        
        class CLSTFont;
        class CFontCache
        {
                //
                //
        public:
        enum ExceptionCodes {
            eUnableToInitializeFreeType = EXC_FONTCACHE,
            eUnableToGenerateFontCache = EXC_FONTCACHE + 1,
                        eUnableToWriteFontCacheFile = EXC_FONTCACHE + 2,
                        eUnableToOpenFontCacheFile = EXC_FONTCACHE + 3
        };

                typedef cache_type::value_type value_type;

                wchar_t *keys[2]; // = {

                static CFontCache* Instance();

                void serialize();
                void restore(Larson::CConfig* config);

                FT_Face findFace(Larson::CConfig* config, CLSTFont *);
                int getFacesSize() { return (int)m_fontEntries.size(); };
                std::wstring getFaceFamilyByIndex(int index) { return m_fontEntries[index].m_familyName; };
                std::wstring getFacePathByIndex(int index) { return m_fontEntries[index].m_path; };

        protected:
                CFontCache() { 

                        keys[0] = (wchar_t*)cvFonts;
                        keys[1] = (wchar_t*)cvT1fonts;

                        m_cacheLoaded = false; 
                        m_library = NULL;
                        m_diskCacheOld = false;
                        m_version = LST_CACHE_VERSION;
                        m_checkvalue = 0;
                };
                ~CFontCache();

        private:
                FT_Error newFace(std::string path, int faceIndex, FT_Face *face);
                FT_Face loadFace(CFontCacheEntry* entry);
                FT_Face matchSubstituteFont(const std::wstring &subName);
                CFontCacheEntry* matchByProps(CFontProperties& props);
                CFontCacheEntry::Weight type1WeightStringToValue(string weight);
                FT_Face trySubstitution(vector<std::wstring> substitutes);

                void addFaceToFaceVector(FT_Face face, std::wstring path);
                void organizeNamesInCache();
                bool diskCacheExists();
                unsigned long getFontCheckValue(Larson::CConfig* config);

                void generateCache(Larson::CConfig* config);
                inline int nEquals(std::wstring str1, std::wstring str2)
                {
                        int i = 0;
                        for (; i < (int)str1.size() && i < (int)str2.size(); i++)
                        {
                                if (str1[i] != str2[i])
                                        break;
                        }
                        return i;
                };

                FT_Library                                      m_library;
                cache_type                                      m_cache;
                vector<CFontCacheEntry>         m_fontEntries;
                MUTEX                                           m_cacheMutex;
                unsigned long                           m_checkvalue;           // holds checkvalue of installed font filenames
                unsigned long                           m_version;                      // font cache version number, triggers recaching when mismatched
                bool                                            m_diskCacheOld;
                std::wstring                            m_fontCachePath;

                static void Destroy() {
                        delete m_pInstance; 
                };

                static bool                                     m_cacheLoaded;
                static CFontCache*                      m_pInstance;
                static MUTEX                            m_mutex;
        };
}

#endif // LST_FONTCACHE_H__INCLUDED_