static QString deviceDescription(io_registry_entry_t ioRegistryEntry)
{
QString result = searchStringProperty(ioRegistryEntry, QCFString(kIOPropertyProductNameKey));
if (result.isEmpty())
result = searchStringProperty(ioRegistryEntry, QCFString(kUSBProductString));
if (result.isEmpty())
result = searchStringProperty(ioRegistryEntry, QCFString("BTName"));
return result;
}
static QFontEngine *loadFromDatabase(QFontDef &req, const QFontPrivate *d)
{
#if defined(QT_MAC_USE_COCOA)
QCFString fontName = NULL;
#else
ATSFontFamilyRef familyRef = 0;
ATSFontRef fontRef = 0;
#endif
QStringList family_list = familyList(req);
const char *stylehint = styleHint(req);
if (stylehint)
family_list << QLatin1String(stylehint);
// add QFont::defaultFamily() to the list, for compatibility with previous versions
family_list << QApplication::font().defaultFamily();
QMutexLocker locker(fontDatabaseMutex());
QFontDatabasePrivate *db = privateDb();
if (!db->count)
initializeDb();
for (int i = 0; i < family_list.size(); ++i) {
for (int k = 0; k < db->count; ++k) {
if (db->families[k]->name.compare(family_list.at(i), Qt::CaseInsensitive) == 0) {
QByteArray family_name = db->families[k]->name.toUtf8();
#if defined(QT_MAC_USE_COCOA)
QCFType<CTFontRef> ctFont = CTFontCreateWithName(QCFString(db->families[k]->name), 12, NULL);
if (ctFont) {
fontName = CTFontCopyFullName(ctFont);
goto found;
}
#else
familyRef = ATSFontFamilyFindFromName(QCFString(db->families[k]->name), kATSOptionFlagsDefault);
if (familyRef) {
fontRef = ATSFontFindFromName(QCFString(db->families[k]->name), kATSOptionFlagsDefault);
goto found;
}
#endif
}
}
}
found:
#ifdef QT_MAC_USE_COCOA
if (fontName)
return new QCoreTextFontEngineMulti(fontName, req, d->kerning);
#else
if (familyRef) {
QCFString actualName;
if (ATSFontFamilyGetName(familyRef, kATSOptionFlagsDefault, &actualName) == noErr)
req.family = actualName;
return new QFontEngineMacMulti(familyRef, fontRef, req, d->kerning);
}
#endif
return NULL;
}
void qt_mac_to_pascal_string(const QString &s, Str255 str, TextEncoding encoding, int len)
{
if(len == -1)
len = s.length();
#if 0
UnicodeMapping mapping;
mapping.unicodeEncoding = CreateTextEncoding(kTextEncodingUnicodeDefault,
kTextEncodingDefaultVariant,
kUnicode16BitFormat);
mapping.otherEncoding = (encoding ? encoding : );
mapping.mappingVersion = kUnicodeUseLatestMapping;
UnicodeToTextInfo info;
OSStatus err = CreateUnicodeToTextInfo(&mapping, &info);
if(err != noErr) {
qDebug("Qt: internal: Unable to create pascal string '%s'::%d [%ld]",
s.left(len).latin1(), (int)encoding, err);
return;
}
const int unilen = len * 2;
const UniChar *unibuf = (UniChar *)s.unicode();
ConvertFromUnicodeToPString(info, unilen, unibuf, str);
DisposeUnicodeToTextInfo(&info);
#else
Q_UNUSED(encoding);
CFStringGetPascalString(QCFString(s), str, 256, CFStringGetSystemEncoding());
#endif
}
QFont qfontForThemeFont(ThemeFontID themeID)
{
#ifndef QT_MAC_USE_COCOA
static const ScriptCode Script = smRoman;
Str255 f_name;
SInt16 f_size;
Style f_style;
GetThemeFont(themeID, Script, f_name, &f_size, &f_style);
extern QString qt_mac_from_pascal_string(const Str255); //qglobal.cpp
return QFont(qt_mac_from_pascal_string(f_name), f_size,
(f_style & ::bold) ? QFont::Bold : QFont::Normal,
(bool)(f_style & ::italic));
#else
QCFType<CTFontRef> ctfont = CopyCTThemeFont(themeID);
QString familyName = QCFString(CTFontCopyFamilyName(ctfont));
QCFType<CFDictionaryRef> dict = CTFontCopyTraits(ctfont);
CFNumberRef num = static_cast<CFNumberRef>(CFDictionaryGetValue(dict, kCTFontWeightTrait));
float fW;
CFNumberGetValue(num, kCFNumberFloat32Type, &fW);
QFont::Weight wght = fW > 0. ? QFont::Bold : QFont::Normal;
num = static_cast<CFNumberRef>(CFDictionaryGetValue(dict, kCTFontSlantTrait));
CFNumberGetValue(num, kCFNumberFloatType, &fW);
bool italic = (fW != 0.0);
return QFont(familyName, CTFontGetSize(ctfont), wght, italic);
#endif
}
void QStorageInfoPrivate::retrieveLabel()
{
#if !defined(Q_OS_IOS)
// deprecated since 10.8
FSRef ref;
FSPathMakeRef(reinterpret_cast<const UInt8*>(QFile::encodeName(rootPath).constData()),
&ref,
Q_NULLPTR);
// deprecated since 10.8
FSCatalogInfo catalogInfo;
OSErr error;
error = FSGetCatalogInfo(&ref, kFSCatInfoVolume, &catalogInfo, Q_NULLPTR, Q_NULLPTR, Q_NULLPTR);
if (error != noErr)
{
return;
}
// deprecated (use CFURLCopyResourcePropertiesForKeys for 10.7 and higher)
HFSUniStr255 volumeName;
error = FSGetVolumeInfo(catalogInfo.volume,
0,
Q_NULLPTR,
kFSVolInfoFSInfo,
Q_NULLPTR,
&volumeName,
Q_NULLPTR);
if (error == noErr)
{
name = QCFString(FSCreateStringFromHFSUniStr(Q_NULLPTR, &volumeName));
}
#endif
}
bool
QMacPasteboard::hasFlavor(QString c_flavor) const
{
if (!paste)
return false;
sync();
ItemCount cnt = 0;
if(PasteboardGetItemCount(paste, &cnt) || !cnt)
return false;
#ifdef DEBUG_PASTEBOARD
qDebug("PasteBoard: hasFlavor [%s]", qPrintable(c_flavor));
#endif
for(uint index = 1; index <= cnt; ++index) {
PasteboardItemID id;
if(PasteboardGetItemIdentifier(paste, index, &id) != noErr)
return false;
PasteboardFlavorFlags flags;
if(PasteboardGetItemFlavorFlags(paste, id, QCFString(c_flavor), &flags) == noErr) {
#ifdef DEBUG_PASTEBOARD
qDebug(" - Found!");
#endif
return true;
}
}
#ifdef DEBUG_PASTEBOARD
qDebug(" - NotFound!");
#endif
return false;
}
QList<QByteArray> QMacPasteboardMimePlainText::convertFromMime(const QString &, QVariant data, QString flavor)
{
QList<QByteArray> ret;
QString string = data.toString();
if(flavor == QCFString(QLatin1String("com.apple.traditional-mac-plain-text")))
ret.append(string.toLatin1());
return ret;
}
bool QMacPasteboardMimeQt3Any::canConvert(const QString &mime, QString flav)
{
loadMimeRegistry();
const int os_flav = UTGetOSTypeFromString(UTTypeCopyPreferredTagWithClass(QCFString(flav), kUTTagClassOSType));
if(mime_registry.contains(mime) && mime_registry[mime] == os_flav)
return true;
return false;
}
void
QMacPasteboard::setMimeData(QMimeData *mime_src)
{
if (!paste)
return;
if (mime == mime_src || (!mime_src && mime && mac_mime_source))
return;
mac_mime_source = false;
delete mime;
mime = mime_src;
QList<QMacPasteboardMime*> availableConverters = QMacPasteboardMime::all(mime_type);
if (mime != 0) {
clear_helper();
QStringList formats = mime_src->formats();
#ifdef QT_MAC_USE_COCOA
// QMimeData sub classes reimplementing the formats() might not expose the
// temporary "application/x-qt-mime-type-name" mimetype. So check the existence
// of this mime type while doing drag and drop.
QString dummyMimeType(QLatin1String("application/x-qt-mime-type-name"));
if (!formats.contains(dummyMimeType)) {
QByteArray dummyType = mime_src->data(dummyMimeType);
if (!dummyType.isEmpty()) {
formats.append(dummyMimeType);
}
}
#endif
for(int f = 0; f < formats.size(); ++f) {
QString mimeType = formats.at(f);
for (QList<QMacPasteboardMime *>::Iterator it = availableConverters.begin(); it != availableConverters.end(); ++it) {
QMacPasteboardMime *c = (*it);
QString flavor(c->flavorFor(mimeType));
if(!flavor.isEmpty()) {
QVariant mimeData = static_cast<QMacMimeData*>(mime_src)->variantData(mimeType);
#if 0
//### Grrr, why didn't I put in a virtual int QMacPasteboardMime::count()? --Sam
const int numItems = c->convertFromMime(mimeType, mimeData, flavor).size();
#else
int numItems = 1; //this is a hack but it is much faster than allowing conversion above
if(c->convertorName() == QLatin1String("FileURL"))
numItems = mime_src->urls().count();
#endif
for(int item = 0; item < numItems; ++item) {
const int itemID = item+1; //id starts at 1
promises.append(QMacPasteboard::Promise(itemID, c, mimeType, mimeData, item));
PasteboardPutItemFlavor(paste, (PasteboardItemID)itemID, QCFString(flavor), 0, kPasteboardFlavorNoFlags);
#ifdef DEBUG_PASTEBOARD
qDebug(" - adding %d %s [%s] <%s> [%d]",
itemID, qPrintable(mimeType), qPrintable(flavor), qPrintable(c->convertorName()), item);
#endif
}
}
}
}
}
}
QString QMacPasteboardMimeQt3Any::mimeFor(QString flav)
{
loadMimeRegistry();
const int os_flav = UTGetOSTypeFromString(UTTypeCopyPreferredTagWithClass(QCFString(flav), kUTTagClassOSType));
for(QMap<QString, int>::const_iterator it = mime_registry.constBegin();
it != mime_registry.constEnd(); ++it) {
if(it.value() == os_flav)
return QString::fromLatin1(it.key().toLatin1());
}
return QString();
}
//static
QString QFileSystemEngine::bundleName(const QFileSystemEntry &entry)
{
QCFType<CFURLRef> url = CFURLCreateWithFileSystemPath(0, QCFString(entry.filePath()),
kCFURLPOSIXPathStyle, true);
if (QCFType<CFDictionaryRef> dict = CFBundleCopyInfoDictionaryForURL(url)) {
if (CFTypeRef name = (CFTypeRef)CFDictionaryGetValue(dict, kCFBundleNameKey)) {
if (CFGetTypeID(name) == CFStringGetTypeID())
return QCFString::toQString((CFStringRef)name);
}
}
return QString();
}
QMacPasteboard::~QMacPasteboard()
{
// commit all promises for paste after exit close
for (int i = 0; i < promises.count(); ++i) {
const Promise &promise = promises.at(i);
QCFString flavor = QCFString(promise.convertor->flavorFor(promise.mime));
promiseKeeper(paste, (PasteboardItemID)promise.itemId, flavor, this);
}
if(paste)
CFRelease(paste);
}
static bool lsOpen(const QUrl &url)
{
if (!url.isValid() || url.scheme().isEmpty())
return false;
QCFType<CFURLRef> cfUrl = CFURLCreateWithString(0, QCFString(QString::fromLatin1(url.toEncoded())), 0);
if (cfUrl == 0)
return false;
const OSStatus err = LSOpenCFURLRef(cfUrl, 0);
return (err == noErr);
}
void QStorageInfoPrivate::retrieveUrlProperties(bool initRootPath)
{
static const void *rootPathKeys[] = { kCFURLVolumeURLKey };
static const void *propertyKeys[] = {
// kCFURLVolumeNameKey, // 10.7
// kCFURLVolumeLocalizedNameKey, // 10.7
kCFURLVolumeTotalCapacityKey,
kCFURLVolumeAvailableCapacityKey,
// kCFURLVolumeIsReadOnlyKey // 10.7
};
size_t size = (initRootPath ? sizeof(rootPathKeys) : sizeof(propertyKeys)) / sizeof(void*);
QCFType<CFArrayRef> keys = CFArrayCreate(kCFAllocatorDefault,
initRootPath ? rootPathKeys : propertyKeys,
size,
Q_NULLPTR);
if (!keys)
return;
const QCFString cfPath = rootPath;
if (initRootPath)
rootPath.clear();
QCFType<CFURLRef> url = CFURLCreateWithFileSystemPath(kCFAllocatorDefault,
cfPath,
kCFURLPOSIXPathStyle,
true);
if (!url)
return;
CFErrorRef error;
QCFType<CFDictionaryRef> map = CFURLCopyResourcePropertiesForKeys(url, keys, &error);
if (!map)
return;
if (initRootPath) {
const CFURLRef rootUrl = (CFURLRef)CFDictionaryGetValue(map, kCFURLVolumeURLKey);
if (!rootUrl)
return;
rootPath = QCFString(CFURLCopyFileSystemPath(rootUrl, kCFURLPOSIXPathStyle));
valid = true;
ready = true;
return;
}
bytesTotal = CFDictionaryGetInt64(map, kCFURLVolumeTotalCapacityKey);
bytesAvailable = CFDictionaryGetInt64(map, kCFURLVolumeAvailableCapacityKey);
bytesFree = bytesAvailable;
}
bool QMacPrintEngine::begin(QPaintDevice *dev)
{
Q_D(QMacPrintEngine);
if (d->state == QPrinter::Idle && d->session == 0) // Need to reinitialize
d->initialize();
d->paintEngine->state = state;
d->paintEngine->begin(dev);
Q_ASSERT_X(d->state == QPrinter::Idle, "QMacPrintEngine", "printer already active");
if (PMSessionValidatePrintSettings(d->session, d->settings, kPMDontWantBoolean) != noErr
|| PMSessionValidatePageFormat(d->session, d->format, kPMDontWantBoolean) != noErr) {
d->state = QPrinter::Error;
return false;
}
if (!d->outputFilename.isEmpty()) {
QCFType<CFURLRef> outFile = CFURLCreateWithFileSystemPath(kCFAllocatorSystemDefault,
QCFString(d->outputFilename),
kCFURLPOSIXPathStyle,
false);
if (PMSessionSetDestination(d->session, d->settings, kPMDestinationFile,
kPMDocumentFormatPDF, outFile) != noErr) {
qWarning("QMacPrintEngine::begin: Problem setting file [%s]", d->outputFilename.toUtf8().constData());
return false;
}
}
OSStatus status = noErr;
#if (MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4)
if (QSysInfo::MacintoshVersion >= QSysInfo::MV_10_4) {
status = d->shouldSuppressStatus() ? PMSessionBeginCGDocumentNoDialog(d->session, d->settings, d->format)
: PMSessionBeginCGDocument(d->session, d->settings, d->format);
} else
#endif
{
#ifndef Q_OS_MAC64
status = d->shouldSuppressStatus() ? PMSessionBeginDocumentNoDialog(d->session, d->settings, d->format)
: PMSessionBeginDocument(d->session, d->settings, d->format);
#endif
}
if (status != noErr) {
d->state = QPrinter::Error;
return false;
}
d->state = QPrinter::Active;
setActive(true);
d->newPage_helper();
return true;
}
QFont qfontForThemeFont(ThemeFontID themeID)
{
QCFType<CTFontRef> ctfont = CopyCTThemeFont(themeID);
QString familyName = QCFString(CTFontCopyFamilyName(ctfont));
QCFType<CFDictionaryRef> dict = CTFontCopyTraits(ctfont);
CFNumberRef num = static_cast<CFNumberRef>(CFDictionaryGetValue(dict, kCTFontWeightTrait));
float fW;
CFNumberGetValue(num, kCFNumberFloat32Type, &fW);
QFont::Weight wght = fW > 0. ? QFont::Bold : QFont::Normal;
num = static_cast<CFNumberRef>(CFDictionaryGetValue(dict, kCTFontSlantTrait));
CFNumberGetValue(num, kCFNumberFloatType, &fW);
bool italic = (fW != 0.0);
return QFont(familyName, CTFontGetSize(ctfont), wght, italic);
}
QString QMacPasteboardMimeQt3Any::flavorFor(const QString &mime)
{
const int os_flav = registerMimeType(mime);
QCFType<CFArrayRef> ids = UTTypeCreateAllIdentifiersForTag(0, kUTTagClassOSType,
QCFString(UTCreateStringForOSType(os_flav)));
if(ids) {
const int type_count = CFArrayGetCount(ids);
if(type_count) {
if(type_count > 1)
qDebug("Can't happen!");
return QCFString::toQString((CFStringRef)CFArrayGetValueAtIndex(ids, 0));
}
}
return QString();
}
QVariant QMacPasteboardMimePlainText::convertToMime(const QString &mimetype, QList<QByteArray> data, QString flavor)
{
if(data.count() > 1)
qWarning("QMacPasteboardMimePlainText: Cannot handle multiple member data");
const QByteArray &firstData = data.first();
QVariant ret;
if(flavor == QCFString(QLatin1String("com.apple.traditional-mac-plain-text"))) {
QCFString str(CFStringCreateWithBytes(kCFAllocatorDefault,
reinterpret_cast<const UInt8 *>(firstData.constData()),
firstData.size(), CFStringGetSystemEncoding(), false));
ret = QString(str);
} else {
qWarning("QMime::convertToMime: unhandled mimetype: %s", qPrintable(mimetype));
}
return ret;
}
QString QFontDatabase::resolveFontFamilyAlias(const QString &family)
{
QCFString expectedFamily = QCFString(family);
QCFType<CFMutableDictionaryRef> attributes = CFDictionaryCreateMutable(NULL, 0,
&kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
CFDictionaryAddValue(attributes, kCTFontFamilyNameAttribute, expectedFamily);
QCFType<CTFontDescriptorRef> descriptor = CTFontDescriptorCreateWithAttributes(attributes);
QCFType<CFMutableSetRef> mandatoryAttributes = CFSetCreateMutable(NULL, 0, &kCFTypeSetCallBacks);
CFSetAddValue(mandatoryAttributes, kCTFontFamilyNameAttribute);
QCFType<CTFontRef> font = CTFontCreateWithFontDescriptor(descriptor, 0.0, NULL);
QCFType<CTFontDescriptorRef> matched = CTFontDescriptorCreateMatchingFontDescriptor(descriptor, mandatoryAttributes);
if (!matched)
return family;
QCFString familyName = (CFStringRef) CTFontDescriptorCopyLocalizedAttribute(matched, kCTFontFamilyNameAttribute, NULL);
return familyName;
}
QString QFSFileEngine::fileName(FileName file) const
{
Q_D(const QFSFileEngine);
if (file == BundleName) {
#if !defined(QWS) && defined(Q_OS_MAC)
QCFType<CFURLRef> url = CFURLCreateWithFileSystemPath(0, QCFString(d->filePath),
kCFURLPOSIXPathStyle, true);
if(CFDictionaryRef dict = CFBundleCopyInfoDictionaryForURL(url)) {
if(CFTypeRef name = (CFTypeRef)CFDictionaryGetValue(dict, kCFBundleNameKey)) {
if(CFGetTypeID(name) == CFStringGetTypeID())
return QCFString::toQString((CFStringRef)name);
}
}
#endif
return QString();
} else if (file == BaseName) {
int slash = d->filePath.lastIndexOf(QLatin1Char('/'));
if (slash != -1)
return d->filePath.mid(slash + 1);
} else if (file == PathName) {
int slash = d->filePath.lastIndexOf(QLatin1Char('/'));
if (slash == -1)
return QLatin1String(".");
else if (!slash)
return QLatin1String("/");
return d->filePath.left(slash);
} else if (file == AbsoluteName || file == AbsolutePathName) {
QString ret;
if (d->filePath.isEmpty() || !d->filePath.startsWith(QLatin1Char('/')))
ret = QDir::currentPath();
if (!d->filePath.isEmpty() && d->filePath != QLatin1String(".")) {
if (!ret.isEmpty() && !ret.endsWith(QLatin1Char('/')))
ret += QLatin1Char('/');
ret += d->filePath;
}
if (ret == QLatin1String("/"))
return ret;
bool isDir = ret.endsWith(QLatin1Char('/'));
ret = QDir::cleanPath(ret);
if (isDir)
ret += QLatin1String("/");
if (file == AbsolutePathName) {
int slash = ret.lastIndexOf(QLatin1Char('/'));
if (slash == -1)
return QDir::currentPath();
else if (!slash)
return QLatin1String("/");
return ret.left(slash);
}
return ret;
} else if (file == CanonicalName || file == CanonicalPathName) {
if (!(fileFlags(ExistsFlag) & ExistsFlag))
return QString();
QString ret = QFSFileEnginePrivate::canonicalized(fileName(AbsoluteName));
if (!ret.isEmpty() && file == CanonicalPathName) {
int slash = ret.lastIndexOf(QLatin1Char('/'));
if (slash == -1)
ret = QDir::currentPath();
else if (slash == 0)
ret = QLatin1String("/");
ret = ret.left(slash);
}
return ret;
} else if (file == LinkName) {
if (d->isSymlink()) {
#if defined(__GLIBC__) && !defined(PATH_MAX)
#define PATH_CHUNK_SIZE 256
char *s = 0;
int len = -1;
int size = PATH_CHUNK_SIZE;
while (1) {
s = (char *) ::realloc(s, size);
if (s == 0) {
len = -1;
break;
}
len = ::readlink(d->nativeFilePath.constData(), s, size);
if (len < 0) {
::free(s);
break;
}
if (len < size) {
break;
}
size *= 2;
}
#else
char s[PATH_MAX+1];
int len = readlink(d->nativeFilePath.constData(), s, PATH_MAX);
#endif
if (len > 0) {
QString ret;
if (S_ISDIR(d->st.st_mode) && s[0] != '/') {
QDir parent(d->filePath);
parent.cdUp();
ret = parent.path();
if (!ret.isEmpty() && !ret.endsWith(QLatin1Char('/')))
ret += QLatin1Char('/');
}
s[len] = '\0';
ret += QFile::decodeName(QByteArray(s));
#if defined(__GLIBC__) && !defined(PATH_MAX)
::free(s);
#endif
if (!ret.startsWith(QLatin1Char('/'))) {
if (d->filePath.startsWith(QLatin1Char('/'))) {
ret.prepend(d->filePath.left(d->filePath.lastIndexOf(QLatin1Char('/')))
+ QLatin1Char('/'));
} else {
ret.prepend(QDir::currentPath() + QLatin1Char('/'));
}
}
ret = QDir::cleanPath(ret);
if (ret.size() > 1 && ret.endsWith(QLatin1Char('/')))
ret.chop(1);
return ret;
}
}
#if !defined(QWS) && defined(Q_OS_MAC)
{
FSRef fref;
if (FSPathMakeRef((const UInt8 *)QFile::encodeName(QDir::cleanPath(d->filePath)).data(), &fref, 0) == noErr) {
Boolean isAlias, isFolder;
if (FSResolveAliasFile(&fref, true, &isFolder, &isAlias) == noErr && isAlias) {
AliasHandle alias;
if (FSNewAlias(0, &fref, &alias) == noErr && alias) {
CFStringRef cfstr;
if (FSCopyAliasInfo(alias, 0, 0, &cfstr, 0, 0) == noErr)
return QCFString::toQString(cfstr);
}
}
}
}
#endif
return QString();
}
return d->filePath;
}
/*!
\reimp
*/
QAbstractFileEngine::FileFlags QFSFileEngine::fileFlags(FileFlags type) const
{
Q_D(const QFSFileEngine);
// Force a stat, so that we're guaranteed to get up-to-date results
if (type & QAbstractFileEngine::FileFlag(QAbstractFileEngine::Refresh)) {
d->tried_stat = 0;
d->need_lstat = 1;
}
QAbstractFileEngine::FileFlags ret = 0;
bool exists = d->doStat();
if (!exists && !d->isSymlink())
return ret;
if (exists && (type & PermsMask)) {
if (d->st.st_mode & S_IRUSR)
ret |= ReadOwnerPerm;
if (d->st.st_mode & S_IWUSR)
ret |= WriteOwnerPerm;
if (d->st.st_mode & S_IXUSR)
ret |= ExeOwnerPerm;
if (d->st.st_mode & S_IRUSR)
ret |= ReadUserPerm;
if (d->st.st_mode & S_IWUSR)
ret |= WriteUserPerm;
if (d->st.st_mode & S_IXUSR)
ret |= ExeUserPerm;
if (d->st.st_mode & S_IRGRP)
ret |= ReadGroupPerm;
if (d->st.st_mode & S_IWGRP)
ret |= WriteGroupPerm;
if (d->st.st_mode & S_IXGRP)
ret |= ExeGroupPerm;
if (d->st.st_mode & S_IROTH)
ret |= ReadOtherPerm;
if (d->st.st_mode & S_IWOTH)
ret |= WriteOtherPerm;
if (d->st.st_mode & S_IXOTH)
ret |= ExeOtherPerm;
}
if (type & TypesMask) {
#if !defined(QWS) && defined(Q_OS_MAC)
bool foundAlias = false;
{
FSRef fref;
if (FSPathMakeRef((const UInt8 *)QFile::encodeName(QDir::cleanPath(d->filePath)).data(),
&fref, NULL) == noErr) {
Boolean isAlias, isFolder;
if (FSIsAliasFile(&fref, &isAlias, &isFolder) == noErr && isAlias) {
foundAlias = true;
ret |= LinkType;
}
}
}
if (!foundAlias)
#endif
{
if ((type & LinkType) && d->isSymlink())
ret |= LinkType;
if (exists && (d->st.st_mode & S_IFMT) == S_IFREG)
ret |= FileType;
else if (exists && (d->st.st_mode & S_IFMT) == S_IFDIR)
ret |= DirectoryType;
#if !defined(QWS) && defined(Q_OS_MAC)
if((ret & DirectoryType) && (type & BundleType)) {
QCFType<CFURLRef> url = CFURLCreateWithFileSystemPath(0, QCFString(d->filePath),
kCFURLPOSIXPathStyle, true);
UInt32 type, creator;
if(CFBundleGetPackageInfoInDirectory(url, &type, &creator))
ret |= BundleType;
}
#endif
}
}
if (type & FlagsMask) {
ret |= LocalDiskFlag;
if (exists)
ret |= ExistsFlag;
if (fileName(BaseName)[0] == QLatin1Char('.')
#if !defined(QWS) && defined(Q_OS_MAC)
|| _q_isMacHidden(d->filePath)
#endif
)
ret |= HiddenFlag;
if (d->filePath == QLatin1String("/"))
ret |= RootFlag;
}
return ret;
}
QString qt_mac_from_pascal_string(const Str255 pstr)
{
return QCFString(CFStringCreateWithPascalString(0, pstr, CFStringGetSystemEncoding()));
}
bool QLibraryPrivate::load_sys()
{
QFileInfo fi(fileName);
QString path = fi.path();
QString name = fi.fileName();
if (path == QLatin1String(".") && !fileName.startsWith(path))
path.clear();
else
path += QLatin1Char('/');
QStringList suffixes, prefixes("");
if (QLibrary::isLibrary(fileName))
suffixes << "";
if (pluginState != IsAPlugin) {
prefixes << "lib";
#if defined(Q_OS_HPUX)
suffixes << ".sl";
suffixes << QString(".%1").arg(majorVerNum);
#elif defined(Q_OS_AIX)
suffixes << ".a";
#else
suffixes << ".so";
if (majorVerNum > -1)
suffixes << QString(".so.%1").arg(majorVerNum);
#endif
# ifdef Q_OS_MAC
suffixes << ".bundle" << ".dylib";
if (majorVerNum > -1) {
suffixes << QString(".%1.bundle").arg(majorVerNum);
suffixes << QString(".%1.dylib").arg(majorVerNum);
}
#endif
}
QString attempt;
for(int prefix = 0; !pHnd && prefix < prefixes.size(); prefix++) {
for(int suffix = 0; !pHnd && suffix < suffixes.size(); suffix++) {
if (!prefixes.at(prefix).isEmpty() && name.startsWith(prefixes.at(prefix)))
continue;
if (!suffixes.at(suffix).isEmpty() && name.endsWith(suffixes.at(suffix)))
continue;
attempt = path + prefixes.at(prefix) + name + suffixes.at(suffix);
pHnd = DL_PREFIX(dlopen)(QFile::encodeName(attempt), RTLD_LAZY);
}
}
#ifdef Q_OS_MAC
if (!pHnd) {
if(QCFType<CFBundleRef> bundle = CFBundleGetBundleWithIdentifier(QCFString(fileName))) {
QCFType<CFURLRef> url = CFBundleCopyExecutableURL(bundle);
QCFString str = CFURLCopyFileSystemPath(url, kCFURLPOSIXPathStyle);
pHnd = DL_PREFIX(dlopen)(QFile::encodeName(str), RTLD_LAZY);
attempt = str;
}
}
# endif
#if defined(QT_DEBUG_COMPONENT)
if (!pHnd) {
qWarning("QLibrary: Cannot load '%s' :%s", QFile::encodeName(fileName).constData(),
qdlerror());
}
#endif
if (pHnd)
qualifiedFileName = attempt;
return (pHnd != 0);
}
bool QLibraryPrivate::load_sys()
{
QString attempt;
#if !defined(Q_OS_VXWORKS)
QFileInfo fi(fileName);
#if defined(Q_OS_SYMBIAN)
QString path; // In Symbian, always resolve with just the filename
QString name;
// Replace possible ".qtplugin" suffix with ".dll"
if (fi.suffix() == QLatin1String("qtplugin"))
name = fi.completeBaseName() + QLatin1String(".dll");
else
name = fi.fileName();
#else
QString path = fi.path();
QString name = fi.fileName();
if (path == QLatin1String(".") && !fileName.startsWith(path))
path.clear();
else
path += QLatin1Char('/');
#endif
// The first filename we want to attempt to load is the filename as the callee specified.
// Thus, the first attempt we do must be with an empty prefix and empty suffix.
QStringList suffixes(QLatin1String("")), prefixes(QLatin1String(""));
if (pluginState != IsAPlugin) {
#if !defined(Q_OS_SYMBIAN)
prefixes << QLatin1String("lib");
#endif
#if defined(Q_OS_HPUX)
// according to
// http://docs.hp.com/en/B2355-90968/linkerdifferencesiapa.htm
// In PA-RISC (PA-32 and PA-64) shared libraries are suffixed
// with .sl. In IPF (32-bit and 64-bit), the shared libraries
// are suffixed with .so. For compatibility, the IPF linker
// also supports the .sl suffix.
// But since we don't know if we are built on HPUX or HPUXi,
// we support both .sl (and .<version>) and .so suffixes but
// .so is preferred.
# if defined(__ia64)
if (!fullVersion.isEmpty()) {
suffixes << QString::fromLatin1(".so.%1").arg(fullVersion);
} else {
suffixes << QLatin1String(".so");
}
# endif
if (!fullVersion.isEmpty()) {
suffixes << QString::fromLatin1(".sl.%1").arg(fullVersion);
suffixes << QString::fromLatin1(".%1").arg(fullVersion);
} else {
suffixes << QLatin1String(".sl");
}
#elif defined(Q_OS_AIX)
suffixes << ".a";
#elif defined(Q_OS_SYMBIAN)
suffixes << QLatin1String(".dll");
#else
if (!fullVersion.isEmpty()) {
suffixes << QString::fromLatin1(".so.%1").arg(fullVersion);
} else {
suffixes << QLatin1String(".so");
}
#endif
# ifdef Q_OS_MAC
if (!fullVersion.isEmpty()) {
suffixes << QString::fromLatin1(".%1.bundle").arg(fullVersion);
suffixes << QString::fromLatin1(".%1.dylib").arg(fullVersion);
} else {
suffixes << QLatin1String(".bundle") << QLatin1String(".dylib");
}
#endif
}
int dlFlags = 0;
#if defined(QT_HPUX_LD)
dlFlags = DYNAMIC_PATH | BIND_NONFATAL;
if (loadHints & QLibrary::ResolveAllSymbolsHint) {
dlFlags |= BIND_IMMEDIATE;
} else {
dlFlags |= BIND_DEFERRED;
}
#else
if (loadHints & QLibrary::ResolveAllSymbolsHint) {
dlFlags |= RTLD_NOW;
} else {
dlFlags |= RTLD_LAZY;
}
if (loadHints & QLibrary::ExportExternalSymbolsHint) {
dlFlags |= RTLD_GLOBAL;
}
#if !defined(Q_OS_CYGWIN)
else {
#if defined(Q_OS_MAC)
if (QSysInfo::MacintoshVersion >= QSysInfo::MV_10_4)
#endif
dlFlags |= RTLD_LOCAL;
}
#endif
#if defined(Q_OS_AIX) // Not sure if any other platform actually support this thing.
if (loadHints & QLibrary::LoadArchiveMemberHint) {
dlFlags |= RTLD_MEMBER;
}
#endif
#endif // QT_HPUX_LD
bool retry = true;
for(int prefix = 0; retry && !pHnd && prefix < prefixes.size(); prefix++) {
for(int suffix = 0; retry && !pHnd && suffix < suffixes.size(); suffix++) {
if (!prefixes.at(prefix).isEmpty() && name.startsWith(prefixes.at(prefix)))
continue;
if (!suffixes.at(suffix).isEmpty() && name.endsWith(suffixes.at(suffix)))
continue;
if (loadHints & QLibrary::LoadArchiveMemberHint) {
attempt = name;
int lparen = attempt.indexOf(QLatin1Char('('));
if (lparen == -1)
lparen = attempt.count();
attempt = path + prefixes.at(prefix) + attempt.insert(lparen, suffixes.at(suffix));
} else {
attempt = path + prefixes.at(prefix) + name + suffixes.at(suffix);
}
#if defined(QT_HPUX_LD)
pHnd = (void*)shl_load(QFile::encodeName(attempt), dlFlags, 0);
#else
pHnd = dlopen(QFile::encodeName(attempt), dlFlags);
#endif
#if defined(Q_OS_SYMBIAN)
// Never try again in symbian, dlopen already handles the library search logic,
// and there is only one possible suffix.
retry = false;
#else
if (!pHnd && fileName.startsWith(QLatin1Char('/')) && QFile::exists(attempt)) {
// We only want to continue if dlopen failed due to that the shared library did not exist.
// However, we are only able to apply this check for absolute filenames (since they are
// not influenced by the content of LD_LIBRARY_PATH, /etc/ld.so.cache, DT_RPATH etc...)
// This is all because dlerror is flawed and cannot tell us the reason why it failed.
retry = false;
}
#endif
}
}
#ifdef Q_OS_MAC
if (!pHnd) {
if (CFBundleRef bundle = CFBundleGetBundleWithIdentifier(QCFString(fileName))) {
QCFType<CFURLRef> url = CFBundleCopyExecutableURL(bundle);
QCFString str = CFURLCopyFileSystemPath(url, kCFURLPOSIXPathStyle);
pHnd = dlopen(QFile::encodeName(str), dlFlags);
attempt = str;
}
}
#endif
#endif // Q_OS_VXWORKS
if (!pHnd) {
errorString = QLibrary::tr("Cannot load library %1: %2").arg(fileName).arg(qdlerror());
}
if (pHnd) {
qualifiedFileName = attempt;
errorString.clear();
}
return (pHnd != 0);
}
void *QGLContext::getProcAddress(const QString &proc) const
{
return CFBundleGetFunctionPointerForName(QCFType<CFBundleRef>(qt_getOpenGLBundle()),
QCFString(proc));
}
void QFontDatabase::load(const QFontPrivate *d, int script)
{
// sanity checks
if(!QFontCache::instance)
qWarning("QFont: Must construct a QApplication before a QFont");
Q_ASSERT(script >= 0 && script < QUnicodeTables::ScriptCount);
Q_UNUSED(script);
QFontDef req = d->request;
req.pixelSize = qt_mac_pixelsize(req, d->dpi);
// set the point size to 0 to get better caching
req.pointSize = 0;
QFontCache::Key key = QFontCache::Key(req, QUnicodeTables::Common, d->screen);
if(!(d->engineData = QFontCache::instance->findEngineData(key))) {
d->engineData = new QFontEngineData;
QFontCache::instance->insertEngineData(key, d->engineData);
} else {
d->engineData->ref.ref();
}
if(d->engineData->engine) // already loaded
return;
// set it to the actual pointsize, so QFontInfo will do the right thing
req.pointSize = qRound(qt_mac_pointsize(d->request, d->dpi));
QFontEngine *e = QFontCache::instance->findEngine(key);
if(!e && qt_enable_test_font && req.family == QLatin1String("__Qt__Box__Engine__")) {
e = new QTestFontEngine(req.pixelSize);
e->fontDef = req;
}
if(e) {
Q_ASSERT(e->type() == QFontEngine::Multi || e->type() == QFontEngine::TestFontEngine);
e->ref.ref();
d->engineData->engine = e;
return; // the font info and fontdef should already be filled
}
//find the font
QStringList family_list = req.family.split(QLatin1Char(','));
// append the substitute list for each family in family_list
{
QStringList subs_list;
for(QStringList::ConstIterator it = family_list.begin(); it != family_list.end(); ++it)
subs_list += QFont::substitutes(*it);
family_list += subs_list;
}
const char *stylehint = styleHint(req);
if (stylehint)
family_list << QLatin1String(stylehint);
// add QFont::defaultFamily() to the list, for compatibility with
// previous versions
family_list << QApplication::font().defaultFamily();
ATSFontFamilyRef familyRef = 0;
ATSFontRef fontRef = 0;
QFontDatabasePrivate *db = privateDb();
if (!db->count)
initializeDb();
for(int i = 0; i < family_list.size(); ++i) {
for (int k = 0; k < db->count; ++k) {
if (db->families[k]->name.compare(family_list.at(i), Qt::CaseInsensitive) == 0) {
QByteArray family_name = db->families[k]->name.toUtf8();
familyRef = ATSFontFamilyFindFromName(QCFString(db->families[k]->name), kATSOptionFlagsDefault);
if (familyRef) {
fontRef = ATSFontFindFromName(QCFString(db->families[k]->name), kATSOptionFlagsDefault);
goto FamilyFound;
}
}
}
}
FamilyFound:
//fill in the engine's font definition
QFontDef fontDef = d->request; //copy..
if(fontDef.pointSize < 0)
fontDef.pointSize = qt_mac_pointsize(fontDef, d->dpi);
else
fontDef.pixelSize = qt_mac_pixelsize(fontDef, d->dpi);
#if 0
ItemCount name_count;
if(ATSUCountFontNames(fontID, &name_count) == noErr && name_count) {
ItemCount actualName_size;
if(ATSUGetIndFontName(fontID, 0, 0, 0, &actualName_size, 0, 0, 0, 0) == noErr && actualName_size) {
QByteArray actualName(actualName_size);
if(ATSUGetIndFontName(fontID, 0, actualName_size, actualName.data(), &actualName_size, 0, 0, 0, 0) == noErr && actualName_size)
fontDef.family = QString::fromUtf8(actualName);
}
}
#else
{
QCFString actualName;
if(ATSFontFamilyGetName(familyRef, kATSOptionFlagsDefault, &actualName) == noErr)
fontDef.family = actualName;
}
#endif
QFontEngine *engine = new QFontEngineMacMulti(familyRef, fontRef, fontDef, d->kerning);
d->engineData->engine = engine;
engine->ref.ref(); //a ref for the engineData->engine
QFontCache::instance->insertEngine(key, engine);
}
void QFontDatabase::load(const QFontPrivate *d, int script)
{
// sanity checks
if(!qApp)
qWarning("QFont: Must construct a QApplication before a QFont");
Q_ASSERT(script >= 0 && script < QUnicodeTables::ScriptCount);
Q_UNUSED(script);
QFontDef req = d->request;
req.pixelSize = qt_mac_pixelsize(req, d->dpi);
// set the point size to 0 to get better caching
req.pointSize = 0;
QFontCache::Key key = QFontCache::Key(req, QUnicodeTables::Common, d->screen);
if(!(d->engineData = QFontCache::instance()->findEngineData(key))) {
d->engineData = new QFontEngineData;
QFontCache::instance()->insertEngineData(key, d->engineData);
} else {
d->engineData->ref.ref();
}
if(d->engineData->engine) // already loaded
return;
// set it to the actual pointsize, so QFontInfo will do the right thing
req.pointSize = qRound(qt_mac_pointsize(d->request, d->dpi));
QFontEngine *e = QFontCache::instance()->findEngine(key);
if(!e && qt_enable_test_font && req.family == QLatin1String("__Qt__Box__Engine__")) {
e = new QTestFontEngine(req.pixelSize);
e->fontDef = req;
}
if(e) {
e->ref.ref();
d->engineData->engine = e;
return; // the font info and fontdef should already be filled
}
//find the font
QStringList family_list = familyList(req);
const char *stylehint = styleHint(req);
if (stylehint)
family_list << QLatin1String(stylehint);
// add QFont::defaultFamily() to the list, for compatibility with
// previous versions
family_list << QApplication::font().defaultFamily();
ATSFontFamilyRef familyRef = 0;
ATSFontRef fontRef = 0;
QMutexLocker locker(fontDatabaseMutex());
QFontDatabasePrivate *db = privateDb();
if (!db->count)
initializeDb();
for(int i = 0; i < family_list.size(); ++i) {
for (int k = 0; k < db->count; ++k) {
if (db->families[k]->name.compare(family_list.at(i), Qt::CaseInsensitive) == 0) {
QByteArray family_name = db->families[k]->name.toUtf8();
familyRef = ATSFontFamilyFindFromName(QCFString(db->families[k]->name), kATSOptionFlagsDefault);
if (familyRef) {
fontRef = ATSFontFindFromName(QCFString(db->families[k]->name), kATSOptionFlagsDefault);
goto FamilyFound;
} else {
#if defined(QT_MAC_USE_COCOA)
// ATS and CT disagrees on what the family name should be,
// use CT to look up the font if ATS fails.
QCFString familyName = QString::fromAscii(family_name);
QCFType<CTFontRef> CTfontRef = CTFontCreateWithName(familyName, 12, NULL);
QCFType<CTFontDescriptorRef> fontDescriptor = CTFontCopyFontDescriptor(CTfontRef);
QCFString displayName = (CFStringRef)CTFontDescriptorCopyAttribute(fontDescriptor, kCTFontDisplayNameAttribute);
familyRef = ATSFontFamilyFindFromName(displayName, kATSOptionFlagsDefault);
if (familyRef) {
fontRef = ATSFontFindFromName(displayName, kATSOptionFlagsDefault);
goto FamilyFound;
}
#endif
}
}
}
}
FamilyFound:
//fill in the engine's font definition
QFontDef fontDef = d->request; //copy..
if(fontDef.pointSize < 0)
fontDef.pointSize = qt_mac_pointsize(fontDef, d->dpi);
else
fontDef.pixelSize = qt_mac_pixelsize(fontDef, d->dpi);
#if 0
ItemCount name_count;
if(ATSUCountFontNames(fontID, &name_count) == noErr && name_count) {
ItemCount actualName_size;
if(ATSUGetIndFontName(fontID, 0, 0, 0, &actualName_size, 0, 0, 0, 0) == noErr && actualName_size) {
QByteArray actualName(actualName_size);
if(ATSUGetIndFontName(fontID, 0, actualName_size, actualName.data(), &actualName_size, 0, 0, 0, 0) == noErr && actualName_size)
fontDef.family = QString::fromUtf8(actualName);
}
}
#else
{
QCFString actualName;
if(ATSFontFamilyGetName(familyRef, kATSOptionFlagsDefault, &actualName) == noErr)
fontDef.family = actualName;
}
#endif
#ifdef QT_MAC_USE_COCOA
QFontEngine *engine = new QCoreTextFontEngineMulti(familyRef, fontRef, fontDef, d->kerning);
#elif 1
QFontEngine *engine = new QFontEngineMacMulti(familyRef, fontRef, fontDef, d->kerning);
#else
ATSFontFamilyRef atsFamily = familyRef;
ATSFontFamilyRef atsFontRef = fontRef;
FMFont fontID;
FMFontFamily fmFamily;
FMFontStyle fntStyle = 0;
fmFamily = FMGetFontFamilyFromATSFontFamilyRef(atsFamily);
if (fmFamily == kInvalidFontFamily) {
// Use the ATSFont then...
fontID = FMGetFontFromATSFontRef(atsFontRef);
} else {
if (fontDef.weight >= QFont::Bold)
fntStyle |= ::bold;
if (fontDef.style != QFont::StyleNormal)
fntStyle |= ::italic;
FMFontStyle intrinsicStyle;
FMFont fnt = 0;
if (FMGetFontFromFontFamilyInstance(fmFamily, fntStyle, &fnt, &intrinsicStyle) == noErr)
fontID = FMGetATSFontRefFromFont(fnt);
}
OSStatus status;
const int maxAttributeCount = 5;
ATSUAttributeTag tags[maxAttributeCount + 1];
ByteCount sizes[maxAttributeCount + 1];
ATSUAttributeValuePtr values[maxAttributeCount + 1];
int attributeCount = 0;
Fixed size = FixRatio(fontDef.pixelSize, 1);
tags[attributeCount] = kATSUSizeTag;
sizes[attributeCount] = sizeof(size);
values[attributeCount] = &size;
++attributeCount;
tags[attributeCount] = kATSUFontTag;
sizes[attributeCount] = sizeof(fontID);
values[attributeCount] = &fontID;
++attributeCount;
CGAffineTransform transform = CGAffineTransformIdentity;
if (fontDef.stretch != 100) {
transform = CGAffineTransformMakeScale(float(fontDef.stretch) / float(100), 1);
tags[attributeCount] = kATSUFontMatrixTag;
sizes[attributeCount] = sizeof(transform);
values[attributeCount] = &transform;
++attributeCount;
}
ATSUStyle style;
status = ATSUCreateStyle(&style);
Q_ASSERT(status == noErr);
Q_ASSERT(attributeCount < maxAttributeCount + 1);
status = ATSUSetAttributes(style, attributeCount, tags, sizes, values);
Q_ASSERT(status == noErr);
QFontEngine *engine = new QFontEngineMac(style, fontID, fontDef, /*multiEngine*/ 0);
ATSUDisposeStyle(style);
#endif
d->engineData->engine = engine;
engine->ref.ref(); //a ref for the engineData->engine
QFontCache::instance()->insertEngine(key, engine);
}
void QFontDatabase::load(const QFontPrivate *d, int script)
{
// sanity checks
if(!qApp)
qWarning("QFont: Must construct a QApplication before a QFont");
Q_ASSERT(script >= 0 && script < QUnicodeTables::ScriptCount);
Q_UNUSED(script);
QFontDef req = d->request;
req.pixelSize = qt_mac_pixelsize(req, d->dpi);
// set the point size to 0 to get better caching
req.pointSize = 0;
QFontCache::Key key = QFontCache::Key(req, QUnicodeTables::Common, d->screen);
if(!(d->engineData = QFontCache::instance()->findEngineData(key))) {
d->engineData = new QFontEngineData;
QFontCache::instance()->insertEngineData(key, d->engineData);
} else {
d->engineData->ref.ref();
}
if(d->engineData->engine) // already loaded
return;
// set it to the actual pointsize, so QFontInfo will do the right thing
req.pointSize = qRound(qt_mac_pointsize(d->request, d->dpi));
QFontEngine *e = QFontCache::instance()->findEngine(key);
if(!e && qt_enable_test_font && req.family == QLatin1String("__Qt__Box__Engine__")) {
e = new QTestFontEngine(req.pixelSize);
e->fontDef = req;
}
if(e) {
e->ref.ref();
d->engineData->engine = e;
return; // the font info and fontdef should already be filled
}
QFontEngine *engine = NULL;
#if defined(QT_MAC_USE_COCOA)
// Shortcut to get the font directly without going through the font database
if (!req.family.isEmpty() && !req.styleName.isEmpty()) {
QCFString expectedFamily = QCFString(req.family);
QCFString expectedStyle = QCFString(req.styleName);
QCFType<CFMutableDictionaryRef> attributes = CFDictionaryCreateMutable(NULL, 0,
&kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
CFDictionaryAddValue(attributes, kCTFontFamilyNameAttribute, expectedFamily);
CFDictionaryAddValue(attributes, kCTFontStyleNameAttribute, expectedStyle);
QCFType<CTFontDescriptorRef> descriptor = CTFontDescriptorCreateWithAttributes(attributes);
CGAffineTransform transform = qt_transform_from_fontdef(req);
QCFType<CTFontRef> ctFont = CTFontCreateWithFontDescriptor(descriptor, req.pixelSize, &transform);
if (ctFont) {
QCFString familyName = CTFontCopyFamilyName(ctFont);
// Only accept the font if the family name is exactly the same as we specified
if (CFEqual(expectedFamily, familyName)) {
engine = new QCoreTextFontEngineMulti(ctFont, req, d->kerning);
}
}
}
#endif
if (!engine)
engine = loadFromDatabase(req, d);
if (engine) {
d->engineData->engine = engine;
engine->ref.ref();
QFontCache::instance()->insertEngine(key, engine);
}
}
static QFontEngine *loadFromDatabase(QFontDef &req, const QFontPrivate *d)
{
#if defined(QT_MAC_USE_COCOA)
QCFString fontName = NULL;
#else
ATSFontFamilyRef familyRef = 0;
ATSFontRef fontRef = 0;
#endif
QStringList family_list = familyList(req);
const char *stylehint = styleHint(req);
if (stylehint)
family_list << QLatin1String(stylehint);
// add QFont::defaultFamily() to the list, for compatibility with previous versions
family_list << QApplication::font().defaultFamily();
QMutexLocker locker(fontDatabaseMutex());
QFontDatabasePrivate *db = privateDb();
if (!db->count)
initializeDb();
for (int i = 0; i < family_list.size(); ++i) {
for (int k = 0; k < db->count; ++k) {
if (db->families[k]->name.compare(family_list.at(i), Qt::CaseInsensitive) == 0) {
#if defined(QT_MAC_USE_COCOA)
CFStringRef familyName = QCFString::toCFStringRef(db->families[k]->name);
QCFType<CTFontDescriptorRef> descriptor = CTFontDescriptorCreateWithAttributes(
QCFType<CFDictionaryRef>(CFDictionaryCreate(kCFAllocatorDefault,
(const void**)&kCTFontFamilyNameAttribute,
(const void**)&familyName, 1,
&kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks)));
CFRelease(familyName);
QCFType<CTFontRef> ctFont = CTFontCreateWithFontDescriptor(descriptor, 0, NULL);
if (ctFont) {
fontName = CTFontCopyFullName(ctFont);
goto found;
}
#else
familyRef = ATSFontFamilyFindFromName(QCFString(db->families[k]->name), kATSOptionFlagsDefault);
if (familyRef) {
fontRef = ATSFontFindFromName(QCFString(db->families[k]->name), kATSOptionFlagsDefault);
goto found;
}
#endif
}
}
}
found:
#ifdef QT_MAC_USE_COCOA
if (fontName)
return new QCoreTextFontEngineMulti(fontName, req, d->kerning);
#else
if (familyRef) {
QCFString actualName;
if (ATSFontFamilyGetName(familyRef, kATSOptionFlagsDefault, &actualName) == noErr)
req.family = actualName;
return new QFontEngineMacMulti(familyRef, fontRef, req, d->kerning);
}
#endif
return NULL;
}
static QCFType<CFURLRef> urlFromFileName(const QString &fileName)
{
return CFURLCreateWithFileSystemPath(kCFAllocatorDefault, QCFString(fileName),
kCFURLPOSIXPathStyle, false);
}
