/* -*- Mode: C++; c-default-style: "k&r"; indent-tabs-mode: nil; tab-width: 2; c-basic-offset: 2 -*- */

/* libmwaw

* Version: MPL 2.0 / LGPLv2+

*

* The contents of this file are subject to the Mozilla Public License Version

* 2.0 (the "License"); you may not use this file except in compliance with

* the License or as specified alternatively below. 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.

*

* Major Contributor(s):

* Copyright (C) 2002 William Lachance (wrlach@gmail.com)

* Copyright (C) 2002,2004 Marc Maurer (uwog@uwog.net)

* Copyright (C) 2004-2006 Fridrich Strba (fridrich.strba@bluewin.ch)

* Copyright (C) 2006, 2007 Andrew Ziem

* Copyright (C) 2011, 2012 Alonso Laurent (alonso@loria.fr)

*

*

* All Rights Reserved.

*

* For minor contributions see the git repository.

*

* Alternatively, the contents of this file may be used under the terms of

* the GNU Lesser General Public License Version 2 or later (the "LGPLv2+"),

* in which case the provisions of the LGPLv2+ are applicable

* instead of those above.

*/

#include <iostream>

#include "libmwaw_internal.hxx"

#include "MWAWFontConverter.hxx"

#include "MWAWFontSJISConverter.hxx"

//! Internal namespace used to store the data used by MWAWFontConverterInternal

namespace MWAWFontConverterInternal

{

//! Internal and low level: tools to convert Macintosh characters

namespace Data

{

//! Internal and low level: a class to store a conversion map for character, ...

struct ConversionData {

  //! constructor

  explicit ConversionData(std::map<unsigned char, unsigned long> &map,

                          char const *odtName="", int delta=0)

    : m_encoding(MWAWFontConverter::E_DEFAULT)

    , m_conversion(map)

    , m_name(odtName)

    , m_deltaSize(delta)

  {

  }

  //! constructor for different encoding

  ConversionData(std::map<unsigned char, unsigned long> &map, MWAWFontConverter::Encoding encoding, char const *odtName="", int delta=0)

    : m_encoding(encoding)

    , m_conversion(map)

    , m_name(odtName)

    , m_deltaSize(delta)

  {

  }

  //! the character encoding

  MWAWFontConverter::Encoding m_encoding;

  //! the conversion map character -> unicode

  std::map<unsigned char, unsigned long> &m_conversion;

  //! the odt font name (if empty used the name)

  std::string m_name;

  //! the size delta: odtSize = fSize + deltaSize

