Update to KDE 3.5.0

1 files changed, 378 insertions, 0 deletions

diff --git a/x11-toolkits/qt33/files/0067-nofclist.patch b/x11-toolkits/qt33/files/0067-nofclist.patch
new file mode 100644
index 000000000000..d5ac46a3730d
--- /dev/null
+++ b/x11-toolkits/qt33/files/0067-nofclist.patch
@@ -0,0 +1,378 @@
+qt-bugs@ issue : none yet
+bugs.kde.org number : none
+applied: no
+author: Lubos Lunak <l.lunak@kde.org>
+
+Instead of getting a full list of all fonts using XftFontList (which calls
+the still awfully slow FcFontList) load on-demand only info about fonts
+that are really needed.
+
+--- src/kernel/qfontdatabase.cpp.sav	2005-11-08 13:20:04.000000000 +0100
++++ src/kernel/qfontdatabase.cpp	2005-12-02 16:24:47.000000000 +0100
+@@ -996,6 +996,10 @@ QFontDatabase::findFont( QFont::Script s
+ 
+ 	load( family_name, script );
+ 
++        // With QT_XFT2 this iterates only those fonts for which load()
++        // has been already called, but that's ok, since below only
++        // those fonts with matching family name are used. If family
++        // name is empty, then load() loads all fonts.
+ 	for ( int x = 0; x < db->count; ++x ) {
+ 	    QtFontFamily *try_family = db->families[x];
+ #ifdef Q_WS_X11
+--- src/kernel/qfontdatabase_x11.cpp.sav	2005-12-01 18:17:33.000000000 +0100
++++ src/kernel/qfontdatabase_x11.cpp	2005-12-02 16:27:34.000000000 +0100
+@@ -843,8 +843,92 @@ static void loadXft()
+     if (!qt_has_xft)
+ 	return;
+ 
+-    XftFontSet  *fonts;
++#ifdef QT_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) {
++	QtFontFamily *family = db->family( f->qtname, TRUE );
++	family->rawName = f->rawname;
++	family->hasXft = TRUE;
++        family->synthetic = TRUE;
++	QtFontFoundry *foundry
++	    = family->foundry( QString::null,  TRUE );
++
++	for ( int i = 0; i < QFont::LastPrivateScript; ++i ) {
++            if (i == QFont::UnknownScript)
++                continue;
++	    family->scripts[i] = QtFontFamily::Supported;
++        }
++
++	QtFontStyle::Key styleKey;
++	styleKey.oblique = FALSE;
++	for (int i = 0; i < 4; ++i) {
++	    styleKey.italic = (i%2);
++	    styleKey.weight = (i > 1) ? QFont::Bold : QFont::Normal;
++	    QtFontStyle *style = foundry->style( styleKey,  TRUE );
++	    style->smoothScalable = TRUE;
++	    QtFontSize *size = style->pixelSize( SMOOTH_SCALABLE, TRUE );
++	    QtFontEncoding *enc = size->encodingID( -1, 0, 0, 0, 0, TRUE );
++	    enc->pitch = (f->fixed ? 'm' : 'p');
++	}
++	++f;
++    }
++#endif
++}
++
++#ifdef XFT_MATRIX
++static void checkXftMatrix( QtFontFamily* family ) {
++	for ( int j = 0; j < family->count; ++j ) {	// each foundry
++	    QtFontFoundry *foundry = family->foundries[j];
++	    for ( int k = 0; k < foundry->count; ++k ) {
++		QtFontStyle *style = foundry->styles[k];
++		if ( style->key.italic || style->key.oblique ) continue;
+ 
++		QtFontSize *size = style->pixelSize( SMOOTH_SCALABLE );
++		if ( ! size ) continue;
++		QtFontEncoding *enc = size->encodingID( -1, 0, 0, 0, 0, TRUE );
++		if ( ! enc ) continue;
++
++		QtFontStyle::Key key = style->key;
++
++		// does this style have an italic equivalent?
++		key.italic = TRUE;
++		QtFontStyle *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;
++
++		QtFontSize *equiv_size = equiv->pixelSize( SMOOTH_SCALABLE, TRUE );
++		QtFontEncoding *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 )
++{
+     QString familyName;
+     QString rawName;
+     char *value;
+@@ -856,24 +940,9 @@ static void loadXft()
+     char *foundry_value = 0;
+     FcBool scalable = FcTrue;
+ 
+-    fonts =
+-	XftListFonts(QPaintDevice::x11AppDisplay(),
+-		     QPaintDevice::x11AppScreen(),
+-		     (const char *)0,
+-		     XFT_FAMILY, XFT_WEIGHT, XFT_SLANT,
+-		     XFT_SPACING, XFT_FILE, XFT_INDEX,
+-#ifdef QT_XFT2
+-		     FC_CHARSET, FC_FOUNDRY, FC_SCALABLE, FC_PIXEL_SIZE,
+-#if FC_VERSION >= 20193
+-                     FC_WIDTH,
+-#endif
+-#endif // QT_XFT2
+-		     (const char *)0);
+-
+-    for (int i = 0; i < fonts->nfont; i++) {
+-	if (XftPatternGetString(fonts->fonts[i],
++	if (XftPatternGetString( font,
+ 				XFT_FAMILY, 0, &value) != XftResultMatch )
+-	    continue;
++	    return false;
+ 	// 	capitalize( value );
+ 	rawName = familyName = QString::fromUtf8(value);
+ 	familyName.replace('-', ' ');
+@@ -884,15 +953,15 @@ static void loadXft()
+ 	spacing_value = XFT_PROPORTIONAL;
+ 	file_value = 0;
+ 	index_value = 0;
+-	XftPatternGetInteger (fonts->fonts[i], XFT_SLANT, 0, &slant_value);
+-	XftPatternGetInteger (fonts->fonts[i], XFT_WEIGHT, 0, &weight_value);
+-	XftPatternGetInteger (fonts->fonts[i], XFT_SPACING, 0, &spacing_value);
+-	XftPatternGetString (fonts->fonts[i], XFT_FILE, 0, &file_value);
+-	XftPatternGetInteger (fonts->fonts[i], XFT_INDEX, 0, &index_value);
++	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 QT_XFT2
+-	FcPatternGetBool(fonts->fonts[i], FC_SCALABLE, 0, &scalable);
++	FcPatternGetBool(font, FC_SCALABLE, 0, &scalable);
+ 	foundry_value = 0;
+-	XftPatternGetString(fonts->fonts[i], FC_FOUNDRY, 0, &foundry_value);
++	XftPatternGetString(font, FC_FOUNDRY, 0, &foundry_value);
+ #endif
+ 	QtFontFamily *family = db->family( familyName, TRUE );
+ 	family->rawName = rawName;
+@@ -900,7 +969,7 @@ static void loadXft()
+ 
+ #ifdef QT_XFT2
+ 	FcCharSet *charset = 0;
+-	FcResult res = FcPatternGetCharSet(fonts->fonts[i], FC_CHARSET, 0, &charset);
++	FcResult res = FcPatternGetCharSet(font, FC_CHARSET, 0, &charset);
+ 	if (res == FcResultMatch && FcCharSetCount(charset) > 1) {
+ 	    for (int i = 0; i < QFont::LastPrivateScript; ++i) {
+ 		QChar ch = sampleCharacter((QFont::Script) i);
+@@ -934,7 +1003,7 @@ static void loadXft()
+         if (!scalable) {
+             int width = 100;
+ #if FC_VERSION >= 20193
+-	    XftPatternGetInteger (fonts->fonts[i], FC_WIDTH, 0, &width);
++	    XftPatternGetInteger (font, FC_WIDTH, 0, &width);
+ #endif
+             styleKey.stretch = width;
+         }
+@@ -955,58 +1024,17 @@ static void loadXft()
+ #ifdef QT_XFT2
+ 	else {
+ 	    double pixel_size = 0;
+-	    XftPatternGetDouble (fonts->fonts[i], FC_PIXEL_SIZE, 0, &pixel_size);
++	    XftPatternGetDouble (font, FC_PIXEL_SIZE, 0, &pixel_size);
+ 	    size = style->pixelSize( (int)pixel_size, TRUE );
+         }
+ #endif
+ 	QtFontEncoding *enc = size->encodingID( -1, 0, 0, 0, 0, TRUE );
+ 	enc->pitch = ( spacing_value >= XFT_CHARCELL ? 'c' :
+ 		       ( spacing_value >= XFT_MONO ? 'm' : 'p' ) );
+-    }
+-
+-    XftFontSetDestroy (fonts);
+-
+-#ifdef QT_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) {
+-	QtFontFamily *family = db->family( f->qtname, TRUE );
+-	family->rawName = f->rawname;
+-	family->hasXft = TRUE;
+-        family->synthetic = TRUE;
+-	QtFontFoundry *foundry
+-	    = family->foundry( QString::null,  TRUE );
+-
+-	for ( int i = 0; i < QFont::LastPrivateScript; ++i ) {
+-            if (i == QFont::UnknownScript)
+-                continue;
+-	    family->scripts[i] = QtFontFamily::Supported;
+-        }
++                       
++        checkXftMatrix( family );
+ 
+-	QtFontStyle::Key styleKey;
+-	styleKey.oblique = FALSE;
+-	for (int i = 0; i < 4; ++i) {
+-	    styleKey.italic = (i%2);
+-	    styleKey.weight = (i > 1) ? QFont::Bold : QFont::Normal;
+-	    QtFontStyle *style = foundry->style( styleKey,  TRUE );
+-	    style->smoothScalable = TRUE;
+-	    QtFontSize *size = style->pixelSize( SMOOTH_SCALABLE, TRUE );
+-	    QtFontEncoding *enc = size->encodingID( -1, 0, 0, 0, 0, TRUE );
+-	    enc->pitch = (f->fixed ? 'm' : 'p');
+-	}
+-	++f;
+-    }
+-#endif
++    return true;
+ }
+ 
+ #ifndef QT_XFT2
+@@ -1231,17 +1259,39 @@ static inline void checkXftCoverage( QtF
+ 
+ static void load( const QString &family = QString::null, int script = -1 )
+ {
+-#ifdef QT_XFT2
+-    if (qt_has_xft)
+-	return;
+-#endif
+-
+ #ifdef QFONTDATABASE_DEBUG
+     QTime t;
+     t.start();
+ #endif
+ 
+     if ( family.isNull() ) {
++#ifndef QT_NO_XFTFREETYPE
++        static bool xft_readall_done = false;
++        if (qt_has_xft && !xft_readall_done) {
++            xft_readall_done = true;
++            XftFontSet  *fonts =
++            	    XftListFonts(QPaintDevice::x11AppDisplay(),
++		         QPaintDevice::x11AppScreen(),
++		         (const char *)0,
++		         XFT_FAMILY, XFT_WEIGHT, XFT_SLANT,
++		         XFT_SPACING, XFT_FILE, XFT_INDEX,
++#ifdef QT_XFT2
++		         FC_CHARSET, FC_FOUNDRY, FC_SCALABLE, FC_PIXEL_SIZE,
++#if FC_VERSION >= 20193
++                         FC_WIDTH,
++#endif
++#endif // QT_XFT2
++		         (const char *)0);
++            for (int i = 0; i < fonts->nfont; i++) {
++                loadXftFont( fonts->fonts[i] );
++            }
++            XftFontSetDestroy (fonts);
++        }
++#ifdef QT_XFT2
++        if (qt_has_xft)
++            return;
++#endif
++#endif // QT_NO_XFTFREETYPE
+ 	if ( script == -1 )
+ 	    loadXlfds( 0, -1 );
+ 	else {
+@@ -1254,12 +1304,38 @@ static void load( const QString &family 
+ 	QtFontFamily *f = db->family( family, TRUE );
+ 	if ( !f->fullyLoaded ) {
+ 
+-#if !defined(QT_NO_XFTFREETYPE) && !defined(QT_XFT2)
++#ifndef QT_NO_XFTFREETYPE
++            if (qt_has_xft) {
++                XftFontSet  *fonts =
++            	    XftListFonts(QPaintDevice::x11AppDisplay(),
++		         QPaintDevice::x11AppScreen(),
++                         XFT_FAMILY, XftTypeString, family.utf8().data(),
++		         (const char *)0,
++		         XFT_FAMILY, XFT_WEIGHT, XFT_SLANT,
++		         XFT_SPACING, XFT_FILE, XFT_INDEX,
++#ifdef QT_XFT2
++		         FC_CHARSET, FC_FOUNDRY, FC_SCALABLE, FC_PIXEL_SIZE,
++#if FC_VERSION >= 20193
++                         FC_WIDTH,
++#endif
++#endif // QT_XFT2
++		         (const char *)0);
++                for (int i = 0; i < fonts->nfont; i++) {
++                    loadXftFont( fonts->fonts[i] );
++                }
++                XftFontSetDestroy (fonts);
++		f->fullyLoaded = TRUE;
++#ifdef QT_XFT2
++                return;
++#endif
++            }
++#ifndef QT_XFT2
+ 	    // need to check Xft coverage
+ 	    if ( f->hasXft && !f->xftScriptCheck ) {
+ 		checkXftCoverage( f );
+ 	    }
+ #endif
++#endif // QT_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 ) ||
+@@ -1305,42 +1381,7 @@ static void initializeDb()
+ #endif // QT_XFT2
+ 
+ #ifdef XFT_MATRIX
+-	for ( int j = 0; j < db->families[i]->count; ++j ) {	// each foundry
+-	    QtFontFoundry *foundry = db->families[i]->foundries[j];
+-	    for ( int k = 0; k < foundry->count; ++k ) {
+-		QtFontStyle *style = foundry->styles[k];
+-		if ( style->key.italic || style->key.oblique ) continue;
+-
+-		QtFontSize *size = style->pixelSize( SMOOTH_SCALABLE );
+-		if ( ! size ) continue;
+-		QtFontEncoding *enc = size->encodingID( -1, 0, 0, 0, 0, TRUE );
+-		if ( ! enc ) continue;
+-
+-		QtFontStyle::Key key = style->key;
+-
+-		// does this style have an italic equivalent?
+-		key.italic = TRUE;
+-		QtFontStyle *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;
+-
+-		QtFontSize *equiv_size = equiv->pixelSize( SMOOTH_SCALABLE, TRUE );
+-		QtFontEncoding *equiv_enc = equiv_size->encodingID( -1, 0, 0, 0, 0, TRUE );
+-
+-		// keep the same pitch
+-		equiv_enc->pitch = enc->pitch;
+-	    }
+-	}
++        checkXftMatrix( db->families[i] );
+ #endif // XFT_MATRIX
+     }
+ #endif