diff options
Diffstat (limited to 'experimental/tqtinterface/qt4/src/kernel/tqfontdatabase_x11.cpp')
-rw-r--r-- | experimental/tqtinterface/qt4/src/kernel/tqfontdatabase_x11.cpp | 2008 |
1 files changed, 2008 insertions, 0 deletions
diff --git a/experimental/tqtinterface/qt4/src/kernel/tqfontdatabase_x11.cpp b/experimental/tqtinterface/qt4/src/kernel/tqfontdatabase_x11.cpp new file mode 100644 index 000000000..8ea403fab --- /dev/null +++ b/experimental/tqtinterface/qt4/src/kernel/tqfontdatabase_x11.cpp @@ -0,0 +1,2008 @@ +/**************************************************************************** +** +** Implementation of platform specific TQFontDatabase +** +** Created : 970521 +** +** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA. +** +** This file is part of the kernel module of the TQt GUI Toolkit. +** +** This file may be used under the terms of the GNU General +** Public License versions 2.0 or 3.0 as published by the Free +** Software Foundation and appearing in the files LICENSE.GPL2 +** and LICENSE.GPL3 included in the packaging of this file. +** Alternatively you may (at your option) use any later version +** of the GNU General Public License if such license has been +** publicly approved by Trolltech ASA (or its successors, if any) +** and the KDE Free TQt Foundation. +** +** Please review the following information to ensure GNU General +** Public Licensing requirements will be met: +** http://trolltech.com/products/qt/licenses/licensing/opensource/. +** If you are unsure which license is appropriate for your use, please +** review the following information: +** http://trolltech.com/products/qt/licenses/licensing/licensingoverview +** or contact the sales department at sales@trolltech.com. +** +** This file may be used under the terms of the Q Public License as +** defined by Trolltech ASA and appearing in the file LICENSE.TQPL +** included in the packaging of this file. Licensees holding valid TQt +** Commercial licenses may use this file in accordance with the TQt +** Commercial License Agreement provided with the Software. +** +** This file is provided "AS IS" with NO WARRANTY OF ANY KIND, +** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR +** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted +** herein. +** +**********************************************************************/ + +#include <tqplatformdefs.h> + +#include <tqdatetime.h> +#include <tqpaintdevicemetrics.h> + +#include "tqt_x11_p.h" + +#include <ctype.h> +#include <stdlib.h> + +#include <sys/types.h> +#include <sys/stat.h> +#include <fcntl.h> +#include <sys/mman.h> + +#ifndef TQT_NO_XFTFREETYPE +#include <ft2build.h> +#include FT_FREETYPE_H +#endif + +#ifndef TQT_XFT2 +#define FcBool Bool +#define FcTrue True +#define FcFalse False +#endif + +#ifdef TQFONTDATABASE_DEBUG +# define FD_DEBUG qDebug +#else +# define FD_DEBUG if (FALSE) qDebug +#endif // TQFONTDATABASE_DEBUG + +// from qfont_x11.cpp +extern double qt_pointSize(double pixelSize, TQPaintDevice *painttqdevice, int screen); +extern double qt_pixelSize(double pointSize, TQPaintDevice *painttqdevice, int screen); + + +static inline void capitalize ( char *s ) +{ + bool space = TRUE; + while( *s ) { + if ( space ) + *s = toupper( *s ); + space = ( *s == ' ' ); + ++s; + } +} + + +// ----- begin of generated code ----- + +#define make_tag( c1, c2, c3, c4 ) \ +( (((unsigned int)c1)<<24) | (((unsigned int)c2)<<16) | \ +(((unsigned int)c3)<<8) | ((unsigned int)c4) ) + +struct XlfdEncoding { + const char *name; + int id; + int mib; + unsigned int hash1; + unsigned int hash2; +}; + +static const XlfdEncoding xlfd_encoding[] = { + { "iso8859-1", 0, 4, make_tag('i','s','o','8'), make_tag('5','9','-','1') }, + { "iso8859-2", 1, 5, make_tag('i','s','o','8'), make_tag('5','9','-','2') }, + { "iso8859-3", 2, 6, make_tag('i','s','o','8'), make_tag('5','9','-','3') }, + { "iso8859-4", 3, 7, make_tag('i','s','o','8'), make_tag('5','9','-','4') }, + { "iso8859-9", 4, 12, make_tag('i','s','o','8'), make_tag('5','9','-','9') }, + { "iso8859-10", 5, 13, make_tag('i','s','o','8'), make_tag('9','-','1','0') }, + { "iso8859-13", 6, 109, make_tag('i','s','o','8'), make_tag('9','-','1','3') }, + { "iso8859-14", 7, 110, make_tag('i','s','o','8'), make_tag('9','-','1','4') }, + { "iso8859-15", 8, 111, make_tag('i','s','o','8'), make_tag('9','-','1','5') }, + { "hp-roman8", 9, 2004, make_tag('h','p','-','r'), make_tag('m','a','n','8') }, + { "jisx0208*-0", 10, 63, make_tag('j','i','s','x'), 0 }, +#define LAST_LATIN_ENCODING 10 + { "iso8859-5", 11, 8, make_tag('i','s','o','8'), make_tag('5','9','-','5') }, + { "*-cp1251", 12, 2251, 0, make_tag('1','2','5','1') }, + { "koi8-ru", 13, 2084, make_tag('k','o','i','8'), make_tag('8','-','r','u') }, + { "koi8-u", 14, 2088, make_tag('k','o','i','8'), make_tag('i','8','-','u') }, + { "koi8-r", 15, 2084, make_tag('k','o','i','8'), make_tag('i','8','-','r') }, + { "iso8859-7", 16, 10, make_tag('i','s','o','8'), make_tag('5','9','-','7') }, + { "iso10646-1", 17, 0, make_tag('i','s','o','1'), make_tag('4','6','-','1') }, + { "iso8859-8", 18, 85, make_tag('i','s','o','8'), make_tag('5','9','-','8') }, + { "gb18030-0", 19, -114, make_tag('g','b','1','8'), make_tag('3','0','-','0') }, + { "gb18030.2000-0", 20, -113, make_tag('g','b','1','8'), make_tag('0','0','-','0') }, + { "gbk-0", 21, -113, make_tag('g','b','k','-'), make_tag('b','k','-','0') }, + { "gb2312.*-0", 22, 57, make_tag('g','b','2','3'), 0 }, + { "jisx0201*-0", 23, 15, make_tag('j','i','s','x'), 0 }, + { "ksc5601*-*", 24, 36, make_tag('k','s','c','5'), 0 }, + { "big5hkscs-0", 25, -2101, make_tag('b','i','g','5'), make_tag('c','s','-','0') }, + { "hkscs-1", 26, -2101, make_tag('h','k','s','c'), make_tag('c','s','-','1') }, + { "big5*-*", 27, -2026, make_tag('b','i','g','5'), 0 }, + { "tscii-*", 28, 2028, make_tag('t','s','c','i'), 0 }, + { "tis620*-*", 29, 2259, make_tag('t','i','s','6'), 0 }, + { "iso8859-11", 30, 2259, make_tag('i','s','o','8'), make_tag('9','-','1','1') }, + { "mulelao-1", 31, -4242, make_tag('m','u','l','e'), make_tag('a','o','-','1') }, + { "ethiopic-tqunicode", 32, 0, make_tag('e','t','h','i'), make_tag('c','o','d','e') }, + { "tqunicode-*", 33, 0, make_tag('u','n','i','c'), 0 }, + { "*-symbol", 34, 0, 0, make_tag('m','b','o','l') }, + { "*-fontspecific", 35, 0, 0, make_tag('i','f','i','c') }, + { "fontspecific-*", 36, 0, make_tag('f','o','n','t'), 0 }, + { 0, 0, 0, 0, 0 } +}; + +static const char scripts_for_xlfd_encoding[37][61] = { + // iso8859-1 + { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0 }, + // iso8859-2 + { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0 }, + // iso8859-3 + { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0 }, + // iso8859-4 + { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0 }, + // iso8859-9 + { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0 }, + // iso8859-10 + { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0 }, + // iso8859-13 + { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0 }, + // iso8859-14 + { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0 }, + // iso8859-15 + { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0 }, + // hp-roman8 + { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0 }, + // jisx0208*-0 + { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0 }, + // iso8859-5 + { 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0 }, + // *-cp1251 + { 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0 }, + // koi8-ru + { 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0 }, + // koi8-u + { 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0 }, + // koi8-r + { 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0 }, + // iso8859-7 + { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0 }, + // iso10646-1 + { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0 }, + // iso8859-8 + { 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0 }, + // gb18030-0 + { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0 }, + // gb18030.2000-0 + { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0 }, + // gbk-0 + { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0 }, + // gb2312.*-0 + { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0 }, + // jisx0201*-0 + { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, + 0 }, + // ksc5601*-* + { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1 }, + // big5hkscs-0 + { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, + 0 }, + // hkscs-1 + { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, + 0 }, + // big5*-* + { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, + 0 }, + // tscii-* + { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0 }, + // tis620*-* + { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0 }, + // iso8859-11 + { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0 }, + // mulelao-1 + { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0 }, + // ethiopic-tqunicode + { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0 }, + // tqunicode-* + { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0 }, + // *-symbol + { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, + 0 }, + // *-fontspecific + { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, + 0 }, + // fontspecific-* + { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, + 0 } + +}; + +// ----- end of generated code ----- + + +const int numEncodings = sizeof( xlfd_encoding ) / sizeof( XlfdEncoding ) - 1; + +int qt_xlfd_encoding_id( const char *encoding ) +{ + // qDebug("looking for encoding id for '%s'", encoding ); + int len = strlen( encoding ); + if ( len < 4 ) + return -1; + unsigned int hash1 = make_tag( encoding[0], encoding[1], encoding[2], encoding[3] ); + const char *ch = encoding + len - 4; + unsigned int hash2 = make_tag( ch[0], ch[1], ch[2], ch[3] ); + + const XlfdEncoding *enc = xlfd_encoding; + for ( ; enc->name; ++enc ) { + if ( (enc->hash1 && enc->hash1 != hash1) || + (enc->hash2 && enc->hash2 != hash2) ) + continue; + // hashes match, do a compare if strings match + // the enc->name can contain '*'s we have to interpret correctly + const char *n = enc->name; + const char *e = encoding; + while ( 1 ) { + // qDebug("bol: *e='%c', *n='%c'", *e, *n ); + if ( *e == '\0' ) { + if ( *n ) + break; + // qDebug( "found encoding id %d", enc->id ); + return enc->id; + } + if ( *e == *n ) { + ++e; + ++n; + continue; + } + if ( *n != '*' ) + break; + ++n; + // qDebug("skip: *e='%c', *n='%c'", *e, *n ); + while ( *e && *e != *n ) + ++e; + } + } + // qDebug( "couldn't tqfind encoding %s", encoding ); + return -1; +} + +int qt_mib_for_xlfd_encoding( const char *encoding ) +{ + int id = qt_xlfd_encoding_id( encoding ); + if ( id != -1 ) return xlfd_encoding[id].mib; + return 0; +} + +int qt_encoding_id_for_mib( int mib ) +{ + const XlfdEncoding *enc = xlfd_encoding; + for ( ; enc->name; ++enc ) { + if ( enc->mib == mib ) + return enc->id; + } + return -1; +} + +static const char * xlfd_for_id( int id ) +{ + // special case: -1 returns the "*-*" encoding, allowing us to do full + // database population in a single X server round trip. + if ( id < 0 || id > numEncodings ) + return "*-*"; + return xlfd_encoding[id].name; +} + +enum XLFDFieldNames { + Foundry, + Family, + Weight, + Slant, + Width, + AddStyle, + PixelSize, + PointSize, + ResolutionX, + ResolutionY, + Spacing, + AverageWidth, + CharsetRegistry, + CharsetEncoding, + NFontFields +}; + +// Splits an X font name into fields separated by '-' +static bool parseXFontName( char *fontName, char **tokens ) +{ + if ( ! fontName || fontName[0] == '0' || fontName[0] != '-' ) { + tokens[0] = 0; + return FALSE; + } + + int i; + ++fontName; + for ( i = 0; i < NFontFields && fontName && fontName[0]; ++i ) { + tokens[i] = fontName; + for ( ;; ++fontName ) { + if ( *fontName == '-' ) + break; + if ( ! *fontName ) { + fontName = 0; + break; + } + } + + if ( fontName ) *fontName++ = '\0'; + } + + if ( i < NFontFields ) { + for ( int j = i ; j < NFontFields; ++j ) + tokens[j] = 0; + return FALSE; + } + + return TRUE; +} + +static inline bool isZero(char *x) +{ + return (x[0] == '0' && x[1] == 0); +} + +static inline bool isScalable( char **tokens ) +{ + return (isZero(tokens[PixelSize]) && + isZero(tokens[PointSize]) && + isZero(tokens[AverageWidth])); +} + +static inline bool isSmoothlyScalable( char **tokens ) +{ + return (isZero(tokens[ResolutionX]) && + isZero(tokens[ResolutionY])); +} + +static inline bool isFixedPitch( char **tokens ) +{ + return (tokens[Spacing][0] == 'm' || + tokens[Spacing][0] == 'c' || + tokens[Spacing][0] == 'M' || + tokens[Spacing][0] == 'C'); +} + +/* + Fills in a font definition (TQFontDef) from an XLFD (X Logical Font + Description). + + Returns TRUE if the the given xlfd is valid. The fields lbearing + and rbearing are not given any values. +*/ +bool qt_fillFontDef( const TQCString &xlfd, TQFontDef *fd, int screen ) +{ + char *tokens[NFontFields]; + TQCString buffer = xlfd.copy(); + if ( ! parseXFontName(buffer.data(), tokens) ) + return FALSE; + + capitalize(tokens[Family]); + capitalize(tokens[Foundry]); + + fd->family = TQString::tqfromLatin1(tokens[Family]); + TQString foundry = TQString::tqfromLatin1(tokens[Foundry]); + if ( ! foundry.isEmpty() && foundry != TQString::tqfromLatin1("*") ) + fd->family += + TQString::tqfromLatin1(" [") + foundry + TQString::tqfromLatin1("]"); + + if ( tqstrlen( tokens[AddStyle] ) > 0 ) + fd->addStyle = TQString::tqfromLatin1(tokens[AddStyle]); + else + fd->addStyle = TQString::null; + + fd->pointSize = atoi(tokens[PointSize]); + fd->tqstyleHint = TQFont::AnyStyle; // ### any until we match families + + char slant = tolower( (uchar) tokens[Slant][0] ); + fd->italic = ( slant == 'o' || slant == 'i' ); + char fixed = tolower( (uchar) tokens[Spacing][0] ); + fd->fixedPitch = ( fixed == 'm' || fixed == 'c' ); + fd->weight = getFontWeight( tokens[Weight] ); + + int r = atoi(tokens[ResolutionY]); + fd->pixelSize = atoi(tokens[PixelSize]); + // not "0" or "*", or required DPI + if ( r && fd->pixelSize && TQPaintDevice::x11AppDpiY( screen ) && + r != TQPaintDevice::x11AppDpiY( screen ) ) { + // calculate actual pointsize for display DPI + fd->pointSize = tqRound(qt_pointSize(fd->pixelSize, 0, screen) * 10.); + } else if ( fd->pixelSize == 0 && fd->pointSize ) { + // calculate pixel size from pointsize/dpi + fd->pixelSize = tqRound(qt_pixelSize(fd->pointSize / 10., 0, screen)); + } + + return TRUE; +} + +/* + Fills in a font definition (TQFontDef) from the font properties in an + XFontStruct. + + Returns TRUE if the TQFontDef could be filled with properties from + the XFontStruct. The fields lbearing and rbearing are not given any + values. +*/ +static bool qt_fillFontDef( XFontStruct *fs, TQFontDef *fd, int screen ) +{ + unsigned long value; + if ( fs && !XGetFontProperty( fs, XA_FONT, &value ) ) + return FALSE; + + char *n = XGetAtomName( TQPaintDevice::x11AppDisplay(), value ); + TQCString xlfd( n ); + if ( n ) + XFree( n ); + return qt_fillFontDef( xlfd.lower(), fd, screen ); +} + + +static TQtFontStyle::Key getStyle( char ** tokens ) +{ + TQtFontStyle::Key key; + + char slant0 = tolower( (uchar) tokens[Slant][0] ); + + if ( slant0 == 'r' ) { + if ( tokens[Slant][1]) { + char slant1 = tolower( (uchar) tokens[Slant][1] ); + + if ( slant1 == 'o' ) + key.oblique = TRUE; + else if ( slant1 == 'i' ) + key.italic = TRUE; + } + } else if ( slant0 == 'o' ) + key.oblique = TRUE; + else if ( slant0 == 'i' ) + key.italic = TRUE; + + key.weight = getFontWeight( tokens[Weight] ); + + if ( qstrcmp( tokens[Width], "normal" ) == 0 ) { + key.stretch = 100; + } else if ( qstrcmp( tokens[Width], "semi condensed" ) == 0 || + qstrcmp( tokens[Width], "semicondensed" ) == 0 ) { + key.stretch = 90; + } else if ( qstrcmp( tokens[Width], "condensed" ) == 0 ) { + key.stretch = 80; + } else if ( qstrcmp( tokens[Width], "narrow" ) == 0 ) { + key.stretch = 60; + } + + return key; +} + + +extern bool qt_has_xft; // defined in qfont_x11.cpp + +static bool xlfdsFullyLoaded = FALSE; +static unsigned char encodingLoaded[numEncodings]; + +static void loadXlfds( const char *reqFamily, int encoding_id ) +{ + TQtFontFamily *fontFamily = reqFamily ? db->family( reqFamily ) : 0; + + // make sure we don't load twice + if ( (encoding_id == -1 && xlfdsFullyLoaded) || (encoding_id != -1 && encodingLoaded[encoding_id]) ) + return; + if ( fontFamily && fontFamily->xlfdLoaded ) + return; + + int fontCount; + // force the X server to give us XLFDs + TQCString xlfd_pattern = "-*-"; + xlfd_pattern += reqFamily ? reqFamily : "*"; + xlfd_pattern += "-*-*-*-*-*-*-*-*-*-*-"; + xlfd_pattern += xlfd_for_id( encoding_id ); + + char **fontList = XListFonts( TQPaintDevice::x11AppDisplay(), + xlfd_pattern.data(), + 0xffff, &fontCount ); + // qDebug("requesting xlfd='%s', got %d fonts", xlfd_pattern.data(), fontCount ); + + + char *tokens[NFontFields]; + + for( int i = 0 ; i < fontCount ; i++ ) { + if ( ! parseXFontName( fontList[i], tokens ) ) continue; + + // get the encoding_id for this xlfd. we need to do this + // here, since we can pass -1 to this function to do full + // database population + *(tokens[CharsetEncoding]-1) = '-'; + int encoding_id = qt_xlfd_encoding_id( tokens[CharsetRegistry] ); + if ( encoding_id == -1 ) + continue; + + char *familyName = tokens[Family]; + capitalize( familyName ); + char *foundryName = tokens[Foundry]; + capitalize( foundryName ); + TQtFontStyle::Key styleKey = getStyle( tokens ); + + bool smooth_scalable = FALSE; + bool bitmap_scalable = FALSE; + if ( isScalable(tokens) ) { + if ( isSmoothlyScalable( tokens ) ) + smooth_scalable = TRUE; + else + bitmap_scalable = TRUE; + } + uint pixelSize = atoi( tokens[PixelSize] ); + uint xpointSize = atoi( tokens[PointSize] ); + uint xres = atoi( tokens[ResolutionX] ); + uint yres = atoi( tokens[ResolutionY] ); + uint avgwidth = atoi( tokens[AverageWidth] ); + bool fixedPitch = isFixedPitch( tokens ); + + if (avgwidth == 0 && pixelSize != 0) { + /* + Ignore bitmap scalable fonts that are automatically + generated by some X servers. We know they are bitmap + scalable because even though they have a specified pixel + size, the average width is zero. + */ + continue; + } + + TQtFontFamily *family = fontFamily ? fontFamily : db->family( familyName, TRUE ); + family->fontFileIndex = -1; + TQtFontFoundry *foundry = family->foundry( foundryName, TRUE ); + TQtFontStyle *style = foundry->style( styleKey, TRUE ); + + delete [] style->weightName; + style->weightName = qstrdup( tokens[Weight] ); + delete [] style->setwidthName; + style->setwidthName = qstrdup( tokens[Width] ); + + if ( smooth_scalable ) { + style->smoothScalable = TRUE; + style->bitmapScalable = FALSE; + pixelSize = SMOOTH_SCALABLE; + } + if ( !style->smoothScalable && bitmap_scalable ) + style->bitmapScalable = TRUE; + if ( !fixedPitch ) + family->fixedPitch = FALSE; + + TQtFontSize *size = style->pixelSize( pixelSize, TRUE ); + TQtFontEncoding *enc = + size->encodingID( encoding_id, xpointSize, xres, yres, avgwidth, TRUE ); + enc->pitch = *tokens[Spacing]; + if ( !enc->pitch ) enc->pitch = '*'; + + for ( int script = 0; script < TQFont::LastPrivateScript; ++script ) { + if ( scripts_for_xlfd_encoding[encoding_id][script] ) + family->scripts[script] = TQtFontFamily::Supported; + else + family->scripts[script] |= TQtFontFamily::UnSupported_Xlfd; + } + if ( encoding_id == -1 ) + family->xlfdLoaded = TRUE; + } + if ( !reqFamily ) { + // mark encoding as loaded + if ( encoding_id == -1 ) + xlfdsFullyLoaded = TRUE; + else + encodingLoaded[encoding_id] = TRUE; + } + + XFreeFontNames( fontList ); +} + + +#ifndef TQT_NO_XFTFREETYPE +static int getXftWeight(int xftweight) +{ + int qtweight = TQFont::Black; + if (xftweight <= (XFT_WEIGHT_LIGHT + XFT_WEIGHT_MEDIUM) / 2) + qtweight = TQFont::Light; + else if (xftweight <= (XFT_WEIGHT_MEDIUM + XFT_WEIGHT_DEMIBOLD) / 2) + qtweight = TQFont::Normal; + else if (xftweight <= (XFT_WEIGHT_DEMIBOLD + XFT_WEIGHT_BOLD) / 2) + qtweight = TQFont::DemiBold; + else if (xftweight <= (XFT_WEIGHT_BOLD + XFT_WEIGHT_BLACK) / 2) + qtweight = TQFont::Bold; + + return qtweight; +} + +static void loadXft() +{ + if (!qt_has_xft) + return; + +#ifdef TQT_XFT2 + struct XftDefaultFont { + const char *qtname; + const char *rawname; + bool fixed; + }; + const XftDefaultFont defaults[] = { + { "Serif", "serif", FALSE }, + { "Sans Serif", "sans-serif", FALSE }, + { "Monospace", "monospace", TRUE }, + { 0, 0, FALSE } + }; + const XftDefaultFont *f = defaults; + while (f->qtname) { + TQtFontFamily *family = db->family( f->qtname, TRUE ); + family->fixedPitch = f->fixed; + family->rawName = f->rawname; + family->hasXft = TRUE; + family->synthetic = TRUE; + TQtFontFoundry *foundry + = family->foundry( TQString::null, TRUE ); + + for ( int i = 0; i < TQFont::LastPrivateScript; ++i ) { + if (i == TQFont::UnknownScript) + continue; + family->scripts[i] = TQtFontFamily::Supported; + } + + TQtFontStyle::Key styleKey; + styleKey.oblique = FALSE; + for (int i = 0; i < 4; ++i) { + styleKey.italic = (i%2); + styleKey.weight = (i > 1) ? TQFont::Bold : TQFont::Normal; + TQtFontStyle *style = foundry->style( styleKey, TRUE ); + style->smoothScalable = TRUE; + TQtFontSize *size = style->pixelSize( SMOOTH_SCALABLE, TRUE ); + TQtFontEncoding *enc = size->encodingID( -1, 0, 0, 0, 0, TRUE ); + enc->pitch = (f->fixed ? 'm' : 'p'); + } + ++f; + } +#endif +} + +#ifdef XFT_MATRIX +static void checkXftMatrix( TQtFontFamily* family ) { + for ( int j = 0; j < family->count; ++j ) { // each foundry + TQtFontFoundry *foundry = family->foundries[j]; + for ( int k = 0; k < foundry->count; ++k ) { + TQtFontStyle *style = foundry->styles[k]; + if ( style->key.italic || style->key.oblique ) continue; + + TQtFontSize *size = style->pixelSize( SMOOTH_SCALABLE ); + if ( ! size ) continue; + TQtFontEncoding *enc = size->encodingID( -1, 0, 0, 0, 0, TRUE ); + if ( ! enc ) continue; + + TQtFontStyle::Key key = style->key; + + // does this style have an italic equivalent? + key.italic = TRUE; + TQtFontStyle *equiv = foundry->style( key ); + if ( equiv ) continue; + + // does this style have an oblique equivalent? + key.italic = FALSE; + key.oblique = TRUE; + equiv = foundry->style( key ); + if ( equiv ) continue; + + // let's fake one... + equiv = foundry->style( key, TRUE ); + equiv->fakeOblique = TRUE; + equiv->smoothScalable = TRUE; + + TQtFontSize *equiv_size = equiv->pixelSize( SMOOTH_SCALABLE, TRUE ); + TQtFontEncoding *equiv_enc = equiv_size->encodingID( -1, 0, 0, 0, 0, TRUE ); + + // keep the same pitch + equiv_enc->pitch = enc->pitch; + } + } +} +#endif // XFT_MATRIX + +static bool loadXftFont( FcPattern* font ) +{ + TQString familyName; + TQString rawName; + char *value; + int weight_value; + int slant_value; + int spacing_value; + char *file_value; + int index_value; + char *foundry_value = 0; + FcBool scalable = FcTrue; + + if (XftPatternGetString( font, + XFT_FAMILY, 0, &value) != XftResultMatch ) + return false; + // capitalize( value ); + rawName = familyName = TQString::fromUtf8(value); + familyName.tqreplace('-', ' '); + familyName.tqreplace("/", ""); + + slant_value = XFT_SLANT_ROMAN; + weight_value = XFT_WEIGHT_MEDIUM; + spacing_value = XFT_PROPORTIONAL; + file_value = 0; + index_value = 0; + XftPatternGetInteger (font, XFT_SLANT, 0, &slant_value); + XftPatternGetInteger (font, XFT_WEIGHT, 0, &weight_value); + XftPatternGetInteger (font, XFT_SPACING, 0, &spacing_value); + XftPatternGetString (font, XFT_FILE, 0, &file_value); + XftPatternGetInteger (font, XFT_INDEX, 0, &index_value); +#ifdef TQT_XFT2 + FcPatternGetBool(font, FC_SCALABLE, 0, &scalable); + foundry_value = 0; + XftPatternGetString(font, FC_FOUNDRY, 0, &foundry_value); +#endif + TQtFontFamily *family = db->family( familyName, TRUE ); + family->rawName = rawName; + family->hasXft = TRUE; + +#ifdef TQT_XFT2 + FcCharSet *charset = 0; + FcResult res = FcPatternGetCharSet(font, FC_CHARSET, 0, &charset); + if (res == FcResultMatch && FcCharSetCount(charset) > 1) { + for (int i = 0; i < TQFont::LastPrivateScript; ++i) { + bool supported = sample_chars[i][0]; + for (int j = 0; sample_chars[i][j]; ++j){ + if (!FcCharSetHasChar(charset, sample_chars[i][j])) { + supported = false; + break; + } + } + if ( supported ){ + family->scripts[i] = TQtFontFamily::Supported; + } else { + family->scripts[i] |= TQtFontFamily::UnSupported_Xft; + } + } + family->xftScriptCheck = TRUE; + } else { + // we set UnknownScript to supported for symbol fonts. It makes no sense to merge these + // with other ones, as they are special in a way. + for ( int i = 0; i < TQFont::LastPrivateScript; ++i ) + family->scripts[i] |= TQtFontFamily::UnSupported_Xft; + family->scripts[TQFont::UnknownScript] = TQtFontFamily::Supported; + } +#endif // TQT_XFT2 + + TQCString file = (file_value ? file_value : ""); + family->fontFilename = file; + family->fontFileIndex = index_value; + + TQtFontStyle::Key styleKey; + styleKey.italic = (slant_value == XFT_SLANT_ITALIC); + styleKey.oblique = (slant_value == XFT_SLANT_OBLIQUE); + styleKey.weight = getXftWeight( weight_value ); +#ifdef TQT_XFT2 + if (!scalable) { + int width = 100; +#if FC_VERSION >= 20193 + XftPatternGetInteger (font, FC_WIDTH, 0, &width); +#endif + styleKey.stretch = width; + } +#endif + + TQtFontFoundry *foundry + = family->foundry( foundry_value ? TQString::fromUtf8(foundry_value) : TQString::null, TRUE ); + TQtFontStyle *style = foundry->style( styleKey, TRUE ); + + if (spacing_value < XFT_MONO ) + family->fixedPitch = FALSE; + + TQtFontSize *size; + if (scalable) { + style->smoothScalable = TRUE; + size = style->pixelSize( SMOOTH_SCALABLE, TRUE ); + } +#ifdef TQT_XFT2 + else { + double pixel_size = 0; + XftPatternGetDouble (font, FC_PIXEL_SIZE, 0, &pixel_size); + size = style->pixelSize( (int)pixel_size, TRUE ); + } +#endif + TQtFontEncoding *enc = size->encodingID( -1, 0, 0, 0, 0, TRUE ); + enc->pitch = ( spacing_value >= XFT_CHARCELL ? 'c' : + ( spacing_value >= XFT_MONO ? 'm' : 'p' ) ); + + checkXftMatrix( family ); + + return true; +} + +#ifndef TQT_XFT2 + +#define MAKE_TAG( _x1, _x2, _x3, _x4 ) \ + ( ( (TQ_UINT32)_x1 << 24 ) | \ + ( (TQ_UINT32)_x2 << 16 ) | \ + ( (TQ_UINT32)_x3 << 8 ) | \ + (TQ_UINT32)_x4 ) + +#ifdef _POSIX_MAPPED_FILES +static inline TQ_UINT32 getUInt(unsigned char *p) +{ + TQ_UINT32 val; + val = *p++ << 24; + val |= *p++ << 16; + val |= *p++ << 8; + val |= *p; + + return val; +} + +static inline TQ_UINT16 getUShort(unsigned char *p) +{ + TQ_UINT16 val; + val = *p++ << 8; + val |= *p; + + return val; +} + +static inline void tag_to_string( char *string, TQ_UINT32 tag ) +{ + string[0] = (tag >> 24)&0xff; + string[1] = (tag >> 16)&0xff; + string[2] = (tag >> 8)&0xff; + string[3] = tag&0xff; + string[4] = 0; +} + +static TQ_UINT16 getGlyphIndex( unsigned char *table, TQ_UINT16 format, unsigned short tqunicode ) +{ + if ( format == 0 ) { + if ( tqunicode < 256 ) + return (int) *(table+6+tqunicode); + } else if ( format == 2 ) { + qWarning("format 2 encoding table for Unicode, not implemented!"); + } else if ( format == 4 ) { + TQ_UINT16 segCountX2 = getUShort( table + 6 ); + unsigned char *ends = table + 14; + TQ_UINT16 endIndex = 0; + int i = 0; + for ( ; i < segCountX2/2 && (endIndex = getUShort( ends + 2*i )) < tqunicode; i++ ); + + unsigned char *idx = ends + segCountX2 + 2 + 2*i; + TQ_UINT16 startIndex = getUShort( idx ); + + if ( startIndex > tqunicode ) + return 0; + + idx += segCountX2; + TQ_INT16 idDelta = (TQ_INT16)getUShort( idx ); + idx += segCountX2; + TQ_UINT16 idRangeoffset_t = (TQ_UINT16)getUShort( idx ); + + TQ_UINT16 glyphIndex; + if ( idRangeoffset_t ) { + TQ_UINT16 id = getUShort( idRangeoffset_t + 2*(tqunicode - startIndex) + idx); + if ( id ) + glyphIndex = ( idDelta + id ) % 0x10000; + else + glyphIndex = 0; + } else { + glyphIndex = (idDelta + tqunicode) % 0x10000; + } + return glyphIndex; + } + + return 0; +} +#endif // _POSIX_MAPPED_FILES + +static inline void checkXftCoverage( TQtFontFamily *family ) +{ +#ifdef _POSIX_MAPPED_FILES + TQCString ext = family->fontFilename.mid( family->fontFilename.tqfindRev( '.' ) ).lower(); + if ( family->fontFileIndex == 0 && ( ext == ".ttf" || ext == ".otf" ) ) { + void *map; + // qDebug("using own ttf code coverage checking of '%s'!", family->name.latin1() ); + int fd = open( family->fontFilename.data(), O_RDONLY ); + size_t pagesize = getpagesize(); + off_t offset = 0; + size_t length = (8192 / pagesize + 1) * pagesize; + + if ( fd == -1 ) + goto xftCheck; + { + if ( (map = mmap( 0, length, PROT_READ, MAP_SHARED, fd, offset ) ) == MAP_FAILED ) + goto error; + + unsigned char *ttf = (unsigned char *)map; + TQ_UINT32 version = getUInt( ttf ); + if ( version != 0x00010000 ) { + // qDebug("file has wrong version %x", version ); + goto error1; + } + TQ_UINT16 numTables = getUShort( ttf+4 ); + + unsigned char *table_dir = ttf + 12; + TQ_UINT32 cmap_offset = 0; + TQ_UINT32 cmap_length = 0; + for ( int n = 0; n < numTables; n++ ) { + TQ_UINT32 tag = getUInt( table_dir + 16*n ); + if ( tag == MAKE_TAG( 'c', 'm', 'a', 'p' ) ) { + cmap_offset = getUInt( table_dir + 16*n + 8 ); + cmap_length = getUInt( table_dir + 16*n + 12 ); + break; + } + } + if ( !cmap_offset ) { + // qDebug("no cmap found" ); + goto error1; + } + + if ( cmap_offset + cmap_length > length ) { + munmap( map, length ); + offset = cmap_offset / pagesize * pagesize; + cmap_offset -= offset; + length = (cmap_offset + cmap_length); + if ( (map = mmap( 0, length, PROT_READ, MAP_SHARED, fd, offset ) ) == MAP_FAILED ) + goto error; + } + + unsigned char *cmap = ((unsigned char *)map) + cmap_offset; + + version = getUShort( cmap ); + if ( version != 0 ) { + // qDebug("wrong cmap version" ); + goto error1; + } + numTables = getUShort( cmap + 2 ); + unsigned char *tqunicode_table = 0; + bool symbol_table = TRUE; + for ( int n = 0; n < numTables; n++ ) { + TQ_UINT32 version = getUInt( cmap + 4 + 8*n ); + // accept both symbol and Unicode encodings. prefer tqunicode. + if ( version == 0x00030001 || version == 0x00030000 ) { + tqunicode_table = cmap + getUInt( cmap + 4 + 8*n + 4 ); + if ( version == 0x00030001 ) { + symbol_table = FALSE; + break; + } + } + } + + if ( !tqunicode_table ) { + // qDebug("no tqunicode table found" ); + goto error1; + } + + TQ_UINT16 format = getUShort( tqunicode_table ); + if ( format != 4 ) + goto error1; + + if (symbol_table) { + // we set UnknownScript to supported for symbol fonts. It makes no sense to merge these + // with other ones, as they are special in a way. + for ( int i = 0; i < TQFont::LastPrivateScript; ++i ) + family->scripts[i] |= TQtFontFamily::UnSupported_Xft; + family->scripts[TQFont::UnknownScript] = TQtFontFamily::Supported; + } else { + for ( int i = 0; i < TQFont::LastPrivateScript; ++i ) { + + bool supported = sample_chars[i][0]; + for (int j = 0; sample_chars[i][j]; ++j) { + if (!getGlyphIndex(tqunicode_table, format, sample_chars[i][j])) { + supported=false; + break; + } + } + if ( supported ){ + // qDebug("font can render script %d", i ); + family->scripts[i] = TQtFontFamily::Supported; + } else { + family->scripts[i] |= TQtFontFamily::UnSupported_Xft; + } + } + } + family->xftScriptCheck = TRUE; + } + error1: + munmap( map, length ); + error: + close( fd ); + if ( family->xftScriptCheck ) + return; + } + xftCheck: +#endif // _POSIX_MAPPED_FILES + + FD_DEBUG("using Freetype for checking of '%s'", family->name.latin1() ); + + FT_Library ft_lib; + FT_Error error = FT_Init_FreeType( &ft_lib ); + if ( error ) return; + FT_Face face; + error = FT_New_Face( ft_lib, family->fontFilename, family->fontFileIndex, &face ); + if ( error ) return; + + for ( int i = 0; i < TQFont::LastPrivateScript; ++i ) { + bool supported = sample_chars[i][j]; + for (int j = 0; sample_chars[i][j]; ++j){ + if (!FT_Get_Char_Index(face, sample_chars[i][j])) { + supported=false; + break; + } + } + if ( supported ){ + FD_DEBUG("font can render char %04x, %04x script %d '%s'", + ch.tqunicode(), FT_Get_Char_Index ( face, ch.tqunicode() ), + i, TQFontDatabase::scriptName( (TQFont::Script)i ).latin1() ); + + family->scripts[i] = TQtFontFamily::Supported; + } else { + family->scripts[i] |= TQtFontFamily::UnSupported_Xft; + } + } + FT_Done_Face( face ); + FT_Done_FreeType( ft_lib ); + family->xftScriptCheck = TRUE; +} +#endif // TQT_XFT2 +#endif // TQT_NO_XFTFREETYPE + +static void load( const TQString &family = TQString::null, int script = -1 ) +{ +#ifdef TQFONTDATABASE_DEBUG + TQTime t; + t.start(); +#endif + + if ( family.isNull() ) { +#ifndef TQT_NO_XFTFREETYPE + static bool xft_readall_done = false; + if (qt_has_xft && !xft_readall_done) { + xft_readall_done = true; + XftFontSet *fonts = + XftListFonts(TQPaintDevice::x11AppDisplay(), + TQPaintDevice::x11AppScreen(), + (const char *)0, + XFT_FAMILY, XFT_WEIGHT, XFT_SLANT, + XFT_SPACING, XFT_FILE, XFT_INDEX, +#ifdef TQT_XFT2 + FC_CHARSET, FC_FOUNDRY, FC_SCALABLE, FC_PIXEL_SIZE, +#if FC_VERSION >= 20193 + FC_WIDTH, +#endif +#endif // TQT_XFT2 + (const char *)0); + for (int i = 0; i < fonts->nfont; i++) + loadXftFont( fonts->fonts[i] ); + XftFontSetDestroy (fonts); + } +#ifdef TQT_XFT2 + if (qt_has_xft) + return; +#endif +#endif // TQT_NO_XFTFREETYPE + if ( script == -1 ) + loadXlfds( 0, -1 ); + else { + for ( int i = 0; i < numEncodings; i++ ) { + if ( scripts_for_xlfd_encoding[i][script] ) + loadXlfds( 0, i ); + } + } + } else { + TQtFontFamily *f = db->family( family, TRUE ); + if ( !f->fullyLoaded ) { + +#ifndef TQT_NO_XFTFREETYPE + if (qt_has_xft) { + TQString mfamily = family; + redo: + XftFontSet *fonts = + XftListFonts(TQPaintDevice::x11AppDisplay(), + TQPaintDevice::x11AppScreen(), + XFT_FAMILY, XftTypeString, mfamily.utf8().data(), + (const char *)0, + XFT_FAMILY, XFT_WEIGHT, XFT_SLANT, + XFT_SPACING, XFT_FILE, XFT_INDEX, +#ifdef TQT_XFT2 + FC_CHARSET, FC_FOUNDRY, FC_SCALABLE, FC_PIXEL_SIZE, +#if FC_VERSION >= 20193 + FC_WIDTH, +#endif +#endif // TQT_XFT2 + (const char *)0); + for (int i = 0; i < fonts->nfont; i++) + loadXftFont( fonts->fonts[i] ); + XftFontSetDestroy (fonts); + if (mfamily.tqcontains(' ')) { + mfamily.tqreplace(TQChar(' '), TQChar('-')); + goto redo; + } + f->fullyLoaded = TRUE; +#ifdef TQT_XFT2 + return; +#endif + } +#ifndef TQT_XFT2 + // need to check Xft coverage + if ( f->hasXft && !f->xftScriptCheck ) { + checkXftCoverage( f ); + } +#endif +#endif // TQT_NO_XFTFREETYPE + // could reduce this further with some more magic: + // would need to remember the encodings loaded for the family. + if ( ( script == -1 && !f->xlfdLoaded ) || + ( !f->hasXft && !(f->scripts[script] & TQtFontFamily::Supported) && + !(f->scripts[script] & TQtFontFamily::UnSupported_Xlfd) ) ) { + loadXlfds( family, -1 ); + f->fullyLoaded = TRUE; + } + } + } + +#ifdef TQFONTDATABASE_DEBUG + FD_DEBUG("TQFontDatabase: load( %s, %d) took %d ms", family.latin1(), script, t.elapsed() ); +#endif +} + + +static void initializeDb() +{ + if ( db ) return; + db = new TQFontDatabasePrivate; + qfontdatabase_cleanup.set(&db); + +#ifndef TQT_XFT2 + memset( encodingLoaded, FALSE, sizeof( encodingLoaded ) ); +#endif + + TQTime t; + t.start(); + +#ifndef TQT_NO_XFTFREETYPE + loadXft(); + FD_DEBUG("TQFontDatabase: loaded Xft: %d ms", t.elapsed() ); +#endif + + t.start(); + +#ifndef TQT_NO_XFTFREETYPE + for ( int i = 0; i < db->count; i++ ) { +#ifndef TQT_XFT2 + checkXftCoverage( db->families[i] ); + FD_DEBUG("TQFontDatabase: xft coverage check: %d ms", t.elapsed() ); +#endif // TQT_XFT2 + +#ifdef XFT_MATRIX + checkXftMatrix( db->families[i] ); +#endif // XFT_MATRIX + } +#endif + + +#ifdef TQFONTDATABASE_DEBUG +#ifdef TQT_XFT2 + if (!qt_has_xft) +#endif + // load everything at startup in debug mode. + loadXlfds( 0, -1 ); + + // print the database + for ( int f = 0; f < db->count; f++ ) { + TQtFontFamily *family = db->families[f]; + FD_DEBUG("'%s' %s hasXft=%s", family->name.latin1(), (family->fixedPitch ? "fixed" : ""), + (family->hasXft ? "yes" : "no") ); + for ( int i = 0; i < TQFont::LastPrivateScript; ++i ) { + FD_DEBUG("\t%s: %s", TQFontDatabase::scriptName((TQFont::Script) i).latin1(), + ((family->scripts[i] & TQtFontFamily::Supported) ? "Supported" : + (family->scripts[i] & TQtFontFamily::UnSupported) == TQtFontFamily::UnSupported ? + "UnSupported" : "Unknown")); + } + + for ( int fd = 0; fd < family->count; fd++ ) { + TQtFontFoundry *foundry = family->foundries[fd]; + FD_DEBUG("\t\t'%s'", foundry->name.latin1() ); + for ( int s = 0; s < foundry->count; s++ ) { + TQtFontStyle *style = foundry->styles[s]; + FD_DEBUG("\t\t\tstyle: italic=%d oblique=%d (fake=%d) weight=%d (%s)\n" + "\t\t\tstretch=%d (%s)", + style->key.italic, style->key.oblique, style->fakeOblique, style->key.weight, + style->weightName, style->key.stretch, + style->setwidthName ? style->setwidthName : "nil" ); + if ( style->smoothScalable ) + FD_DEBUG("\t\t\t\tsmooth scalable" ); + else if ( style->bitmapScalable ) + FD_DEBUG("\t\t\t\tbitmap scalable" ); + if ( style->pixelSizes ) { + qDebug("\t\t\t\t%d pixel sizes", style->count ); + for ( int z = 0; z < style->count; ++z ) { + TQtFontSize *size = style->pixelSizes + z; + for ( int e = 0; e < size->count; ++e ) { + FD_DEBUG( "\t\t\t\t size %5d pitch %c encoding %s", + size->pixelSize, + size->encodings[e].pitch, + xlfd_for_id( size->encodings[e].encoding ) ); + } + } + } + } + } + } +#endif // TQFONTDATABASE_DEBUG +} + +void TQFontDatabase::createDatabase() +{ + initializeDb(); +} + + +// -------------------------------------------------------------------------------------- +// font loader +// -------------------------------------------------------------------------------------- +#define MAXFONTSIZE_XFT 256 +#define MAXFONTSIZE_XLFD 128 +#ifndef TQT_NO_XFTFREETYPE +static double addPatternProps(XftPattern *pattern, const TQtFontStyle::Key &key, bool fakeOblique, + bool smoothScalable, const TQFontPrivate *fp, const TQFontDef &request) +{ + int weight_value = XFT_WEIGHT_BLACK; + if ( key.weight == 0 ) + weight_value = XFT_WEIGHT_MEDIUM; + else if ( key.weight < (TQFont::Light + TQFont::Normal) / 2 ) + weight_value = XFT_WEIGHT_LIGHT; + else if ( key.weight < (TQFont::Normal + TQFont::DemiBold) / 2 ) + weight_value = XFT_WEIGHT_MEDIUM; + else if ( key.weight < (TQFont::DemiBold + TQFont::Bold) / 2 ) + weight_value = XFT_WEIGHT_DEMIBOLD; + else if ( key.weight < (TQFont::Bold + TQFont::Black) / 2 ) + weight_value = XFT_WEIGHT_BOLD; + XftPatternAddInteger( pattern, XFT_WEIGHT, weight_value ); + + int slant_value = XFT_SLANT_ROMAN; + if ( key.italic ) + slant_value = XFT_SLANT_ITALIC; + else if ( key.oblique && !fakeOblique ) + slant_value = XFT_SLANT_OBLIQUE; + XftPatternAddInteger( pattern, XFT_SLANT, slant_value ); + + /* + Xft1 doesn't obey user settings for turning off anti-aliasing using + the following: + + match any size > 6 size < 12 edit antialias = false; + + ... if we request pixel sizes. so, work around this limitiation and + convert the pixel size to a point size and request that. + */ + double size_value = request.pixelSize; + double scale = 1.; + if ( size_value > MAXFONTSIZE_XFT ) { + scale = (double)size_value/(double)MAXFONTSIZE_XFT; + size_value = MAXFONTSIZE_XFT; + } + + size_value = size_value*72./TQPaintDevice::x11AppDpiY(fp->screen); + XftPatternAddDouble( pattern, XFT_SIZE, size_value ); + +#ifdef XFT_MATRIX +# ifdef TQT_XFT2 + if (!smoothScalable) { +# if FC_VERSION >= 20193 + int stretch = request.stretch; + if (!stretch) + stretch = 100; + XftPatternAddInteger(pattern, FC_WIDTH, stretch); +# endif + } else +# endif + if ( ( request.stretch > 0 && request.stretch != 100 ) || + ( key.oblique && fakeOblique ) ) { + XftMatrix matrix; + XftMatrixInit( &matrix ); + + if ( request.stretch > 0 && request.stretch != 100 ) + XftMatrixScale( &matrix, double( request.stretch ) / 100.0, 1.0 ); + if ( key.oblique && fakeOblique ) + XftMatrixShear( &matrix, 0.20, 0.0 ); + + XftPatternAddMatrix( pattern, XFT_MATRIX, &matrix ); + } +#endif // XFT_MATRIX + if (request.styleStrategy & (TQFont::PreferAntialias|TQFont::NoAntialias)) { + XftPatternDel(pattern, XFT_ANTIALIAS); + XftPatternAddBool(pattern, XFT_ANTIALIAS, + !(request.styleStrategy & TQFont::NoAntialias)); + } + + return scale; +} +#endif // TQT_NO_XFTFREETYPE + +static +TQFontEngine *loadEngine( TQFont::Script script, + const TQFontPrivate *fp, const TQFontDef &request, + TQtFontFamily *family, TQtFontFoundry *foundry, + TQtFontStyle *style, TQtFontSize *size, + TQtFontEncoding *encoding, bool forced_encoding ) +{ + TQ_UNUSED(script); + + if ( fp && fp->rawMode ) { + TQCString xlfd = request.family.latin1(); + FM_DEBUG( "Loading XLFD (rawmode) '%s'", xlfd.data() ); + + XFontStruct *xfs; + if (! (xfs = XLoadQueryFont(TQPaintDevice::x11AppDisplay(), xlfd.data() ) ) ) + return 0; + + TQFontEngine *fe = new TQFontEngineXLFD( xfs, xlfd.data(), 0 ); + if ( ! qt_fillFontDef( xfs, &fe->fontDef, TQPaintDevice::x11AppScreen() ) && + ! qt_fillFontDef( xlfd, &fe->fontDef, TQPaintDevice::x11AppScreen() ) ) + fe->fontDef = TQFontDef(); + + return fe; + } + +#ifndef TQT_NO_XFTFREETYPE + if ( encoding->encoding == -1 ) { + + FM_DEBUG( " using Xft" ); + + XftPattern *pattern = XftPatternCreate(); + if ( !pattern ) return 0; + + bool symbol = (family->scripts[TQFont::UnknownScript] == TQtFontFamily::Supported); +# ifdef TQT_XFT2 + if (!symbol && script != TQFont::Unicode) { + FcCharSet *cs = FcCharSetCreate(); + for ( int j=0; sample_chars[script][j]; j++ ) + FcCharSetAddChar(cs, sample_chars[script][j]); + if (script == TQFont::Latin) + // add Euro character + FcCharSetAddChar(cs, 0x20ac); + FcPatternAddCharSet(pattern, FC_CHARSET, cs); + FcCharSetDestroy(cs); + } +# else + XftPatternAddString( pattern, XFT_ENCODING, symbol ? "adobe-fontspecific" : "iso10646-1"); +# endif // TQT_XFT2 + + if ( !foundry->name.isEmpty() ) + XftPatternAddString( pattern, XFT_FOUNDRY, + foundry->name.utf8().data() ); + + if ( !family->rawName.isEmpty() ) + XftPatternAddString( pattern, XFT_FAMILY, + family->rawName.utf8().data() ); + + + char pitch_value = ( encoding->pitch == 'c' ? XFT_CHARCELL : + ( encoding->pitch == 'm' ? XFT_MONO : XFT_PROPORTIONAL ) ); + XftPatternAddInteger( pattern, XFT_SPACING, pitch_value ); + + double scale = addPatternProps(pattern, style->key, style->fakeOblique, + style->smoothScalable, fp, request); + + XftResult res; + XftPattern *result = + XftFontMatch( TQPaintDevice::x11AppDisplay(), fp->screen, pattern, &res ); +#ifdef TQT_XFT2 + if (result && script == TQFont::Latin) { + // since we added the Euro char on top, check we actually got the family + // we requested. If we didn't get it correctly, remove the Euro from the pattern + // and try again. + FcChar8 *f; + res = FcPatternGetString(result, FC_FAMILY, 0, &f); + if (res == FcResultMatch && TQString::fromUtf8((char *)f) != family->rawName) { + FcPatternDel(pattern, FC_CHARSET); + FcCharSet *cs = FcCharSetCreate(); + for ( int j=0; sample_chars[script][j]; j++ ) + FcCharSetAddChar(cs, sample_chars[script][j]); + FcPatternAddCharSet(pattern, FC_CHARSET, cs); + FcCharSetDestroy(cs); + result = XftFontMatch( TQPaintDevice::x11AppDisplay(), fp->screen, pattern, &res ); + } + } +#endif + XftPatternDestroy(pattern); + if (!result) + return 0; + + // somehow this gets lost in the XftMatch call, reset the anitaliasing property correctly. + if (request.styleStrategy & (TQFont::PreferAntialias|TQFont::NoAntialias)) { + XftPatternDel(result, XFT_ANTIALIAS); + XftPatternAddBool(result, XFT_ANTIALIAS, + !(request.styleStrategy & TQFont::NoAntialias)); + } + // We pass a duplicate to XftFontOpenPattern because either xft font + // will own the pattern after the call or the pattern will be + // destroyed. + XftPattern *dup = XftPatternDuplicate( result ); + XftFont *xftfs = XftFontOpenPattern( TQPaintDevice::x11AppDisplay(), dup ); + + if ( ! xftfs ) // Xft couldn't tqfind a font? + return 0; + + TQFontEngine *fe = new TQFontEngineXft( xftfs, result, symbol ? 1 : 0 ); + if (fp->painttqdevice + && TQPaintDeviceMetrics(fp->painttqdevice).logicalDpiY() != TQPaintDevice::x11AppDpiY()) { + double px; + XftPatternGetDouble(result, XFT_PIXEL_SIZE, 0, &px); + scale = (double)request.pixelSize/px; + } + fe->setScale( scale ); + return fe; + } +#endif // TQT_NO_XFTFREETYPE + + FM_DEBUG( " using XLFD" ); + + TQCString xlfd = "-"; + xlfd += foundry->name.isEmpty() ? "*" : foundry->name.latin1(); + xlfd += "-"; + xlfd += family->name.isEmpty() ? "*" : family->name.latin1(); + + xlfd += "-"; + xlfd += style->weightName ? style->weightName : "*"; + xlfd += "-"; + xlfd += ( style->key.italic ? "i" : ( style->key.oblique ? "o" : "r" ) ); + + xlfd += "-"; + xlfd += style->setwidthName ? style->setwidthName : "*"; + // ### handle add-style + xlfd += "-*-"; + + int px = size->pixelSize; + if ( style->smoothScalable && px == SMOOTH_SCALABLE ) + px = request.pixelSize; + else if ( style->bitmapScalable && px == 0 ) + px = request.pixelSize; + double scale = 1.; + if ( px > MAXFONTSIZE_XLFD ) { + scale = (double)px/(double)MAXFONTSIZE_XLFD; + px = MAXFONTSIZE_XLFD; + } + if (fp && fp->painttqdevice + && TQPaintDeviceMetrics(fp->painttqdevice).logicalDpiY() != TQPaintDevice::x11AppDpiY()) + scale = (double)request.pixelSize/(double)px; + + xlfd += TQString::number( px ).latin1(); + xlfd += "-"; + xlfd += TQString::number( encoding->xpoint ); + xlfd += "-"; + xlfd += TQString::number( encoding->xres ); + xlfd += "-"; + xlfd += TQString::number( encoding->yres ); + xlfd += "-"; + + // ### handle cell spaced fonts + xlfd += encoding->pitch; + xlfd += "-"; + xlfd += TQString::number( encoding->avgwidth ); + xlfd += "-"; + xlfd += xlfd_for_id( encoding->encoding ); + + FM_DEBUG( " xlfd: '%s'", xlfd.data() ); + + XFontStruct *xfs; + if (! (xfs = XLoadQueryFont(TQPaintDevice::x11AppDisplay(), xlfd.data() ) ) ) + return 0; + + TQFontEngine *fe = 0; + const int mib = xlfd_encoding[ encoding->encoding ].mib; + if (script == TQFont::Latin && encoding->encoding <= LAST_LATIN_ENCODING && !forced_encoding) { + fe = new TQFontEngineLatinXLFD( xfs, xlfd.data(), mib ); + } else { + fe = new TQFontEngineXLFD( xfs, xlfd.data(), mib ); + } + + fe->setScale( scale ); + + return fe; +} + + +#ifdef TQT_XFT2 + +static void parseFontName(const TQString &name, TQString &foundry, TQString &family) +{ + if ( name.tqcontains('[') && name.tqcontains(']')) { + int i = name.tqfind('['); + int li = name.tqfindRev(']'); + + if (i < li) { + foundry = name.mid(i + 1, li - i - 1); + if (name[i - 1] == ' ') + i--; + family = name.left(i); + } + } else { + foundry = TQString::null; + family = name; + } +} + + +static TQFontEngine *loadFontConfigFont(const TQFontPrivate *fp, const TQFontDef &request, TQFont::Script script) +{ + if (!qt_has_xft) + return 0; + + TQStringList family_list; + if (request.family.isEmpty()) { + family_list = TQStringList::split(TQChar(','), fp->request.family); + + TQString stylehint; + switch ( request.tqstyleHint ) { + case TQFont::SansSerif: + stylehint = "sans-serif"; + break; + case TQFont::Serif: + stylehint = "serif"; + break; + case TQFont::TypeWriter: + stylehint = "monospace"; + break; + default: + if (request.fixedPitch) + stylehint = "monospace"; + break; + } + if (!stylehint.isEmpty()) + family_list << stylehint; + } else { + family_list << request.family; + } + + FcPattern *pattern = FcPatternCreate(); + + { + TQString family, foundry; + for (TQStringList::ConstIterator it = family_list.begin(); it != family_list.end(); ++it) { + parseFontName(*it, foundry, family); + XftPatternAddString(pattern, XFT_FAMILY, family.utf8().data()); + } + } + + TQtFontStyle::Key key; + key.italic = request.italic; + key.weight = request.weight; + key.stretch = request.stretch; + + double scale = addPatternProps(pattern, key, FALSE, TRUE, fp, request); +#ifdef FONT_MATCH_DEBUG + qDebug("original pattern tqcontains:"); + FcPatternPrint(pattern); +#endif + + // XftFontMatch calls the right ConfigSubstitute variants, but as we use + // FcFontMatch/Sort here we have to do it manually. + FcConfigSubstitute(0, pattern, FcMatchPattern); + XftDefaultSubstitute(TQPaintDevice::x11AppDisplay(), TQPaintDevice::x11AppScreen(), pattern); + +// qDebug("1: pattern tqcontains:"); +// FcPatternPrint(pattern); + + { + FcValue value; + value.type = FcTypeString; + + // these should only get added to the pattern _after_ substitution + // append the default fallback font for the specified script + extern TQString qt_fallback_font_family( TQFont::Script ); + TQString fallback = qt_fallback_font_family( script ); + if ( ! fallback.isEmpty() && ! family_list.tqcontains( fallback ) ) { + TQCString cs = fallback.utf8(); + value.u.s = (const FcChar8 *)cs.data(); + FcPatternAddWeak(pattern, FC_FAMILY, value, FcTrue); + } + + // add the default family + TQString defaultFamily = TQApplication::font().family(); + if ( ! family_list.tqcontains( defaultFamily ) ) { + TQCString cs = defaultFamily.utf8(); + value.u.s = (const FcChar8 *)cs.data(); + FcPatternAddWeak(pattern, FC_FAMILY, value, FcTrue); + } + + // add TQFont::defaultFamily() to the list, for compatibility with + // previous versions + defaultFamily = TQApplication::font().defaultFamily(); + if ( ! family_list.tqcontains( defaultFamily ) ) { + TQCString cs = defaultFamily.utf8(); + value.u.s = (const FcChar8 *)cs.data(); + FcPatternAddWeak(pattern, FC_FAMILY, value, FcTrue); + } + } + + if (script != TQFont::Unicode) { + FcCharSet *cs = FcCharSetCreate(); + for ( int j=0; sample_chars[script][j]; j++ ) + FcCharSetAddChar(cs, sample_chars[script][j]); + if (script == TQFont::Latin) + // add Euro character + FcCharSetAddChar(cs, 0x20ac); + FcPatternAddCharSet(pattern, FC_CHARSET, cs); + FcCharSetDestroy(cs); + } + +#ifdef FONT_MATCH_DEBUG + printf("final pattern tqcontains:\n"); + FcPatternPrint(pattern); +#endif + + TQFontEngine *fe = 0; + + for( int jj = (FcGetVersion() >= 20392 ? 0 : 1); jj < 2; ++jj ) { + bool use_fontsort = ( jj == 1 ); + + FcResult result; + FcFontSet *fs = 0; + FcPattern *fsp = 0; + if( use_fontsort ) { + fs = FcFontSort(0, pattern, FcFalse, 0, &result); + if (!fs) + continue; + } else { + fsp = FcFontMatch(0, pattern, &result); + if (!fsp) + continue; + } + +#ifdef FONT_MATCH_DEBUG + if( use_fontsort ) { + printf("fontset tqcontains:\n"); + for (int i = 0; i < fs->nfont; ++i) { + FcPattern *test = fs->fonts[i]; + FcChar8 *fam; + FcPatternGetString(test, FC_FAMILY, 0, &fam); + printf(" %s\n", fam); + } + } else { + printf("fontmatch:"); + FcChar8 *fam; + FcPatternGetString(fsp, FC_FAMILY, 0, &fam); + printf(" %s\n", fam); + } +#endif + + double size_value = request.pixelSize; + if ( size_value > MAXFONTSIZE_XFT ) + size_value = MAXFONTSIZE_XFT; + + int cnt = use_fontsort ? fs->nfont : 1; + + for (int i = 0; i < cnt; ++i) { + FcPattern *font = use_fontsort ? fs->fonts[i] : fsp; + FcCharSet *cs; + FcResult res = FcPatternGetCharSet(font, FC_CHARSET, 0, &cs); + if (res != FcResultMatch) + continue; + bool do_break=true; + for ( int j=0; sample_chars[script][j]; j++ ){ + do_break=false; + if (!FcCharSetHasChar(cs, sample_chars[script][j])) { + do_break=true; + break; + } + } + if ( do_break ) + continue; + FcBool scalable; + res = FcPatternGetBool(font, FC_SCALABLE, 0, &scalable); + if (res != FcResultMatch || !scalable) { + int pixelSize; + res = FcPatternGetInteger(font, FC_PIXEL_SIZE, 0, &pixelSize); + if (res != FcResultMatch || TQABS((size_value-pixelSize)/size_value) > 0.2) + continue; + } + + XftPattern *pattern = XftPatternDuplicate(font); + // add properties back in as the font selected from the list doesn't contain them. + addPatternProps(pattern, key, FALSE, TRUE, fp, request); + + XftPattern *result = + XftFontMatch( TQPaintDevice::x11AppDisplay(), fp->screen, pattern, &res ); + XftPatternDestroy(pattern); + + // We pass a duplicate to XftFontOpenPattern because either xft font + // will own the pattern after the call or the pattern will be + // destroyed. + XftPattern *dup = XftPatternDuplicate( result ); + XftFont *xftfs = XftFontOpenPattern( TQPaintDevice::x11AppDisplay(), dup ); + + if ( !xftfs ) { + // Xft couldn't tqfind a font? + qDebug("couldn't open fontconfigs chosen font with Xft!!!"); + } else { + fe = new TQFontEngineXft( xftfs, result, 0 ); + if (fp->painttqdevice + && TQPaintDeviceMetrics(fp->painttqdevice).logicalDpiY() != TQPaintDevice::x11AppDpiY()) { + double px; + XftPatternGetDouble(result, XFT_PIXEL_SIZE, 0, &px); + scale = request.pixelSize/px; + } + fe->setScale( scale ); + fe->fontDef = request; + if ( script != TQFont::Unicode && !canRender(fe, script) ) { + FM_DEBUG( " WARN: font loaded cannot render samples" ); + delete fe; + fe = 0; + }else + FM_DEBUG( " USE: %s", fe->fontDef.family.latin1() ); + } + if (fe) { + TQFontEngineXft *xft = (TQFontEngineXft *)fe; + char *family; + if (XftPatternGetString(xft->pattern(), XFT_FAMILY, 0, &family) == XftResultMatch) + xft->fontDef.family = TQString::fromUtf8(family); + + double px; + if (XftPatternGetDouble(xft->pattern(), XFT_PIXEL_SIZE, 0, &px) == XftResultMatch) + xft->fontDef.pixelSize = tqRound(px); + + int weight = XFT_WEIGHT_MEDIUM; + XftPatternGetInteger(xft->pattern(), XFT_WEIGHT, 0, &weight); + xft->fontDef.weight = getXftWeight(weight); + + int slant = XFT_SLANT_ROMAN; + XftPatternGetInteger(xft->pattern(), XFT_SLANT, 0, &slant); + xft->fontDef.italic = (slant != XFT_SLANT_ROMAN); + + int spacing = XFT_PROPORTIONAL; + XftPatternGetInteger(xft->pattern(), XFT_SPACING, 0, &spacing); + xft->fontDef.fixedPitch = spacing != XFT_PROPORTIONAL; + + xft->fontDef.ignorePitch = FALSE; + break; + } + } + + if( use_fontsort ) + FcFontSetDestroy(fs); + else + FcPatternDestroy(fsp); + + if( fe ) + break; + + } // for( jj ) + + FcPatternDestroy(pattern); + + return fe; +} + +#endif |