  int m_deltaSize;

};

// Courtesy of unicode.org: http://unicode.org/Public/MAPPINGS/VENDORS/APPLE/ROMAN.TXT

//! Internal and Low level: vector ( char, unicode) for roman font

static int const s_romanUnicode [] = {

  0x20,0x0020,  0x21,0x0021,  0x22,0x0022,  0x23,0x0023,  0x24,0x0024,

  0x25,0x0025,  0x26,0x0026,  0x27,0x0027,  0x28,0x0028,  0x29,0x0029,

  0x2A,0x002A,  0x2B,0x002B,  0x2C,0x002C,  0x2D,0x002D,  0x2E,0x002E,

  0x2F,0x002F,  0x30,0x0030,  0x31,0x0031,  0x32,0x0032,  0x33,0x0033,

  0x34,0x0034,  0x35,0x0035,  0x36,0x0036,  0x37,0x0037,  0x38,0x0038,

  0x39,0x0039,  0x3A,0x003A,  0x3B,0x003B,  0x3C,0x003C,  0x3D,0x003D,

  0x3E,0x003E,  0x3F,0x003F,  0x40,0x0040,  0x41,0x0041,  0x42,0x0042,

  0x43,0x0043,  0x44,0x0044,  0x45,0x0045,  0x46,0x0046,  0x47,0x0047,

  0x48,0x0048,  0x49,0x0049,  0x4A,0x004A,  0x4B,0x004B,  0x4C,0x004C,

  0x4D,0x004D,  0x4E,0x004E,  0x4F,0x004F,  0x50,0x0050,  0x51,0x0051,

  0x52,0x0052,  0x53,0x0053,  0x54,0x0054,  0x55,0x0055,  0x56,0x0056,

  0x57,0x0057,  0x58,0x0058,  0x59,0x0059,  0x5A,0x005A,  0x5B,0x005B,

// in icelandic : 5f='|o'

// in czech : 5f='s' (final 's' or begin word letter 'z')

  0x5C,0x005C,  0x5D,0x005D,  0x5E,0x005E,  0x5F,0x005F,  0x60,0x0060,

  0x61,0x0061,  0x62,0x0062,  0x63,0x0063,  0x64,0x0064,  0x65,0x0065,

  0x66,0x0066,  0x67,0x0067,  0x68,0x0068,  0x69,0x0069,  0x6A,0x006A,

  0x6B,0x006B,  0x6C,0x006C,  0x6D,0x006D,  0x6E,0x006E,  0x6F,0x006F,

  0x70,0x0070,  0x71,0x0071,  0x72,0x0072,  0x73,0x0073,  0x74,0x0074,

  0x75,0x0075,  0x76,0x0076,  0x77,0x0077,  0x78,0x0078,  0x79,0x0079,

  0x7A,0x007A,  0x7B,0x007B,  0x7C,0x007C,  0x7D,0x007D,  0x7E,0x007E,

  0x7F,0x007F,  0x80,0x00C4,  0x81,0x00C5,  0x82,0x00C7,  0x83,0x00C9,

  0x84,0x00D1,  0x85,0x00D6,  0x86,0x00DC,  0x87,0x00E1,  0x88,0x00E0,

  0x89,0x00E2,  0x8A,0x00E4,  0x8B,0x00E3,  0x8C,0x00E5,  0x8D,0x00E7,

  0x8E,0x00E9,  0x8F,0x00E8,  0x90,0x00EA,  0x91,0x00EB,  0x92,0x00ED,

  0x93,0x00EC,  0x94,0x00EE,  0x95,0x00EF,  0x96,0x00F1,  0x97,0x00F3,

  0x98,0x00F2,  0x99,0x00F4,  0x9A,0x00F6,  0x9B,0x00F5,  0x9C,0x00FA,

  0x9D,0x00F9,  0x9E,0x00FB,  0x9F,0x00FC,  0xA0,0x2020,  0xA1,0x00B0,

  0xA2,0x00A2,  0xA3,0x00A3,  0xA4,0x00A7,  0xA5,0x2022,  0xA6,0x00B6,

  0xA7,0x00DF,  0xA8,0x00AE,  0xA9,0x00A9,  0xAA,0x2122,  0xAB,0x00B4,

  0xAC,0x00A8,  0xAD,0x2260,  0xAE,0x00C6,  0xAF,0x00D8,  0xB0,0x221E,

  0xB1,0x00B1,  0xB2,0x2264,  0xB3,0x2265,  0xB4,0x00A5,  0xB5,0x00B5,

  0xB6,0x2202,  0xB7,0x2211,  0xB8,0x220F,  0xB9,0x03C0,  0xBA,0x222B,

  0xBB,0x00AA,  0xBC,0x00BA,  0xBD,0x03A9,  0xBE,0x00E6,  0xBF,0x00F8,

  0xC0,0x00BF,  0xC1,0x00A1,  0xC2,0x00AC,  0xC3,0x221A,  0xC4,0x0192,

  0xC5,0x2248,  0xC6,0x2206,  0xC7,0x00AB,  0xC8,0x00BB,  0xC9,0x2026,

  0xCA,0x00A0,  0xCB,0x00C0,  0xCC,0x00C3,  0xCD,0x00D5,  0xCE,0x0152,

  0xCF,0x0153,  0xD0,0x2013,  0xD1,0x2014,  0xD2,0x201C,  0xD3,0x201D,

  0xD4,0x2018,  0xD5,0x2019,  0xD6,0x00F7,  0xD7,0x25CA,  0xD8,0x00FF,

  0xD9,0x0178,  0xDA,0x2044,  0xDB,0x20AC,  0xDC,0x2039,  0xDD,0x203A,

  0xDE,0xFB01,  0xDF,0xFB02,  0xE0,0x2021,  0xE1,0x00B7,  0xE2,0x201A,

// E6 = non breaking space (instead of 0x00CA) ?

  0xE3,0x201E,  0xE4,0x2030,  0xE5,0x00C2,  0xE6,0x00CA,  0xE7,0x00C1,

  0xE8,0x00CB,  0xE9,0x00C8,  0xEA,0x00CD,  0xEB,0x00CE,  0xEC,0x00CF,

  0xED,0x00CC,  0xEE,0x00D3,  0xEF,0x00D4,  0xF0,0xF8FF,  0xF1,0x00D2,

  0xF2,0x00DA,  0xF3,0x00DB,  0xF4,0x00D9,  0xF5,0x0131,  0xF6,0x02C6,

  0xF7,0x02DC,  0xF8,0x00AF,  0xF9,0x02D8,  0xFA,0x02D9,  0xFB,0x02DA,

  0xFC,0x00B8,  0xFD,0x02DD,  0xFE,0x02DB,  0xFF,0x02C7

};

// Courtesy of unicode.org: http://unicode.org/Public/MAPPINGS/VENDORS/APPLE/CENTEURO.TXT

//! Internal and Low level: vector (char, unicode) for Central european font

static int const s_centralEuroUnicode[] = {

  0x20,0x0020, 0x21,0x0021, 0x22,0x0022, 0x23,0x0023, 0x24,0x0024, 0x25,0x0025, 0x26,0x0026, 0x27,0x0027,

  0x28,0x0028, 0x29,0x0029, 0x2A,0x002A, 0x2B,0x002B, 0x2C,0x002C, 0x2D,0x002D, 0x2E,0x002E, 0x2F,0x002F,

  0x30,0x0030, 0x31,0x0031, 0x32,0x0032, 0x33,0x0033, 0x34,0x0034, 0x35,0x0035, 0x36,0x0036, 0x37,0x0037,

  0x38,0x0038, 0x39,0x0039, 0x3A,0x003A, 0x3B,0x003B, 0x3C,0x003C, 0x3D,0x003D, 0x3E,0x003E, 0x3F,0x003F,

  0x40,0x0040, 0x41,0x0041, 0x42,0x0042, 0x43,0x0043, 0x44,0x0044, 0x45,0x0045, 0x46,0x0046, 0x47,0x0047,

  0x48,0x0048, 0x49,0x0049, 0x4A,0x004A, 0x4B,0x004B, 0x4C,0x004C, 0x4D,0x004D, 0x4E,0x004E, 0x4F,0x004F,

  0x50,0x0050, 0x51,0x0051, 0x52,0x0052, 0x53,0x0053, 0x54,0x0054, 0x55,0x0055, 0x56,0x0056, 0x57,0x0057,

  0x58,0x0058, 0x59,0x0059, 0x5A,0x005A, 0x5B,0x005B, 0x5C,0x005C, 0x5D,0x005D, 0x5E,0x005E, 0x5F,0x005F,

  0x60,0x0060, 0x61,0x0061, 0x62,0x0062, 0x63,0x0063, 0x64,0x0064, 0x65,0x0065, 0x66,0x0066, 0x67,0x0067,

  0x68,0x0068, 0x69,0x0069, 0x6A,0x006A, 0x6B,0x006B, 0x6C,0x006C, 0x6D,0x006D, 0x6E,0x006E, 0x6F,0x006F,

  0x70,0x0070, 0x71,0x0071, 0x72,0x0072, 0x73,0x0073, 0x74,0x0074, 0x75,0x0075, 0x76,0x0076, 0x77,0x0077,

  0x78,0x0078, 0x79,0x0079, 0x7A,0x007A, 0x7B,0x007B, 0x7C,0x007C, 0x7D,0x007D, 0x7E,0x007E,

  0x80,0x00C4, 0x81,0x0100, 0x82,0x0101, 0x83,0x00C9, 0x84,0x0104, 0x85,0x00D6, 0x86,0x00DC, 0x87,0x00E1,

  0x88,0x0105, 0x89,0x010C, 0x8A,0x00E4, 0x8B,0x010D, 0x8C,0x0106, 0x8D,0x0107, 0x8E,0x00E9, 0x8F,0x0179,

  0x90,0x017A, 0x91,0x010E, 0x92,0x00ED, 0x93,0x010F, 0x94,0x0112, 0x95,0x0113, 0x96,0x0116, 0x97,0x00F3,

  0x98,0x0117, 0x99,0x00F4, 0x9A,0x00F6, 0x9B,0x00F5, 0x9C,0x00FA, 0x9D,0x011A, 0x9E,0x011B, 0x9F,0x00FC,

  0xA0,0x2020, 0xA1,0x00B0, 0xA2,0x0118, 0xA3,0x00A3, 0xA4,0x00A7, 0xA5,0x2022, 0xA6,0x00B6, 0xA7,0x00DF,

  0xA8,0x00AE, 0xA9,0x00A9, 0xAA,0x2122, 0xAB,0x0119, 0xAC,0x00A8, 0xAD,0x2260, 0xAE,0x0123, 0xAF,0x012E,

  0xB0,0x012F, 0xB1,0x012A, 0xB2,0x2264, 0xB3,0x2265, 0xB4,0x012B, 0xB5,0x0136, 0xB6,0x2202, 0xB7,0x2211,

  0xB8,0x0142, 0xB9,0x013B, 0xBA,0x013C, 0xBB,0x013D, 0xBC,0x013E, 0xBD,0x0139, 0xBE,0x013A, 0xBF,0x0145,

  0xC0,0x0146, 0xC1,0x0143, 0xC2,0x00AC, 0xC3,0x221A, 0xC4,0x0144, 0xC5,0x0147, 0xC6,0x2206, 0xC7,0x00AB,

  0xC8,0x00BB, 0xC9,0x2026, 0xCA,0x00A0, 0xCB,0x0148, 0xCC,0x0150, 0xCD,0x00D5, 0xCE,0x0151, 0xCF,0x014C,

  0xD0,0x2013, 0xD1,0x2014, 0xD2,0x201C, 0xD3,0x201D, 0xD4,0x2018, 0xD5,0x2019, 0xD6,0x00F7, 0xD7,0x25CA,

  0xD8,0x014D, 0xD9,0x0154, 0xDA,0x0155, 0xDB,0x0158, 0xDC,0x2039, 0xDD,0x203A, 0xDE,0x0159, 0xDF,0x0156,

  0xE0,0x0157, 0xE1,0x0160, 0xE2,0x201A, 0xE3,0x201E, 0xE4,0x0161, 0xE5,0x015A, 0xE6,0x015B, 0xE7,0x00C1,

  0xE8,0x0164, 0xE9,0x0165, 0xEA,0x00CD, 0xEB,0x017D, 0xEC,0x017E, 0xED,0x016A, 0xEE,0x00D3, 0xEF,0x00D4,

  0xF0,0x016B, 0xF1,0x016E, 0xF2,0x00DA, 0xF3,0x016F, 0xF4,0x0170, 0xF5,0x0171, 0xF6,0x0172, 0xF7,0x0173,

  0xF8,0x00DD, 0xF9,0x00FD, 0xFA,0x0137, 0xFB,0x017B, 0xFC,0x0141, 0xFD,0x017C, 0xFE,0x0122, 0xFF,0x02C7,

};

// Courtesy of unicode.org: http://unicode.org/Public/MAPPINGS/VENDORS/APPLE/CYRILLIC.TXT

//! Internal and Low level: vector (char, unicode) for Cyrillic font

static int const s_cyrillicUnicode[] = {

  0x20,0x0020, 0x21,0x0021, 0x22,0x0022, 0x23,0x0023, 0x24,0x0024, 0x25,0x0025, 0x26,0x0026, 0x27,0x0027,

  0x28,0x0028, 0x29,0x0029, 0x2A,0x002A, 0x2B,0x002B, 0x2C,0x002C, 0x2D,0x002D, 0x2E,0x002E, 0x2F,0x002F,

  0x30,0x0030, 0x31,0x0031, 0x32,0x0032, 0x33,0x0033, 0x34,0x0034, 0x35,0x0035, 0x36,0x0036, 0x37,0x0037,

  0x38,0x0038, 0x39,0x0039, 0x3A,0x003A, 0x3B,0x003B, 0x3C,0x003C, 0x3D,0x003D, 0x3E,0x003E, 0x3F,0x003F,

  0x40,0x0040, 0x41,0x0041, 0x42,0x0042, 0x43,0x0043, 0x44,0x0044, 0x45,0x0045, 0x46,0x0046, 0x47,0x0047,

  0x48,0x0048, 0x49,0x0049, 0x4A,0x004A, 0x4B,0x004B, 0x4C,0x004C, 0x4D,0x004D, 0x4E,0x004E, 0x4F,0x004F,

  0x50,0x0050, 0x51,0x0051, 0x52,0x0052, 0x53,0x0053, 0x54,0x0054, 0x55,0x0055, 0x56,0x0056, 0x57,0x0057,

  0x58,0x0058, 0x59,0x0059, 0x5A,0x005A, 0x5B,0x005B, 0x5C,0x005C, 0x5D,0x005D, 0x5E,0x005E, 0x5F,0x005F,

  0x60,0x0060, 0x61,0x0061, 0x62,0x0062, 0x63,0x0063, 0x64,0x0064, 0x65,0x0065, 0x66,0x0066, 0x67,0x0067,

  0x68,0x0068, 0x69,0x0069, 0x6A,0x006A, 0x6B,0x006B, 0x6C,0x006C, 0x6D,0x006D, 0x6E,0x006E, 0x6F,0x006F,

  0x70,0x0070, 0x71,0x0071, 0x72,0x0072, 0x73,0x0073, 0x74,0x0074, 0x75,0x0075, 0x76,0x0076, 0x77,0x0077,

  0x78,0x0078, 0x79,0x0079, 0x7A,0x007A, 0x7B,0x007B, 0x7C,0x007C, 0x7D,0x007D, 0x7E,0x007E,

  0x80,0x0410, 0x81,0x0411, 0x82,0x0412, 0x83,0x0413, 0x84,0x0414, 0x85,0x0415, 0x86,0x0416, 0x87,0x0417,

  0x88,0x0418, 0x89,0x0419, 0x8A,0x041A, 0x8B,0x041B, 0x8C,0x041C, 0x8D,0x041D, 0x8E,0x041E, 0x8F,0x041F,

  0x90,0x0420, 0x91,0x0421, 0x92,0x0422, 0x93,0x0423, 0x94,0x0424, 0x95,0x0425, 0x96,0x0426, 0x97,0x0427,

  0x98,0x0428, 0x99,0x0429, 0x9A,0x042A, 0x9B,0x042B, 0x9C,0x042C, 0x9D,0x042D, 0x9E,0x042E, 0x9F,0x042F,

  0xA0,0x2020, 0xA1,0x00B0, 0xA2,0x0490, 0xA3,0x00A3, 0xA4,0x00A7, 0xA5,0x2022, 0xA6,0x00B6, 0xA7,0x0406,

  0xA8,0x00AE, 0xA9,0x00A9, 0xAA,0x2122, 0xAB,0x0402, 0xAC,0x0452, 0xAD,0x2260, 0xAE,0x0403, 0xAF,0x0453,

  0xB0,0x221E, 0xB1,0x00B1, 0xB2,0x2264, 0xB3,0x2265, 0xB4,0x0456, 0xB5,0x00B5, 0xB6,0x0491, 0xB7,0x0408,

  0xB8,0x0404, 0xB9,0x0454, 0xBA,0x0407, 0xBB,0x0457, 0xBC,0x0409, 0xBD,0x0459, 0xBE,0x040A, 0xBF,0x045A,

  0xC0,0x0458, 0xC1,0x0405, 0xC2,0x00AC, 0xC3,0x221A, 0xC4,0x0192, 0xC5,0x2248, 0xC6,0x2206, 0xC7,0x00AB,

  0xC8,0x00BB, 0xC9,0x2026, 0xCA,0x00A0, 0xCB,0x040B, 0xCC,0x045B, 0xCD,0x040C, 0xCE,0x045C, 0xCF,0x0455,

  0xD0,0x2013, 0xD1,0x2014, 0xD2,0x201C, 0xD3,0x201D, 0xD4,0x2018, 0xD5,0x2019, 0xD6,0x00F7, 0xD7,0x201E,

  0xD8,0x040E, 0xD9,0x045E, 0xDA,0x040F, 0xDB,0x045F, 0xDC,0x2116, 0xDD,0x0401, 0xDE,0x0451, 0xDF,0x044F,

  0xE0,0x0430, 0xE1,0x0431, 0xE2,0x0432, 0xE3,0x0433, 0xE4,0x0434, 0xE5,0x0435, 0xE6,0x0436, 0xE7,0x0437,

  0xE8,0x0438, 0xE9,0x0439, 0xEA,0x043A, 0xEB,0x043B, 0xEC,0x043C, 0xED,0x043D, 0xEE,0x043E, 0xEF,0x043F,

  0xF0,0x0440, 0xF1,0x0441, 0xF2,0x0442, 0xF3,0x0443, 0xF4,0x0444, 0xF5,0x0445, 0xF6,0x0446, 0xF7,0x0447,

  0xF8,0x0448, 0xF9,0x0449, 0xFA,0x044A, 0xFB,0x044B, 0xFC,0x044C, 0xFD,0x044D, 0xFE,0x044E, 0xFF,0x20AC,

};

// Courtesy of unicode.org: http://unicode.org/Public/MAPPINGS/VENDORS/APPLE/TURKISH.TXT

//! Internal and Low level: vector (char, unicode) for Turkish font ( diff to mac roman)

static int const s_turkishUnicode[] = {

  0xda,0x11e, 0xdb,0x11f, 0xdc,0x130, 0xdd,0x131, 0xde,0x15e, 0xdf,0x15f, 0xf5,0xf8a0

};

// Courtesy of unicode.org: http://unicode.org/Public/MAPPINGS/VENDORS/APPLE/SYMBOL.TXT

//! Internal and Low level: vector (char, unicode) for symbol font

static int const s_symbolUnicode[] = {

  0x20,0x0020,  0x21,0x0021,  0x22,0x2200,  0x23,0x0023,  0x24,0x2203,

  0x25,0x0025,  0x26,0x0026,  0x27,0x220D,  0x28,0x0028,  0x29,0x0029,

  0x2A,0x2217,  0x2B,0x002B,  0x2C,0x002C,  0x2D,0x2212,  0x2E,0x002E,

  0x2F,0x002F,  0x30,0x0030,  0x31,0x0031,  0x32,0x0032,  0x33,0x0033,

  0x34,0x0034,  0x35,0x0035,  0x36,0x0036,  0x37,0x0037,  0x38,0x0038,

  0x39,0x0039,  0x3A,0x003A,  0x3B,0x003B,  0x3C,0x003C,  0x3D,0x003D,

  0x3E,0x003E,  0x3F,0x003F,  0x40,0x2245,  0x41,0x0391,  0x42,0x0392,

  0x43,0x03A7,  0x44,0x0394,  0x45,0x0395,  0x46,0x03A6,  0x47,0x0393,

  0x48,0x0397,  0x49,0x0399,  0x4A,0x03D1,  0x4B,0x039A,  0x4C,0x039B,

  0x4D,0x039C,  0x4E,0x039D,  0x4F,0x039F,  0x50,0x03A0,  0x51,0x0398,

  0x52,0x03A1,  0x53,0x03A3,  0x54,0x03A4,  0x55,0x03A5,  0x56,0x03C2,

  0x57,0x03A9,  0x58,0x039E,  0x59,0x03A8,  0x5A,0x0396,  0x5B,0x005B,

  0x5C,0x2234,  0x5D,0x005D,  0x5E,0x22A5,  0x5F,0x005F,  0x60,0xF8E5,

  0x61,0x03B1,  0x62,0x03B2,  0x63,0x03C7,  0x64,0x03B4,  0x65,0x03B5,

  0x66,0x03C6,  0x67,0x03B3,  0x68,0x03B7,  0x69,0x03B9,  0x6A,0x03D5,

  0x6B,0x03BA,  0x6C,0x03BB,  0x6D,0x03BC,  0x6E,0x03BD,  0x6F,0x03BF,

  0x70,0x03C0,  0x71,0x03B8,  0x72,0x03C1,  0x73,0x03C3,  0x74,0x03C4,

  0x75,0x03C5,  0x76,0x03D6,  0x77,0x03C9,  0x78,0x03BE,  0x79,0x03C8,

  0x7A,0x03B6,  0x7B,0x007B,  0x7C,0x007C,  0x7D,0x007D,  0x7E,0x223C,

  0xA0,0x20AC,  0xA1,0x03D2,  0xA2,0x2032,  0xA3,0x2264,  0xA4,0x2044,

  0xA5,0x221E,  0xA6,0x0192,  0xA7,0x2663,  0xA8,0x2666,  0xA9,0x2665,

  0xAA,0x2660,  0xAB,0x2194,  0xAC,0x2190,  0xAD,0x2191,  0xAE,0x2192,

  0xAF,0x2193,  0xB0,0x00B0,  0xB1,0x00B1,  0xB2,0x2033,  0xB3,0x2265,

  0xB4,0x00D7,  0xB5,0x221D,  0xB6,0x2202,  0xB7,0x2022,  0xB8,0x00F7,

  0xB9,0x2260,  0xBA,0x2261,  0xBB,0x2248,  0xBC,0x2026,  0xBD,0x23D0,

  0xBE,0x23AF,  0xBF,0x21B5,  0xC0,0x2135,  0xC1,0x2111,  0xC2,0x211C,

  0xC3,0x2118,  0xC4,0x2297,  0xC5,0x2295,  0xC6,0x2205,  0xC7,0x2229,

  0xC8,0x222A,  0xC9,0x2283,  0xCA,0x2287,  0xCB,0x2284,  0xCC,0x2282,

  0xCD,0x2286,  0xCE,0x2208,  0xCF,0x2209,  0xD0,0x2220,  0xD1,0x2207,

  0xD2,0x00AE,  0xD3,0x00A9,  0xD4,0x2122,  0xD5,0x220F,  0xD6,0x221A,

  0xD7,0x22C5,  0xD8,0x00AC,  0xD9,0x2227,  0xDA,0x2228,  0xDB,0x21D4,

  0xDC,0x21D0,  0xDD,0x21D1,  0xDE,0x21D2,  0xDF,0x21D3,  0xE0,0x25CA,

  0xE1,0x3008,  0xE2,0x00AE,  0xE3,0x00A9,  0xE4,0x2122,  0xE5,0x2211,

  0xE6,0x239B,  0xE7,0x239C,  0xE8,0x239D,  0xE9,0x23A1,  0xEA,0x23A2,

  0xEB,0x23A3,  0xEC,0x23A7,  0xED,0x23A8,  0xEE,0x23A9,  0xEF,0x23AA,

  0xF0,0xF8FF,  0xF1,0x3009,  0xF2,0x222B,  0xF3,0x2320,  0xF4,0x23AE,

  0xF5,0x2321,  0xF6,0x239E,  0xF7,0x239F,  0xF8,0x23A0,  0xF9,0x23A4,

  0xFA,0x23A5,  0xFB,0x23A6,  0xFC,0x23AB,  0xFD,0x23AC,  0xFE,0x23AD

};

// Courtesy of unicode.org: http://unicode.org/Public/MAPPINGS/VENDORS/APPLE/DINGBATS.TXT

//! Internal and Low level: vector (char, unicode) for dingbats font

static int const s_dingbatsUnicode[] = {

  0x20,0x0020,  0x21,0x2701,  0x22,0x2702,  0x23,0x2703,  0x24,0x2704,

  0x25,0x260E,  0x26,0x2706,  0x27,0x2707,  0x28,0x2708,  0x29,0x2709,

  0x2A,0x261B,  0x2B,0x261E,  0x2C,0x270C,  0x2D,0x270D,  0x2E,0x270E,

  0x2F,0x270F,  0x30,0x2710,  0x31,0x2711,  0x32,0x2712,  0x33,0x2713,

  0x34,0x2714,  0x35,0x2715,  0x36,0x2716,  0x37,0x2717,  0x38,0x2718,

  0x39,0x2719,  0x3A,0x271A,  0x3B,0x271B,  0x3C,0x271C,  0x3D,0x271D,

  0x3E,0x271E,  0x3F,0x271F,  0x40,0x2720,  0x41,0x2721,  0x42,0x2722,

  0x43,0x2723,  0x44,0x2724,  0x45,0x2725,  0x46,0x2726,  0x47,0x2727,

  0x48,0x2605,  0x49,0x2729,  0x4A,0x272A,  0x4B,0x272B,  0x4C,0x272C,

  0x4D,0x272D,  0x4E,0x272E,  0x4F,0x272F,  0x50,0x2730,  0x51,0x2731,

  0x52,0x2732,  0x53,0x2733,  0x54,0x2734,  0x55,0x2735,  0x56,0x2736,

  0x57,0x2737,  0x58,0x2738,  0x59,0x2739,  0x5A,0x273A,  0x5B,0x273B,

  0x5C,0x273C,  0x5D,0x273D,  0x5E,0x273E,  0x5F,0x273F,  0x60,0x2740,

  0x61,0x2741,  0x62,0x2742,  0x63,0x2743,  0x64,0x2744,  0x65,0x2745,

  0x66,0x2746,  0x67,0x2747,  0x68,0x2748,  0x69,0x2749,  0x6A,0x274A,

  0x6B,0x274B,  0x6C,0x25CF,  0x6D,0x274D,  0x6E,0x25A0,  0x6F,0x274F,

  0x70,0x2750,  0x71,0x2751,  0x72,0x2752,  0x73,0x25B2,  0x74,0x25BC,

  0x75,0x25C6,  0x76,0x2756,  0x77,0x25D7,  0x78,0x2758,  0x79,0x2759,

  0x7A,0x275A,  0x7B,0x275B,  0x7C,0x275C,  0x7D,0x275D,  0x7E,0x275E,

  0x80,0x2768,  0x81,0x2769,  0x82,0x276A,  0x83,0x276B,  0x84,0x276C,

  0x85,0x276D,  0x86,0x276E,  0x87,0x276F,  0x88,0x2770,  0x89,0x2771,

  0x8A,0x2772,  0x8B,0x2773,  0x8C,0x2774,  0x8D,0x2775,  0xA1,0x2761,

  0xA2,0x2762,  0xA3,0x2763,  0xA4,0x2764,  0xA5,0x2765,  0xA6,0x2766,

  0xA7,0x2767,  0xA8,0x2663,  0xA9,0x2666,  0xAA,0x2665,  0xAB,0x2660,

  0xAC,0x2460,  0xAD,0x2461,  0xAE,0x2462,  0xAF,0x2463,  0xB0,0x2464,

  0xB1,0x2465,  0xB2,0x2466,  0xB3,0x2467,  0xB4,0x2468,  0xB5,0x2469,

  0xB6,0x2776,  0xB7,0x2777,  0xB8,0x2778,  0xB9,0x2779,  0xBA,0x277A,

  0xBB,0x277B,  0xBC,0x277C,  0xBD,0x277D,  0xBE,0x277E,  0xBF,0x277F,

  0xC0,0x2780,  0xC1,0x2781,  0xC2,0x2782,  0xC3,0x2783,  0xC4,0x2784,

  0xC5,0x2785,  0xC6,0x2786,  0xC7,0x2787,  0xC8,0x2788,  0xC9,0x2789,

  0xCA,0x278A,  0xCB,0x278B,  0xCC,0x278C,  0xCD,0x278D,  0xCE,0x278E,

  0xCF,0x278F,  0xD0,0x2790,  0xD1,0x2791,  0xD2,0x2792,  0xD3,0x2793,

  0xD4,0x2794,  0xD5,0x2192,  0xD6,0x2194,  0xD7,0x2195,  0xD8,0x2798,

  0xD9,0x2799,  0xDA,0x279A,  0xDB,0x279B,  0xDC,0x279C,  0xDD,0x279D,

  0xDE,0x279E,  0xDF,0x279F,  0xE0,0x27A0,  0xE1,0x27A1,  0xE2,0x27A2,

  0xE3,0x27A3,  0xE4,0x27A4,  0xE5,0x27A5,  0xE6,0x27A6,  0xE7,0x27A7,

  0xE8,0x27A8,  0xE9,0x27A9,  0xEA,0x27AA,  0xEB,0x27AB,  0xEC,0x27AC,

  0xED,0x27AD,  0xEE,0x27AE,  0xEF,0x27AF,  0xF1,0x27B1,  0xF2,0x27B2,

  0xF3,0x27B3,  0xF4,0x27B4,  0xF5,0x27B5,  0xF6,0x27B6,  0xF7,0x27B7,

  0xF8,0x27B8,  0xF9,0x27B9,  0xFA,0x27BA,  0xFB,0x27BB,  0xFC,0x27BC,

  0xFD,0x27BD,  0xFE,0x27BE

};

//! Internal and Low level: vector (char, unicode) for Monotype Sorts font

static int const s_monotypeSortsUnicode[] = {

  0x20,0x20, 0x21,0x2701, 0x22,0x2700, 0x23,0x2703,

  0x24,0x2704, 0x25,0x260, 0x26,0x2706, 0x27,0x2622,

  0x28,0x2708, 0x29,0x2709, 0x2a,0x261b, 0x2b,0x261e,

  0x2c,0x270c, 0x2d,0x270d, 0x2e,0x270e, 0x2f,0x270f,

  0x30,0x2710, 0x31,0x2711, 0x32,0x2712, 0x33,0x2713,

  0x34,0x2714, 0x35,0x2715, 0x36,0x2716, 0x37,0x2717,

  0x38,0x2718, 0x39,0x2719, 0x3a,0x271a, 0x3b,0x271b,

  0x3c,0x271c, 0x3d,0x271d, 0x3e,0x271e, 0x3f,0x271f,

  0x40,0x2720, 0x41,0x2721, 0x42,0x2722, 0x43,0x2723,

  0x44,0x2724, 0x45,0x2725, 0x46,0x2726, 0x47,0x2727,

  0x48,0x2605, 0x49,0x2729, 0x4a,0x272a, 0x4b,0x272b,

  0x4c,0x272c, 0x4d,0x272d, 0x4e,0x272e, 0x4f,0x272f,

  0x50,0x2730, 0x51,0x2736, 0x52,0x2732, 0x53,0x2731,

  0x54,0x2731, 0x55,0x2735, 0x56,0x2736, 0x57,0x2737,

  0x58,0x2738, 0x59,0x2739, 0x5a,0x273a, 0x5b,0x273b,

  0x5c,0x273c, 0x5d,0x273d, 0x5e,0x273e, 0x5f,0x273f,

  0x60,0x2740, 0x61,0x2741, 0x62,0x2742, 0x63,0x2743,

  0x64,0x2744, 0x65,0x2745, 0x66,0x2746, 0x67,0x2747,

  0x68,0x2748, 0x69,0x2749, 0x6a,0x274a, 0x6b,0x274b,

  0x6c,0x25cf, 0x6d,0x25ef, 0x6e,0x2b1b, 0x6f,0x274f,

  0x70,0x2750, 0x71,0x2751, 0x72,0x2752, 0x73,0x25b2,

  0x74,0x25bc, 0x75,0x25c6, 0x76,0x2756, 0x77,0x25d7,

  0x78,0x2758, 0x79,0x2759, 0x7a,0x275a, 0x7b,0x275b,

  0x7c,0x275c, 0x7d,0x275d, 0x7e,0x275e,

  0x80,0x2768, 0x81,0x2769, 0x82,0x28, 0x83,0x29,

  0x84,0x2329, 0x85,0x232a, 0x86,0x27e8, 0x87,0x27e9,

  0x88,0x2770, 0x89,0x2771, 0x8a,0x5b, 0x8b,0x5d,

  0x8c,0x7b, 0x8d,0x7d,

  0xa1,0x2761, 0xa2,0x2762, 0xa3,0x2763,

  0xa4,0x2764, 0xa5,0x2765, 0xa6,0x2766, 0xa7,0x2767,

  0xa8,0x2663, 0xa9,0x2666, 0xaa,0x2665, 0xab,0x2660,

  0xac,0x2460, 0xad,0x2461, 0xae,0x2462, 0xaf,0x2463,

  0xb0,0x2464, 0xb1,0x2465, 0xb2,0x2466, 0xb3,0x2467,

  0xb4,0x2468, 0xb5,0x2469, 0xb6,0x2776, 0xb7,0x2777,

  0xb8,0x2778, 0xb9,0x2779, 0xba,0x277a, 0xbb,0x277b,

  0xbc,0x277c, 0xbd,0x277d, 0xbe,0x277e, 0xbf,0x277f,

  0xc0,0x2780, 0xc1,0x2781, 0xc2,0x2782, 0xc3,0x2783,

  0xc4,0x2784, 0xc5,0x2785, 0xc6,0x2786, 0xc7,0x2787,

  0xc8,0x2788, 0xc9,0x2789, 0xca,0x2776, 0xcb,0x2777,

  0xcc,0x2778, 0xcd,0x2779, 0xce,0x277a, 0xcf,0x277b,

  0xd0,0x277c, 0xd1,0x277d, 0xd2,0x277e, 0xd3,0x277f,

  0xd4,0x279c, 0xd5,0x2192, 0xd6,0x2194, 0xd7,0x2195,

  0xd8,0x2798, 0xd9,0x2799, 0xda,0x279a, 0xdb,0x279b,

  0xdc,0x279c, 0xdd,0x279d, 0xde,0x279e, 0xdf,0x279f,

  0xe0,0x27a0, 0xe1,0x27a1, 0xe2,0x27a2, 0xe3,0x27a3,

  0xe4,0x27a4, 0xe5,0x27a5, 0xe6,0x27a6, 0xe7,0x27a7,

  0xe8,0x27a8, 0xe9,0x27a9, 0xea,0x27aa, 0xeb,0x27ab,

  0xec,0x27ac, 0xed,0x27ad, 0xee,0x27ae, 0xef,0x27af,

  0xf1,0x27b1, 0xf2,0x27b2, 0xf3,0x27b3,

  0xf4,0x27b4, 0xf5,0x27b5, 0xf6,0x27b6, 0xf7,0x27b7,

  0xf8,0x27bc, 0xf9,0x27b9, 0xfa,0x27ba, 0xfb,0x27bb,

  0xfc,0x27bc, 0xfd,0x27bd, 0xfe,0x27be

};

// Courtesy of unicode.org: http://www.alanwood.net/demos/wingdings.html

//! Internal and Low level: vector (char, unicode) for wingdings font

static int const s_wingdingsUnicode[] = {

  0x20,0x0020,  0x21,0x270f,  0x22,0x2702,  0x23,0x2701,  0x24,0x1F453,

  0x25,0x1F514, 0x26,0x1F514, 0x27,0x2710/*candle*/, 0x28,0x260E, 0x29,0x2706,

  0x2A,0x2709,  0x2B,0x260E,  0x2C,0x1f4ea, 0x2D,0x1f4eb, 0x2E,0x1f4ec,

  0x2F,0x1f4ed, 0x30,0x1f4c1, 0x31,0x1f4c2, 0x32,0x1f4c4, 0x33,0x1f4c4,

  0x34,0x1f4c4, 0x35,0x25AF,  0x36,0x231B,  0x37,0x2328,  0x38,0x1F42F/*mouse*/,

  0x39,0x2328/*trackpad*/, 0x3A,0x1F4BB, 0x3B,0x2328/*harddisk*/, 0x3C,0x1F4BE,  0x3D,0x1F4BE,

  0x3E,0x2707,  0x3F,0x270D,  0x40,0x270D,  0x41,0x270c,  0x42,0x1F44C,

  0x43,0x1F44D, 0x44,0x1F44E, 0x45,0x261C,  0x46,0x261E,  0x47,0x261D,

  0x48,0x261F,  0x49,0x270B,  0x4A,0x263A,  0x4B,0x1F610, 0x4C,0x2639,

  0x4D,0x1F4A3, 0x4E,0x2620,  0x4F,0x2690,  0x50,0x1F6A9, 0x51,0x2708,

  0x52,0x263C,  0x53,0x1F4A7, 0x54,0x2744,  0x55,0x271E,  0x56,0x271E,

  0x57,0x271D,  0x58,0x2720,  0x59,0x2721,  0x5A,0x262a,  0x5B,0x262f,

  0x5C,0x0950,  0x5D,0x2638,  0x5E,0x2648,  0x5F,0x2649,  0x60,0x264a,

  0x61,0x264b,  0x62,0x264c,  0x63,0x264d,  0x64,0x264e,  0x65,0x264f,

  0x66,0x2650,  0x67,0x2651,  0x68,0x2652,  0x69,0x2653,  0x6A,0x0026,

  0x6B,0x0026,  0x6C,0x25CF,  0x6D,0x274D,  0x6E,0x25A0,  0x6F,0x27A1,

  0x70,0x2751,  0x71,0x2751,  0x72,0x2752,  0x73,0x2B27,  0x74,0x29EB,

  0x75,0x25C6,  0x76,0x2756,  0x77,0x2B25,  0x78,0x2327,  0x79,0x2353,

  0x7A,0x2318,  0x7B,0x2740,  0x7C,0x273F,  0x7D,0x275D,  0x7E,0x275E,

  0x7F,0x25AF,  0x80,0x24EA,  0x81,0x2460,  0x82,0x2461,  0x83,0x2462,

  0x84,0x2463,  0x85,0x2464,  0x86,0x2465,  0x87,0x2466,  0x88,0x2467,

  0x89,0x2468,  0x8A,0x2469,  0x8B,0x24FF,  0x8C,0x2776,  0x8D,0x2777,

  0x8E,0x2778,  0x8F,0x2779,  0x90,0x277A,  0x91,0x277B,  0x92,0x277C,

  0x93,0x277D,  0x94,0x277E,  0x95,0x277F,

  0x96,0x269B,  0x97,0x269B,  0x98,0x269B,  0x99,0x269B,

  0x9a,0x269B,  0x9b,0x269B,  0x9c,0x269B,  0x9d,0x269B,  // bud and vine leaf

  0x9E,0x00B7,  0x9F,0x277F,  0xA0,0x25AA,  0xA1,0x25CB,  0xA2,0x2B55,

  0xA3,0x2B55,  0xA4,0x25C9,  0xA5,0x25CE,  0xA6,0x25CB,

  0xA7,0x25AA,  0xA8,0x25FB,  0xA9,0x2726,  0xAA,0x2726,  0xAB,0x2605,

  0xAC,0x2736,  0xAD,0x2734,  0xAE,0x2739,  0xAF,0x2735,  0xB0,0x2316,

  0xB1,0x2316,  0xB2,0x27E1,  0xB3,0x2311,  0xB4,0x27E1,  0xB5,0x25CB,/*clock*/

  0xB6,0x2730,  0xB7,0x1F550, 0xB8,0x1F551, 0xB9,0x1F552, 0xBA,0x1F553,

  0xBB,0x1F554, 0xBC,0x1F555, 0xBD,0x1F556, 0xBE,0x1F557, 0xBF,0x1F558,

  0xC0,0x1F559, 0xC1,0x1F55A, 0xC2,0x1F55B, 0xC3,0x21B5,  0xC4,0x21B3,

  0xC5,0x21B0,  0xC6,0x21B1,  0xC7,0x21BB,  0xC8,0x21BA,  0xC9,0x21BA,

  0xCA,0x21BB,  0xCB,0x2722,  0xCC,0x2722,

  0xCD,0x2743,  0xCE,0x2743,  0xCF,0x2743,  0xD0,0x2743,

  0xD1,0x2743,  0xD2,0x2743,  0xD3,0x2743,  0xD4,0x2743,  /* normally leaf...*/

  0xD5,0x232B,  0xD6,0x2326,  0xD7,0x21E6,  0xD8,0x27A2,

  0xD9,0x21E7,  0xDA,0x21E9,  0xDB,0x21E6,  0xDC,0x27B2,  0xDD,0x21E7,

  0xDE,0x21E9,  0xDF,0x21E6,  0xE0,0x21E8,  0xE1,0x21E7,  0xE2,0x21E9,

  0xE3,0x2B00,  0xE4,0x2B01,  0xE5,0x2B03,  0xE6,0x2B02,  0xE7,0x21E6,

  0xE8,0x2794,  0xE9,0x21E7,  0xEA,0x21E9,  0xEB,0x2B00,  0xEC,0x2B01,

  0xED,0x2B03,  0xEE,0x2B02,  0xEF,0x21E6,  0xF0,0x27E8,  0xF1,0x27E7,

  0xF2,0x21E9,

  0xF3,0x2B04,  0xF4,0x21F3,  0xF5,0x2B00,  0xF6,0x2B01,  0xF7,0x2B03,

  0xF8,0x2B02,  0xF9,0x25AD,  0xFA,0x25AB,  0xFB,0x2717,  0xFC,0x2713,

  0xFD,0x2612,  0xFE,0x2611

};

//

// For the next one, we stored only the "known" differences between roman and font

//

/** Internal and Low level: vector (char, unicode) for cursive font

\note only characters which differs from roman*/

static int const s_cursiveIncompleteUnicode[] = {

  0xa2,0xBC, 0xa3,0x2153, 0xa4,0x2159, 0xaa,0xBD, 0xc1,0x2154

  // 0x40, 0xB0: some number,

};

/** Internal and Low level: vector (char, unicode) for math font

\note only characters which differs from roman */

static int const s_mathIncompleteUnicode[] = {

  0x22,0x222A, 0x27,0x222A,  0x28,0x2229, 0x2b,0x2260, 0x31,0x2282,

  0x33,0x2227, 0x36,0x2A2F,  0x39,0x2282, 0x43,0x2102, 0x44,0x216E,

  0x47,0x0393, 0x49,0x2160,  0x4e,0x2115, 0x52,0x211D, 0x5a,0x2124,

  0x63,0x0255, 0x64,0x03B4,  0x65,0x212F, 0x68,0x210E, 0x70,0x01BF,

  0x76,0x2174

};

/** Internal and Low level: vector (char, unicode) for scientific font

\note only characters which differs from roman*/

static int const s_scientificIncompleteUnicode[] = {

  0x23,0x0394, 0x40,0x221A,  0x49,0x2160, 0x56,0x2164, 0x5c,0x007C,

  0x5b,0x2192, 0x5d,0x2192,  0x90,0x211D, 0x91,0x2192, 0xa7,0x03C3,

  0xa9,0x03B3, 0xab,0x03F5,  0xad,0x2260, 0xc3,0x03C8, 0xcf,0x03B8,

  0xd1,0x223C, 0xd4,0x2192,  0xe3,0x2009, 0xe8,0x00a0, 0xec,0x2303,

  0xee,0x2227, 0xef,0x0305,  0xf2,0x2192

};

// other fonts with unknown names :

/** Internal and Low level: vector (char, unicode) for font 107

\note only characters which differs from roman */

static int const s_unknown107IncompleteUnicode[] = {

  0x76,0x221a

};

/** Internal and Low level: vector (char, unicode) for font 128

\note only characters which differs from roman*/

static int const s_unknown128IncompleteUnicode[] = {

  0x43,0x2102, 0x4e,0x2115, 0x52,0x211D, 0x61,0xFE3F, 0x76,0x2192

};

/** Internal and Low level: vector (char, unicode) for font 200

\note only characters which differs from roman */

static int const s_unknown200IncompleteUnicode[] = {

  0x76,0x2192, 0x77,0x2192, 0x61,0xFE3F

};

//! Internal and Low level: vector (char, unicode) for SJIS font (see MWAWFontSJISConverter )

static int const s_SJISSimplifiedUnicode[]= {

  0x20,0x0020, 0x21,0x0021, 0x22,0x0022, 0x23,0x0023, 0x24,0x0024, 0x25,0x0025, 0x26,0x0026, 0x27,0x0027,

  0x28,0x0028, 0x29,0x0029, 0x2A,0x002A, 0x2B,0x002B, 0x2C,0x002C, 0x2D,0x002D, 0x2E,0x002E, 0x2F,0x002F,

  0x30,0x0030, 0x31,0x0031, 0x32,0x0032, 0x33,0x0033, 0x34,0x0034, 0x35,0x0035, 0x36,0x0036, 0x37,0x0037,

  0x38,0x0038, 0x39,0x0039, 0x3A,0x003A, 0x3B,0x003B, 0x3C,0x003C, 0x3D,0x003D, 0x3E,0x003E, 0x3F,0x003F,

  0x40,0x0040, 0x41,0x0041, 0x42,0x0042, 0x43,0x0043, 0x44,0x0044, 0x45,0x0045, 0x46,0x0046, 0x47,0x0047,

  0x48,0x0048, 0x49,0x0049, 0x4A,0x004A, 0x4B,0x004B, 0x4C,0x004C, 0x4D,0x004D, 0x4E,0x004E, 0x4F,0x004F,

  0x50,0x0050, 0x51,0x0051, 0x52,0x0052, 0x53,0x0053, 0x54,0x0054, 0x55,0x0055, 0x56,0x0056, 0x57,0x0057,

  0x58,0x0058, 0x59,0x0059, 0x5A,0x005A, 0x5B,0x005B, 0x5C,0x00A5, 0x5D,0x005D, 0x5E,0x005E, 0x5F,0x005F,

  0x60,0x0060, 0x61,0x0061, 0x62,0x0062, 0x63,0x0063, 0x64,0x0064, 0x65,0x0065, 0x66,0x0066, 0x67,0x0067,

  0x68,0x0068, 0x69,0x0069, 0x6A,0x006A, 0x6B,0x006B, 0x6C,0x006C, 0x6D,0x006D, 0x6E,0x006E, 0x6F,0x006F,

  0x70,0x0070, 0x71,0x0071, 0x72,0x0072, 0x73,0x0073, 0x74,0x0074, 0x75,0x0075, 0x76,0x0076, 0x77,0x0077,

  0x78,0x0078, 0x79,0x0079, 0x7A,0x007A, 0x7B,0x007B, 0x7C,0x007C, 0x7D,0x007D, 0x7E,0x203E, 0x7F,0x007F,

  0xA1,0xFF61, 0xA2,0xFF62, 0xA3,0xFF63, 0xA4,0xFF64, 0xA5,0xFF65, 0xA6,0xFF66, 0xA7,0xFF67, 0xA8,0xFF68,

  0xA9,0xFF69, 0xAA,0xFF6A, 0xAB,0xFF6B, 0xAC,0xFF6C, 0xAD,0xFF6D, 0xAE,0xFF6E, 0xAF,0xFF6F, 0xB0,0xFF70,

  0xB1,0xFF71, 0xB2,0xFF72, 0xB3,0xFF73, 0xB4,0xFF74, 0xB5,0xFF75, 0xB6,0xFF76, 0xB7,0xFF77, 0xB8,0xFF78,

  0xB9,0xFF79, 0xBA,0xFF7A, 0xBB,0xFF7B, 0xBC,0xFF7C, 0xBD,0xFF7D, 0xBE,0xFF7E, 0xBF,0xFF7F, 0xC0,0xFF80,

  0xC1,0xFF81, 0xC2,0xFF82, 0xC3,0xFF83, 0xC4,0xFF84, 0xC5,0xFF85, 0xC6,0xFF86, 0xC7,0xFF87, 0xC8,0xFF88,

  0xC9,0xFF89, 0xCA,0xFF8A, 0xCB,0xFF8B, 0xCC,0xFF8C, 0xCD,0xFF8D, 0xCE,0xFF8E, 0xCF,0xFF8F, 0xD0,0xFF90,

  0xD1,0xFF91, 0xD2,0xFF92, 0xD3,0xFF93, 0xD4,0xFF94, 0xD5,0xFF95, 0xD6,0xFF96, 0xD7,0xFF97, 0xD8,0xFF98,

  0xD9,0xFF99, 0xDA,0xFF9A, 0xDB,0xFF9B, 0xDC,0xFF9C, 0xDD,0xFF9D, 0xDE,0xFF9E, 0xDF,0xFF9F

};

//

// some pc encoding

//

//! Internal and Low Level: the Windows CP1250 encoding

static int const s_windowsCP1250Unicode[] = {

  0x80,0x20ac,0x82,0x201a,0x84,0x201e,0x85,0x2026,0x86,0x2020,0x87,0x2021,

  0x89,0x2030,0x8a,0x160,0x8b,0x2039,0x8c,0x15a,0x8d,0x164,0x8e,0x17d,0x8f,0x179,

  0x91,0x2018,0x92,0x2019,0x93,0x201c,0x94,0x201d,0x95,0x2022,0x96,0x2013,0x97,0x2014,

  0x99,0x2122,0x9a,0x161,0x9b,0x203a,0x9c,0x15b,0x9d,0x165,0x9e,0x17e,0x9f,0x17a,

  0xa1,0x2c7,0xa2,0x2d8,0xa3,0x141,0xa5,0x104,

  0xaa,0x15e,0xaf,0x17b,

  0xb2,0x2db,0xb3,0x142,

  0xb9,0x105,0xba,0x15f,0xbc,0x13d,0xbd,0x2dd,0xbe,0x13e,0xbf,0x17c,

  0xc0,0x154,0xc3,0x102,0xc5,0x139,0xc6,0x106,

  0xc8,0x10c,0xca,0x118,0xcc,0x11a,0xcf,0x10e,

  0xd0,0x110,0xd1,0x143,0xd2,0x147,0xd5,0x150,

  0xd8,0x158,0xd9,0x16e,0xdb,0x170,0xde,0x162,

  0xe0,0x155,0xe3,0x103,0xe5,0x13a,0xe6,0x107,

  0xe8,0x10d,0xea,0x119,0xec,0x11b,0xef,0x10f,

  0xf0,0x111,0xf1,0x144,0xf2,0x148,0xf5,0x151,

  0xf8,0x159,0xf9,0x16f,0xfb,0x171,0xfe,0x163,0xff,0x2d9

};

//! Internal and Low Level: the Windows CP1251 encoding

static int const s_windowsCP1251Unicode[] = {

  0x80,0x402, 0x81,0x403, 0x82,0x201a, 0x83,0x453, 0x84,0x201e, 0x85,0x2026, 0x86,0x2020, 0x87,0x2021,

  0x88,0x20ac, 0x89,0x2030, 0x8a,0x409, 0x8b,0x2039, 0x8c,0x40a, 0x8d,0x40c, 0x8e,0x40b, 0x8f,0x40f,

  0x90,0x452, 0x91,0x2018, 0x92,0x2019, 0x93,0x201c, 0x94,0x201d, 0x95,0x2022, 0x96,0x2013, 0x97,0x2014,

  0x99,0x2122, 0x9a,0x459, 0x9b,0x203a, 0x9c,0x45a, 0x9d,0x45c, 0x9e,0x45b, 0x9f,0x45f,

  0xa1,0x40e, 0xa2,0x45e, 0xa3,0x408, 0xa5,0x490,

  0xa8,0x401, 0xaa,0x404, 0xaf,0x407,

  0xb2,0x406, 0xb3,0x456, 0xb4,0x491,

  0xb8,0x451, 0xb9,0x2116, 0xba,0x454, 0xbc,0x458, 0xbd,0x405, 0xbe,0x455, 0xbf,0x457,

  0xc0,0x410, 0xc1,0x411, 0xc2,0x412, 0xc3,0x413, 0xc4,0x414, 0xc5,0x415, 0xc6,0x416, 0xc7,0x417,

  0xc8,0x418, 0xc9,0x419, 0xca,0x41a, 0xcb,0x41b, 0xcc,0x41c, 0xcd,0x41d, 0xce,0x41e, 0xcf,0x41f,

  0xd0,0x420, 0xd1,0x421, 0xd2,0x422, 0xd3,0x423, 0xd4,0x424, 0xd5,0x425, 0xd6,0x426, 0xd7,0x427,

  0xd8,0x428, 0xd9,0x429, 0xda,0x42a, 0xdb,0x42b, 0xdc,0x42c, 0xdd,0x42d, 0xde,0x42e, 0xdf,0x42f,

  0xe0,0x430, 0xe1,0x431, 0xe2,0x432, 0xe3,0x433, 0xe4,0x434, 0xe5,0x435, 0xe6,0x436, 0xe7,0x437,

  0xe8,0x438, 0xe9,0x439, 0xea,0x43a, 0xeb,0x43b, 0xec,0x43c, 0xed,0x43d, 0xee,0x43e, 0xef,0x43f,

  0xf0,0x440, 0xf1,0x441, 0xf2,0x442, 0xf3,0x443, 0xf4,0x444, 0xf5,0x445, 0xf6,0x446, 0xf7,0x447,

  0xf8,0x448, 0xf9,0x449, 0xfa,0x44a, 0xfb,0x44b, 0xfc,0x44c, 0xfd,0x44d, 0xfe,0x44e, 0xff,0x44f

};

//! Internal and Low Level: the Windows CP1252 encoding

static int const s_windowsCP1252Unicode[] = {

  0x80,0x20ac, 0x82,0x201a, 0x83,0x0192, 0x84,0x201e, 0x85,0x2026, 0x86,0x2020, 0x87,0x2021,

  0x88,0x02c6, 0x89,0x2030, 0x8a,0x0160, 0x8b,0x2039, 0x8c,0x0152, 0x8e,0x017d,

  0x91,0x2018, 0x92,0x2019, 0x93,0x201c, 0x94,0x201d, 0x95,0x2022, 0x96,0x2013, 0x97,0x2014,

  0x98,0x02dc, 0x99,0x2122, 0x9a,0x0161, 0x9b,0x203a, 0x9c,0x0153, 0x9e,0x017e, 0x9f,0x0178

};

//! Internal and Low Level: the Windows CP1253 encoding

static int const s_windowsCP1253Unicode[] = {

  0x80,0x20ac, 0x82,0x201a, 0x83,0x192, 0x84,0x201e, 0x85,0x2026, 0x86,0x2020, 0x87,0x2021,

  0x89,0x2030, 0x8b,0x2039,

  0x91,0x2018, 0x92,0x2019, 0x93,0x201c, 0x94,0x201d, 0x95,0x2022, 0x96,0x2013, 0x97,0x2014,

  0x99,0x2122, 0x9b,0x203a,

  0xa1,0x385, 0xa2,0x386,

  0xaf,0x2015,

  0xb4,0x384,

  0xb8,0x388, 0xb9,0x389, 0xba,0x38a, 0xbc,0x38c, 0xbe,0x38e, 0xbf,0x38f,

  0xc0,0x390, 0xc1,0x391, 0xc2,0x392, 0xc3,0x393, 0xc4,0x394, 0xc5,0x395, 0xc6,0x396, 0xc7,0x397,

  0xc8,0x398, 0xc9,0x399, 0xca,0x39a, 0xcb,0x39b, 0xcc,0x39c, 0xcd,0x39d, 0xce,0x39e, 0xcf,0x39f,

  0xd0,0x3a0, 0xd1,0x3a1, 0xd3,0x3a3, 0xd4,0x3a4, 0xd5,0x3a5, 0xd6,0x3a6, 0xd7,0x3a7,

  0xd8,0x3a8, 0xd9,0x3a9, 0xda,0x3aa, 0xdb,0x3ab, 0xdc,0x3ac, 0xdd,0x3ad, 0xde,0x3ae, 0xdf,0x3af,

  0xe0,0x3b0, 0xe1,0x3b1, 0xe2,0x3b2, 0xe3,0x3b3, 0xe4,0x3b4, 0xe5,0x3b5, 0xe6,0x3b6, 0xe7,0x3b7,

  0xe8,0x3b8, 0xe9,0x3b9, 0xea,0x3ba, 0xeb,0x3bb, 0xec,0x3bc, 0xed,0x3bd, 0xee,0x3be, 0xef,0x3bf,

  0xf0,0x3c0, 0xf1,0x3c1, 0xf2,0x3c2, 0xf3,0x3c3, 0xf4,0x3c4, 0xf5,0x3c5, 0xf6,0x3c6, 0xf7,0x3c7,

  0xf8,0x3c8, 0xf9,0x3c9, 0xfa,0x3ca, 0xfb,0x3cb, 0xfc,0x3cc, 0xfd,0x3cd, 0xfe,0x3ce

};

//! Internal and Low Level: the Windows CP1254 encoding

static int const s_windowsCP1254Unicode[] = {

  0x80,0x20ac, 0x82,0x201a, 0x83,0x192, 0x84,0x201e, 0x85,0x2026, 0x86,0x2020, 0x87,0x2021,

  0x88,0x2c6, 0x89,0x2030, 0x8a,0x160, 0x8b,0x2039, 0x8c,0x152,

  0x91,0x2018, 0x92,0x2019, 0x93,0x201c, 0x94,0x201d, 0x95,0x2022, 0x96,0x2013, 0x97,0x2014,

  0x98,0x2dc, 0x99,0x2122, 0x9a,0x161, 0x9b,0x203a, 0x9c,0x153, 0x9f,0x178,

  0xd0,0x11e,

  0xdd,0x130, 0xde,0x15e,

  0xf0,0x11f,

  0xfd,0x131, 0xfe,0x15f

};

//! Internal and Low Level: the Windows CP1255 encoding

static int const s_windowsCP1255Unicode[] = {

  0x80,0x20ac, 0x82,0x201a, 0x83,0x192, 0x84,0x201e, 0x85,0x2026, 0x86,0x2020, 0x87,0x2021,

  0x88,0x2c6, 0x89,0x2030, 0x8b,0x2039,

  0x91,0x2018, 0x92,0x2019, 0x93,0x201c, 0x94,0x201d, 0x95,0x2022, 0x96,0x2013, 0x97,0x2014,

  0x98,0x2dc, 0x99,0x2122, 0x9b,0x203a,

  0xa4,0x20aa,

  0xaa,0xd7,

  0xba,0xf7,

  0xc0,0x5b0, 0xc1,0x5b1, 0xc2,0x5b2, 0xc3,0x5b3, 0xc4,0x5b4, 0xc5,0x5b5, 0xc6,0x5b6, 0xc7,0x5b7,

  0xc8,0x5b8, 0xc9,0x5b9, 0xcb,0x5bb, 0xcc,0x5bc, 0xcd,0x5bd, 0xce,0x5be, 0xcf,0x5bf,

  0xd0,0x5c0, 0xd1,0x5c1, 0xd2,0x5c2, 0xd3,0x5c3, 0xd4,0x5f0, 0xd5,0x5f1, 0xd6,0x5f2, 0xd7,0x5f3,

  0xd8,0x5f4,

  0xe0,0x5d0, 0xe1,0x5d1, 0xe2,0x5d2, 0xe3,0x5d3, 0xe4,0x5d4, 0xe5,0x5d5, 0xe6,0x5d6, 0xe7,0x5d7,

  0xe8,0x5d8, 0xe9,0x5d9, 0xea,0x5da, 0xeb,0x5db, 0xec,0x5dc, 0xed,0x5dd, 0xee,0x5de, 0xef,0x5df,

  0xf0,0x5e0, 0xf1,0x5e1, 0xf2,0x5e2, 0xf3,0x5e3, 0xf4,0x5e4, 0xf5,0x5e5, 0xf6,0x5e6, 0xf7,0x5e7,

  0xf8,0x5e8, 0xf9,0x5e9, 0xfa,0x5ea, 0xfd,0x200e, 0xfe,0x200f

};

//! Internal and Low Level: the Windows CP1256 encoding

static int const s_windowsCP1256Unicode[] = {

  0x80,0x20ac, 0x81,0x67e, 0x82,0x201a, 0x83,0x192, 0x84,0x201e, 0x85,0x2026, 0x86,0x2020, 0x87,0x2021,

  0x88,0x2c6, 0x89,0x2030, 0x8a,0x679, 0x8b,0x2039, 0x8c,0x152, 0x8d,0x686, 0x8e,0x698, 0x8f,0x688,

  0x90,0x6af, 0x91,0x2018, 0x92,0x2019, 0x93,0x201c, 0x94,0x201d, 0x95,0x2022, 0x96,0x2013, 0x97,0x2014,

  0x98,0x6a9, 0x99,0x2122, 0x9a,0x691, 0x9b,0x203a, 0x9c,0x153, 0x9d,0x200c, 0x9e,0x200d, 0x9f,0x6ba,

  0xa1,0x60c,

  0xaa,0x6be,

  0xba,0x61b, 0xbf,0x61f,

  0xc0,0x6c1, 0xc1,0x621, 0xc2,0x622, 0xc3,0x623, 0xc4,0x624, 0xc5,0x625, 0xc6,0x626, 0xc7,0x627,

  0xc8,0x628, 0xc9,0x629, 0xca,0x62a, 0xcb,0x62b, 0xcc,0x62c, 0xcd,0x62d, 0xce,0x62e, 0xcf,0x62f,

  0xd0,0x630, 0xd1,0x631, 0xd2,0x632, 0xd3,0x633, 0xd4,0x634, 0xd5,0x635, 0xd6,0x636,

  0xd8,0x637, 0xd9,0x638, 0xda,0x639, 0xdb,0x63a, 0xdc,0x640, 0xdd,0x641, 0xde,0x642, 0xdf,0x643,

  0xe1,0x644, 0xe3,0x645, 0xe4,0x646, 0xe5,0x647, 0xe6,0x648,

  0xec,0x649, 0xed,0x64a,

  0xf0,0x64b, 0xf1,0x64c, 0xf2,0x64d, 0xf3,0x64e, 0xf5,0x64f, 0xf6,0x650,

  0xf8,0x651, 0xfa,0x652, 0xfd,0x200e, 0xfe,0x200f, 0xff,0x6d2

};

//! Internal and Low Level: the Windows CP1257 encoding

static int const s_windowsCP1257Unicode[] = {

  0x80,0x20ac, 0x82,0x201a, 0x84,0x201e, 0x85,0x2026, 0x86,0x2020, 0x87,0x2021,

  0x89,0x2030, 0x8b,0x2039, 0x8d,0xa8, 0x8e,0x2c7, 0x8f,0xb8,

  0x91,0x2018, 0x92,0x2019, 0x93,0x201c, 0x94,0x201d, 0x95,0x2022, 0x96,0x2013, 0x97,0x2014,

  0x99,0x2122, 0x9b,0x203a, 0x9d,0xaf, 0x9e,0x2db,

  0xa8,0xd8, 0xaa,0x156, 0xaf,0xc6,

  0xb8,0xf8, 0xba,0x157, 0xbf,0xe6,

  0xc0,0x104, 0xc1,0x12e, 0xc2,0x100, 0xc3,0x106, 0xc6,0x118, 0xc7,0x112,

  0xc8,0x10c, 0xca,0x179, 0xcb,0x116, 0xcc,0x122, 0xcd,0x136, 0xce,0x12a, 0xcf,0x13b,

  0xd0,0x160, 0xd1,0x143, 0xd2,0x145, 0xd4,0x14c,

  0xd8,0x172, 0xd9,0x141, 0xda,0x15a, 0xdb,0x16a, 0xdd,0x17b, 0xde,0x17d,

  0xe0,0x105, 0xe1,0x12f, 0xe2,0x101, 0xe3,0x107, 0xe6,0x119, 0xe7,0x113,

  0xe8,0x10d, 0xea,0x17a, 0xeb,0x117, 0xec,0x123, 0xed,0x137, 0xee,0x12b, 0xef,0x13c,

  0xf0,0x161, 0xf1,0x144, 0xf2,0x146, 0xf4,0x14d,

  0xf8,0x173, 0xf9,0x142, 0xfa,0x15b, 0xfb,0x16b, 0xfd,0x17c, 0xfe,0x17e, 0xff,0x2d9

};

//! Internal and Low Level: the Windows CP1258 encoding

static int const s_windowsCP1258Unicode[] = {

  0x80,0x20ac, 0x82,0x201a, 0x83,0x192, 0x84,0x201e, 0x85,0x2026, 0x86,0x2020, 0x87,0x2021,

  0x88,0x2c6, 0x89,0x2030, 0x8b,0x2039, 0x8c,0x152,

  0x91,0x2018, 0x92,0x2019, 0x93,0x201c, 0x94,0x201d, 0x95,0x2022, 0x96,0x2013, 0x97,0x2014,

  0x98,0x2dc, 0x99,0x2122, 0x9b,0x203a, 0x9c,0x153, 0x9f,0x178,

  0xc3,0x102,

  0xcc,0x300,

  0xd0,0x110, 0xd2,0x309, 0xd5,0x1a0,

  0xdd,0x1af, 0xde,0x303,

  0xe3,0x103,

  0xec,0x301,

  0xf0,0x111, 0xf2,0x323, 0xf5,0x1a1,

  0xfd,0x1b0, 0xfe,0x20ab

};

class KnownConversion

{

public:

