kcharsets.cpp

monqueror一个很具有参考价值的源玛

QFont KCharsets::fontForChar (const QChar &c, const QFont &_f) const
{
#if _CODE_BY_YMWEI
    MGFontInfo fi(_f);
#else
    QFontInfo fi(_f);
#endif

    // unicode can display any char...
    if (fi.charSet() == QFont::Unicode) return _f;

    // here comes the work...
    // we look at the range the char is in, and try charsets which can
    // map the char...
    QFont f = _f;
    int uc = c.unicode();

    if( uc < 0xff ) // 8859-1
        setQFont( f, QFont::Latin1 );
    else if ( uc > 0x0400 && uc < 0x0460 )
        setQFont( f, QFont::Latin5 );
    else if ( uc > 0x0600 && uc < 0x0660 )
        setQFont( f, QFont::Latin6 );
    else if ( uc > 0x0380 && uc < 0x03e0 )
        setQFont( f, QFont::Latin7 );
    else if ( uc >= 0x05d0 && uc < 0x05f0 )
        setQFont( f, QFont::Latin8 );
    else if ( hasUnicode( f ) ) // don't know, let's try Unicode
        setQFont( f, QFont::Unicode );

    return f;
}

QStringList KCharsets::availableFamilies( QFont::CharSet ch )
{
    QStringList families;
    QValueList<QCString> chFamilies = (*d->availableCharsets)[ch];
    for ( QValueList<QCString>::Iterator it = chFamilies.begin(); it != chFamilies.end(); ++it ) {
        families.append( QString(*it) );
    }
    return families;
}

void KCharsets::setQFont(QFont &f, QString charset) const
{
    setQFont(f, nameToID(charset));
}

void KCharsets::setQFont(QFont &f, QFont::CharSet charset) const
{
#if _CODE_BY_YMWEI
    if(MGFontInfo(f).charSet() == charset)
#else
    if(QFontInfo(f).charSet() == charset)
#endif
        return;

    if(charset == QFont::AnyCharSet)
    {
        f.setCharSet(QFont::AnyCharSet);
        return;
    }

    if(!d->db)
#if _CODE_BY_YMWEI
        d->db = new MGFontDatabase;
#else
        d->db = new QFontDatabase;
#endif

    d->getAvailableCharsets();

    QCString family = f.family().latin1();

    QValueList<QCString> chFamilies = (*d->availableCharsets)[charset];
    if(chFamilies.contains(family)) {
        f.setCharSet(charset);
        return;
    }

    // ok... we don't have the charset in the specified family, let's
    // try to find a replacement.

    if(chFamilies.count() != 0) {
        f.setFamily(chFamilies.first());
        f.setCharSet(charset);
        return;
    }

    QValueList<QCString> ucFamilies = (*d->availableCharsets)[QFont::Unicode];
    if(ucFamilies.contains(family)) {
        // just setting the charset to unicode should work
        f.setCharSet(QFont::Unicode);
        return;
    }

    // Unicode and any family
    if(ucFamilies.count() != 0) {
        f.setFamily(ucFamilies.first());
        f.setCharSet(QFont::Unicode);
        return;
    }

    // give up -- just use something
    f.setCharSet(QFont::AnyCharSet);
    return;
}

bool KCharsets::isAvailable(const QString &charset)
{
    QFont::CharSet cs = nameToID(charset);
    return cs == QFont::AnyCharSet ? false : isAvailable(cs);
}

bool KCharsets::isAvailable(QFont::CharSet charset)
{
    d->getAvailableCharsets();

    if(d->availableCharsets->contains(charset))
        return true;
    return false;
}

QFont::CharSet KCharsets::charsetForLocale()
{
#if 0
    return nameToID(KGlobal::locale()->charset());
#else
    return QFont::Set_GBK;
    // return nameToID("iso8859-1");
#endif
}

bool KCharsets::hasUnicode(QString family) const
{
    d->getAvailableCharsets();
    if(!d->availableCharsets->contains(QFont::Unicode))
        return false;
    QValueList<QCString> lst = (*d->availableCharsets)[QFont::Unicode];
    if(lst.contains(family.latin1()))
        return true;
    return false;
}

bool KCharsets::hasUnicode(QFont &font) const
{
    return hasUnicode(font.family());
}