  //! constructor

  KnownConversion()

    : m_convertMap()

    , m_familyMap()

    , m_romanMap()

    , m_centralEuroMap()

    , m_cyrillicMap()

    , m_turkishMap()

    , m_symbolMap()

    , m_dingbatsMap()

    , m_cursiveMap()

    , m_mathMap()

    , m_monotypeSortsMap()

    , m_scientificMap()

    , m_wingdingsMap()

    , m_SJISMap()

    , m_unknown107Map()

    , m_unknown128Map()

    , m_unknown200Map()

    , m_windowsCP1250Map()

    , m_windowsCP1251Map()

    , m_windowsCP1252Map()

    , m_windowsCP1253Map()

    , m_windowsCP1254Map()

    , m_windowsCP1255Map()

    , m_windowsCP1256Map()

    , m_windowsCP1257Map()

    , m_windowsCP1258Map()

    , m_defaultConv(m_romanMap)

    , m_centralEuroConv(m_centralEuroMap)

    , m_cyrillicConv(m_cyrillicMap)

    , m_turkishConv(m_turkishMap)

    , m_timeConv(m_romanMap,"Times New Roman")

    , m_zapfChanceryConv(m_romanMap,"Apple Chancery", -2)

    , m_symbolConv(m_symbolMap)

    , m_dingbatsConv(m_dingbatsMap)

    , m_cursiveConv(m_cursiveMap,"Apple Chancery")

    , m_mathConv(m_mathMap)

    , m_monotypeSortsConv(m_monotypeSortsMap, "Monotype Sorts")

    , m_scientificConv(m_scientificMap)

    , m_wingdingsConv(m_wingdingsMap)

    , m_SJISConv(m_SJISMap, MWAWFontConverter::E_SJIS)

    , m_unknown107Conv(m_unknown107Map)

    , m_unknown128Conv(m_unknown128Map)

    , m_unknown200Conv(m_unknown200Map)

    , m_windowsCP1250Conv(m_windowsCP1250Map)

    , m_windowsCP1251Conv(m_windowsCP1251Map)

    , m_windowsCP1252Conv(m_windowsCP1252Map)

    , m_windowsCP1253Conv(m_windowsCP1253Map)

    , m_windowsCP1254Conv(m_windowsCP1254Map)

    , m_windowsCP1255Conv(m_windowsCP1255Map)

    , m_windowsCP1256Conv(m_windowsCP1256Map)

    , m_windowsCP1257Conv(m_windowsCP1257Map)

    , m_windowsCP1258Conv(m_windowsCP1258Map)

  {

    initMaps();

  }

  //! returns the conversion map which corresponds to a name, or the default map