QString KCharsets::xCharsetName(QFont::CharSet charSet) const
{
    switch( charSet )
    {
    case QFont::Unicode:
        return "iso10646-1";
    case QFont::ISO_8859_1:
        return "iso8859-1";
    case QFont::ISO_8859_2:
        return "iso8859-2";
    case QFont::ISO_8859_3:
        return "iso8859-3";
    case QFont::ISO_8859_4:
        return "iso8859-4";
    case QFont::ISO_8859_5:
        return "iso8859-5";
    case QFont::ISO_8859_6:
        return "iso8859-6";
    case QFont::ISO_8859_7:
        return "iso8859-7";
    case QFont::ISO_8859_8:
        return "iso8859-8";
    case QFont::ISO_8859_9:
        return "iso8859-9";
    case QFont::ISO_8859_10:
        return "iso8859-10";
    case QFont::ISO_8859_11: // most of them are actually named as tis620
        return "tis620-0";
    case QFont::ISO_8859_12:
        return "iso8859-12";
    case QFont::ISO_8859_13:
        return "iso8859-13";
    case QFont::ISO_8859_14:
        return "iso8859-14";
    case QFont::ISO_8859_15:
        return "iso8859-15";
    case QFont::KOI8R:
        return "koi8-r";
#if QT_VERSION > 220
    case QFont::KOI8U:
        return "koi8-u";
#endif
    case QFont::Set_Ko:
        return "ksc5601.1987-0";
    case QFont::Set_Ja:
        return "jisx0208.1983-0";
    case QFont::TSCII:
        return "tscii-0";
    case QFont::Set_Th_TH:
        return "unknown";
    case QFont::Set_GBK:
    case QFont::Set_Zh:
            return "set-gbk";
    case QFont::Set_Zh_TW:
    case QFont::Set_Big5:
        return "big5-0";
    case QFont::AnyCharSet:
    default:
        break;
    }
    return "*-*";
}

QFont::CharSet KCharsets::nameToID(QString name) const
{
    name = name.lower();

    int i = 0;
    while(i < CHARSETS_COUNT)
    {
        if( name == charsetsStr[i] )
            return charsetsIds[i];
        i++;
    }

    i = 0;
    while(i < CHARSETS_COUNT)
    {
        if( name == xNames[i] )
            return charsetsIds[i];
        i++;
    }
    return QFont::AnyCharSet;
}

QString KCharsets::name(const QFont &f)
{
    QFont::CharSet c = f.charSet();

    return name(c);
}

QString KCharsets::name(QFont::CharSet c)
{
    int i = 0;

    while(i < CHARSETS_COUNT)
    {
        if( c == charsetsIds[i] )
            return charsetsStr[i];
        i++;
    }
    return "any";
}

/*
QFont::CharSet KCharsets::xNameToID(QString name) const
{
    name = name.lower();

    int i = 0;
    while(i < CHARSETS_COUNT)
    {
       if( !QRegExp( xNames[i] ).match(name) )
            return charsetsIds[i];
        i++;
    }
    return QFont::AnyCharSet;
}
*/

#if 0
QTextCodec *KCharsets::codecForName(const QString &n) const
{
    bool b;
    return codecForName( n, b );
}

QTextCodec *KCharsets::codecForName(const QString &n, bool &ok) const
{
    ok = true;
  if (n.isEmpty()) {
    QString lc = KGlobal::locale()->charset();
    QString lc = "iso8859-1";
    if (lc.isEmpty())
      return QTextCodec::codecForName("iso8859-1");
    return codecForName(lc);
  }

  QString name = n.lower();
  QTextCodec *codec = QTextCodec::codecForName(name.latin1());

    if(codec)
        return codec;

    KConfig conf( "charsets", true );

    // these codecs are built into Qt, but the name given for the codec is different,
    // so QTextCodec did not recognise it.
    conf.setGroup("builtin");

    QString cname = conf.readEntry(name);
    if(!cname.isEmpty() && !cname.isNull())
        codec = QTextCodec::codecForName(cname.latin1());

    if(codec) return codec;

    conf.setGroup("general");
    QString dir = conf.readEntry("i18ndir", QString::fromLatin1("/usr/share/i18n/charmaps"));
    dir += "/";

    // these are codecs not included in Qt. They can be build up if the corresponding charmap
    // is available in the charmap directory.
    conf.setGroup("aliases");

    cname = conf.readEntry(name);
    if(cname.isNull() || cname.isEmpty())
        cname = name;
    cname = cname.upper();

    codec = QTextCodec::loadCharmapFile(dir + cname);

    if(codec)
        return codec;

    // this also failed, the last resort is now to take some compatibility charmap

    conf.setGroup("conversionHints");
    cname = cname.lower();
    cname = conf.readEntry(cname);

    if(!cname.isEmpty() && !cname.isNull())
        codec = QTextCodec::codecForName(cname.latin1());

    if(codec)
        return codec;

    // could not assign a codec, let's return Latin1
    ok = false;
    return QTextCodec::codecForName("iso8859-1");
}
#endif

QFont::CharSet KCharsets::charsetForEncoding(const QString &e) const
{
#if 0
    QString encoding = e.lower();
    KConfig conf( "charsets", true );
    conf.setGroup("charsetsForEncoding");

    QString enc = conf.readEntry(encoding);
    if(enc.isEmpty()) {
        conf.setGroup("builtin");
        encoding = conf.readEntry(encoding);
        encoding = encoding.lower();
        conf.setGroup("charsetsForEncoding");
    }

    QStringList charsets;
    charsets = conf.readListEntry(encoding);

    // iterate thorugh the list and find the first charset that is available
    for ( QStringList::Iterator it = charsets.begin(); it != charsets.end(); ++it ) {
        if( const_cast<KCharsets *>(this)->isAvailable(*it) ) {
            return nameToID(*it);
        }
    }
    // let's hope the system has a unicode font...
    return QFont::Unicode;
#else
//    return nameToID ("iso8859-1");
    return QFont::Set_GBK;
#endif
}