  Data::ConversionData const &getConversionMaps(std::string fName);

  //! set a family correspondance

  void setFamily(std::string const &fName, std::string const &family)

  {

    if (fName.length() && family.length())

      m_familyMap[fName]=family;

  }

  //! return the default converter

  ConversionData const &getDefault() const

  {

    return m_defaultConv;

  }

protected:

  //! Internal and Low level: initializes all the conversion maps

  void initMaps();

  //! Internal and Low level: initializes a map with a vector of \a numElt elements (char, unicode)

  static void initAMap(int const *arr, size_t numElt, std::map<unsigned char, unsigned long> &map)

  {

    for (size_t i = 0; i < numElt; i++) {

      auto c = static_cast<unsigned char>(arr[2*i]);

      auto unicode = static_cast<unsigned long>(arr[2*i+1]);

      map[c] = unicode;

    }

  }

  /** the conversiont map fName -> ConversionData */

  std::map<std::string, ConversionData const *> m_convertMap;

  //! Internal and Low level: map font name -> family font name

  std::map<std::string, std::string> m_familyMap;

  //! Internal and Low level: map char -> unicode for roman font

  std::map<unsigned char, unsigned long> m_romanMap;

  //! Internal and Low level: map char -> unicode for central european font

  std::map<unsigned char, unsigned long> m_centralEuroMap;

  //! Internal and Low level: map char -> unicode for cyrillic font

  std::map<unsigned char, unsigned long> m_cyrillicMap;

  //! Internal and Low level: map char -> unicode for turkish font

  std::map<unsigned char, unsigned long> m_turkishMap;

  //! Internal and Low level: map char -> unicode for symbol font

  std::map<unsigned char, unsigned long> m_symbolMap;

  //! Internal and Low level: map char -> unicode for dingbats font

  std::map<unsigned char, unsigned long> m_dingbatsMap;

  //! Internal and Low level: map char -> unicode for cursive font

  std::map<unsigned char, unsigned long> m_cursiveMap;

  //! Internal and Low level: map char -> unicode for math font

  std::map<unsigned char, unsigned long> m_mathMap;

  //! Internal and Low level: map char -> unicode for monotypeSorts font

  std::map<unsigned char, unsigned long> m_monotypeSortsMap;

  //! Internal and Low level: map char -> unicode for scientific font

  std::map<unsigned char, unsigned long> m_scientificMap;

  //! Internal and Low level: map char -> unicode for wingdings font

  std::map<unsigned char, unsigned long> m_wingdingsMap;

  //! Internal and Low level: simplified map char -> unicode for SJIS font

  std::map<unsigned char, unsigned long> m_SJISMap;

  //! Internal and Low level: map char -> unicode for font 107

  std::map<unsigned char, unsigned long> m_unknown107Map;

  //! Internal and Low level: map char -> unicode for font 128

  std::map<unsigned char, unsigned long> m_unknown128Map;

  //! Internal and Low level: map char -> unicode for font 200

  std::map<unsigned char, unsigned long> m_unknown200Map;

  //! Internal and Low level: map char -> unicode for Windows CP1250

  std::map<unsigned char, unsigned long> m_windowsCP1250Map;

  //! Internal and Low level: map char -> unicode for Windows CP1251

  std::map<unsigned char, unsigned long> m_windowsCP1251Map;

  //! Internal and Low level: map char -> unicode for Windows CP1252

  std::map<unsigned char, unsigned long> m_windowsCP1252Map;

  //! Internal and Low level: map char -> unicode for Windows CP1253

  std::map<unsigned char, unsigned long> m_windowsCP1253Map;

  //! Internal and Low level: map char -> unicode for Windows CP1254

  std::map<unsigned char, unsigned long> m_windowsCP1254Map;

  //! Internal and Low level: map char -> unicode for Windows CP1255

  std::map<unsigned char, unsigned long> m_windowsCP1255Map;

  //! Internal and Low level: map char -> unicode for Windows CP1256

  std::map<unsigned char, unsigned long> m_windowsCP1256Map;

  //! Internal and Low level: map char -> unicode for Windows CP1257

  std::map<unsigned char, unsigned long> m_windowsCP1257Map;

  //! Internal and Low level: map char -> unicode for Windows CP1258

  std::map<unsigned char, unsigned long> m_windowsCP1258Map;

  //! Internal and Low level: the default converter: roman

  ConversionData m_defaultConv;

  //! Internal and Low level: the default converter: central european

  ConversionData m_centralEuroConv;

  //! Internal and Low level: the default converter: cyrillic

  ConversionData m_cyrillicConv;

  //! Internal and Low level: the default converter: turkish

  ConversionData m_turkishConv;

  //! Internal and Low level: the converter for times font

  ConversionData m_timeConv;

  //! Internal and Low level: the converter for zapfChancery font

  ConversionData m_zapfChanceryConv;

  //! Internal and Low level: the converter for symbol font

  ConversionData m_symbolConv;

  //! Internal and Low level: the converter for dingbats font

  ConversionData m_dingbatsConv;

  //! Internal and Low level: the converter for cursive font

  ConversionData m_cursiveConv;

  //! Internal and Low level: the converter for math font

  ConversionData m_mathConv;

  //! Internal and Low level: the converter for monotypeSorts font

  ConversionData m_monotypeSortsConv;

  //! Internal and Low level: the converter for scientific font

  ConversionData m_scientificConv;

  //! Internal and Low level: the converter for wingdings font

  ConversionData m_wingdingsConv;

  //! Internal and Low level: the converter for SJIS font

  ConversionData m_SJISConv;

  //! Internal and Low level: the converter for font 107

  ConversionData m_unknown107Conv;

  //! Internal and Low level: the converter for font 128

  ConversionData m_unknown128Conv;

  //! Internal and Low level: the converter for font 200

  ConversionData m_unknown200Conv;

  //! Internal and Low level: the converter for Windows CP1250

  ConversionData m_windowsCP1250Conv;

  //! Internal and Low level: the converter for Windows CP1251

  ConversionData m_windowsCP1251Conv;

  //! Internal and Low level: the converter for Windows CP1252

  ConversionData m_windowsCP1252Conv;

  //! Internal and Low level: the converter for Windows CP1253

  ConversionData m_windowsCP1253Conv;

  //! Internal and Low level: the converter for Windows CP1254

  ConversionData m_windowsCP1254Conv;

  //! Internal and Low level: the converter for Windows CP1255

  ConversionData m_windowsCP1255Conv;

  //! Internal and Low level: the converter for Windows CP1256

  ConversionData m_windowsCP1256Conv;

  //! Internal and Low level: the converter for Windows CP1257

  ConversionData m_windowsCP1257Conv;

  //! Internal and Low level: the converter for Windows CP1258

  ConversionData m_windowsCP1258Conv;

};

//! Internal and Low level: initializes all the conversion maps

void KnownConversion::initMaps()

{

  size_t numRoman = sizeof(s_romanUnicode)/(2*sizeof(int));

  for (size_t i = 0; i < numRoman; i++) {

    auto c = static_cast<unsigned char>(s_romanUnicode[2*i]);

    auto unicode = static_cast<unsigned long>(s_romanUnicode[2*i+1]);

    m_romanMap[c] = m_turkishMap[c] = unicode;

    m_cursiveMap[c] = m_mathMap[c] = m_scientificMap[c] = unicode;

    m_unknown107Map[c] = m_unknown128Map[c] = m_unknown200Map[c] = unicode;

  }

  for (unsigned long c=0x20; c<=0xff; ++c)

    m_windowsCP1250Map[static_cast<unsigned char>(c)]=m_windowsCP1251Map[static_cast<unsigned char>(c)]=

          m_windowsCP1252Map[static_cast<unsigned char>(c)]=m_windowsCP1253Map[static_cast<unsigned char>(c)]=

                m_windowsCP1254Map[static_cast<unsigned char>(c)]=m_windowsCP1255Map[static_cast<unsigned char>(c)]=

                      m_windowsCP1256Map[static_cast<unsigned char>(c)]=m_windowsCP1257Map[static_cast<unsigned char>(c)]=

                            m_windowsCP1258Map[static_cast<unsigned char>(c)]=c;

  initAMap(s_centralEuroUnicode, sizeof(s_centralEuroUnicode)/(2*sizeof(int)), m_centralEuroMap);

  initAMap(s_cyrillicUnicode, sizeof(s_cyrillicUnicode)/(2*sizeof(int)), m_cyrillicMap);

  initAMap(s_turkishUnicode, sizeof(s_turkishUnicode)/(2*sizeof(int)), m_turkishMap);

  initAMap(s_symbolUnicode, sizeof(s_symbolUnicode)/(2*sizeof(int)), m_symbolMap);

  initAMap(s_dingbatsUnicode, sizeof(s_dingbatsUnicode)/(2*sizeof(int)), m_dingbatsMap);

  initAMap(s_cursiveIncompleteUnicode, sizeof(s_cursiveIncompleteUnicode)/(2*sizeof(int)), m_cursiveMap);

  initAMap(s_mathIncompleteUnicode, sizeof(s_mathIncompleteUnicode)/(2*sizeof(int)), m_mathMap);

  initAMap(s_monotypeSortsUnicode, sizeof(s_monotypeSortsUnicode)/(2*sizeof(int)), m_monotypeSortsMap);

  initAMap(s_scientificIncompleteUnicode, sizeof(s_scientificIncompleteUnicode)/(2*sizeof(int)),m_scientificMap);

  initAMap(s_wingdingsUnicode, sizeof(s_wingdingsUnicode)/(2*sizeof(int)), m_wingdingsMap);

  initAMap(s_SJISSimplifiedUnicode, sizeof(s_SJISSimplifiedUnicode)/(2*sizeof(int)), m_SJISMap);

  initAMap(s_unknown107IncompleteUnicode, sizeof(s_unknown107IncompleteUnicode)/(2*sizeof(int)),m_unknown107Map);

  initAMap(s_unknown128IncompleteUnicode, sizeof(s_unknown128IncompleteUnicode)/(2*sizeof(int)),m_unknown128Map);

  initAMap(s_unknown200IncompleteUnicode, sizeof(s_unknown200IncompleteUnicode)/(2*sizeof(int)),m_unknown200Map);

  initAMap(s_windowsCP1250Unicode, sizeof(s_windowsCP1250Unicode)/(2*sizeof(int)),m_windowsCP1250Map);

  initAMap(s_windowsCP1251Unicode, sizeof(s_windowsCP1251Unicode)/(2*sizeof(int)),m_windowsCP1251Map);

  initAMap(s_windowsCP1252Unicode, sizeof(s_windowsCP1252Unicode)/(2*sizeof(int)),m_windowsCP1252Map);

  initAMap(s_windowsCP1253Unicode, sizeof(s_windowsCP1253Unicode)/(2*sizeof(int)),m_windowsCP1253Map);

  initAMap(s_windowsCP1254Unicode, sizeof(s_windowsCP1254Unicode)/(2*sizeof(int)),m_windowsCP1254Map);

  initAMap(s_windowsCP1255Unicode, sizeof(s_windowsCP1255Unicode)/(2*sizeof(int)),m_windowsCP1255Map);

  initAMap(s_windowsCP1256Unicode, sizeof(s_windowsCP1256Unicode)/(2*sizeof(int)),m_windowsCP1256Map);

  initAMap(s_windowsCP1257Unicode, sizeof(s_windowsCP1257Unicode)/(2*sizeof(int)),m_windowsCP1257Map);

  initAMap(s_windowsCP1258Unicode, sizeof(s_windowsCP1258Unicode)/(2*sizeof(int)),m_windowsCP1258Map);

  // init convertMap

  m_convertMap[std::string("Default")] = &m_defaultConv;

  m_convertMap[std::string("Times")] = &m_timeConv;

  m_convertMap[std::string("Zapf Chancery")] = &m_zapfChanceryConv;

  m_convertMap[std::string("Symbol")] = &m_symbolConv;

  m_convertMap[std::string("Zapf Dingbats")] = &m_dingbatsConv;

  m_convertMap[std::string("Cursive")] = &m_cursiveConv;

  m_convertMap[std::string("Math")] = &m_mathConv;

  m_convertMap[std::string("Monotype Sorts")] = &m_monotypeSortsConv;

  m_convertMap[std::string("scientific")] = &m_scientificConv;

  m_convertMap[std::string("Wingdings")] = &m_wingdingsConv;

  m_convertMap[std::string("Osaka")] = &m_SJISConv;

  m_convertMap[std::string("Unknown107")] = &m_unknown107Conv;

  m_convertMap[std::string("Unknown128")] = &m_unknown128Conv;

  m_convertMap[std::string("Unknown200")] = &m_unknown200Conv;

  m_convertMap[std::string("CP1250")] = &m_windowsCP1250Conv;

  m_convertMap[std::string("CP1251")] = &m_windowsCP1251Conv;

  m_convertMap[std::string("CP1252")] = &m_windowsCP1252Conv;

  m_convertMap[std::string("CP1253")] = &m_windowsCP1253Conv;

  m_convertMap[std::string("CP1254")] = &m_windowsCP1254Conv;

  m_convertMap[std::string("CP1255")] = &m_windowsCP1255Conv;

  m_convertMap[std::string("CP1256")] = &m_windowsCP1256Conv;

  m_convertMap[std::string("CP1257")] = &m_windowsCP1257Conv;

  m_convertMap[std::string("CP1258")] = &m_windowsCP1258Conv;

  m_convertMap[std::string("APC Courier")] = & m_cyrillicConv;

  m_convertMap[std::string("Baston CYR")] = & m_cyrillicConv; // similar to Helvetica

  m_convertMap[std::string("Latinskij")] = & m_cyrillicConv;  // similar to Times

  m_convertMap[std::string("Priamoj")] = & m_cyrillicConv;  // similar to Monaco

  m_convertMap[std::string("Priamoj Prop")] = & m_cyrillicConv; // similar to Geneva

  m_convertMap[std::string("Sistemnyj")] = & m_cyrillicConv; // similar to Chicago

  m_familyMap["Osaka Tohaba"]="Osaka";

  m_familyMap["Hei"]="Osaka"; // checkme

  m_familyMap["Heisei Mincho"]="Osaka";

  m_familyMap["Heisei KakuGothic"]="Osaka";

  m_familyMap["Heiti SC Light"]="Osaka"; // checkme

  m_familyMap["Heiti SC Medium"]="Osaka"; // checkme

  m_familyMap["Hiragino KakuGothic ProN W3"]="Osaka";

  m_familyMap["Hiragino MaruGo W3"]="Osaka";

  m_familyMap["Hiragino MaruGo W4"]="Osaka";

  m_familyMap["Hiragino MaruGo W6"]="Osaka";

  m_familyMap["Hiragino Kakugo W3"]="Osaka";

  m_familyMap["Hiragino Kakugo W6"]="Osaka";

  m_familyMap["Hiragino Kakugo W8"]="Osaka";

  m_familyMap["Hiragino San GB W3"]="Osaka"; // checkme

  m_familyMap["Hiragino San GB W6"]="Osaka"; // checkme

}

ConversionData const &KnownConversion::getConversionMaps(std::string fName)

{

  if (fName.empty()) return m_defaultConv;

  auto it= m_convertMap.find(fName);

  if (it != m_convertMap.end()) return *(it->second);

  // look for a family map

  auto famIt= m_familyMap.find(fName);

  if (famIt == m_familyMap.end()) {

    // checkme maybe ok for pre-OS7, ... but not for WorldScript

    size_t len=fName.length();

    if (len > 4 && fName.substr(len-4,4)==" CYR")

      return m_cyrillicConv;

    if (len > 3 && fName[len-3]==' ') {

      if (fName.substr(len-3,3)==" CE")

        return m_centralEuroConv;

      if (fName.substr(len-3,3)==" CY")

        return m_cyrillicConv;

      if (fName.substr(len-3,3)==" TC")

        return m_turkishConv;

    }

    return m_defaultConv;

  }

  fName = famIt->second;

  it= m_convertMap.find(fName);

  if (it != m_convertMap.end()) return *(it->second);

  return  m_defaultConv;

}

}

//------------------------------------------------------------

//

// Font convertor imlementation

//

//------------------------------------------------------------

//! the default font converter

class State

{

public:

  //! the constructor

  State()

    : m_knownConversion()

    , m_idNameMap()

    , m_nameIdMap()

    , m_nameTranslatedNameMap()

    , m_nameIdCounter(0)

    , m_uniqueId(768)

    , m_sjisConverter()

    , m_unicodeCache()

  {

    initMaps();

  }

  /** returns an unused id */

  int getUnusedId()

  {

    while (m_idNameMap.find(m_uniqueId)!=m_idNameMap.end())

      m_uniqueId++;

    return m_uniqueId;

  }

  /** returns the identificator for a name,

  if not set creates one */

  int getId(std::string const &name, std::string const &family="")

  {

    if (name.empty()) return -1;

    auto it=m_nameIdMap.find(name);

    if (it != m_nameIdMap.end()) return it->second;

    int newId=getUnusedId();

    setCorrespondance(newId, name, family);

    return newId;

  }

  //! returns the name corresponding to an id or return std::string("")

  std::string getName(int macId)

  {

    auto it=m_idNameMap.find(macId);

    if (it==m_idNameMap.end()) return "";

    return it->second;

  }

  /* converts a character in unicode

     \return -1 if the character is not transformed */

  int unicode(int macId, unsigned char c);

  /* converts a character in unicode, if needed can read the next input caracter

     \return -1 if the character is not transformed */

  int unicode(int macId, unsigned char c, MWAWInputStreamPtr &input);

  /** converts a character in unicode, if needed can read the next input caracter in str

      \return -1 if the character is not transformed */

  int unicode(int macId, unsigned char c, unsigned char const *(&str), int len);

  /** final font name and a delta which can be used to change the size

  if no name is found, return "Times New Roman" */

  void getOdtInfo(int macId, std::string &nm, int &deltaSize);

  //! fixes the name corresponding to an id

  void setCorrespondance(int macId, std::string const &name, std::string const &family="")

  {

    m_idNameMap[macId] = name;

    m_nameIdMap[name] = macId;

    m_nameIdCounter++;

    if (family.length())

      m_knownConversion.setFamily(name,family);

  }

  /** check if a string is valid, if not, convert it to a valid string */

  std::string getValidName(std::string const &name) const

  {

    if (m_nameTranslatedNameMap.count(name))

      return m_nameTranslatedNameMap.find(name)->second;

    std::string fName;

    static bool first = true;

    for (auto c : name) {

      auto ch = static_cast<unsigned char>(c);

      if (ch > 0x1f && ch < 0x80) {

        fName+=c;

        continue;

      }

      if (first) {

        MWAW_DEBUG_MSG(("MWAWFontConverterInternal::State::getValidName: fontName contains bad character\n"));

        first = false;

      }

      fName += 'X';

    }

    return fName;

  }

protected:

  //! initializes the map

  void initMaps();

  //! try to update the cache

  bool updateCache(int macId);

  //! the basic conversion map

  MWAWFontConverterInternal::Data::KnownConversion m_knownConversion;

  //! map sysid -> font name

  std::map<int, std::string> m_idNameMap;

  //! map font name -> sysid

  std::map<std::string, int> m_nameIdMap;

  //! map font name (in original language) -> latin name

  std::map<std::string, std::string> m_nameTranslatedNameMap;

  //!Internal: a counter modified when a new correspondance name<->id is found

  long m_nameIdCounter;

  //! a int used to create new id for a name

  int m_uniqueId;

  //! a SJIS convertor to convert Shit-JIS font

  std::shared_ptr<MWAWFontSJISConverter> m_sjisConverter;

  //! small structure to speedup unicode

  struct UnicodeCache {

    //! constructor

    UnicodeCache()

      : m_nameIdCounter(-1)

      , m_macId(-1)

      , m_conv(nullptr)

    {

    }

    //! actual counter

    long m_nameIdCounter;

    //! actual macId

    int m_macId;

    //! actual convertor

    MWAWFontConverterInternal::Data::ConversionData const *m_conv;

  } m_unicodeCache;

};

// initializes the default conversion map

void State::initMaps()

{