void ToConfiguration::Editor::saveUserType(QSettings &s, QVariant &val, int key) const
{
Q_ASSERT_X( key == EditStyleMap && val.canConvert<toStylesMap>(), qPrintable(__QHERE__), qPrintable(QString("Unknown key to store: %1").arg(key)));
QMetaEnum StyleNameEnum(ENUM_REF(toSyntaxAnalyzer,WordClassEnum));
toStylesMap dMap = defaultValue(EditStyleMap).value<toStylesMap>();
toStylesMap wMap = val.value<toStylesMap>();
Q_FOREACH(int k, wMap.keys())
{
const char* i = StyleNameEnum.valueToKey(k);
if (i != NULL)
{
QString keyNameFg = QString(i) + "Fg";
QColor confFg = wMap.value(k).FGColor;
QColor defaFg = dMap.value(k).FGColor;
if ( confFg != defaFg)
s.setValue(keyNameFg, confFg.name());
QString keyNameBg = QString(i) + "Bg";
QColor confBg = wMap.value(k).BGColor;
QColor defaBg = dMap.value(k).BGColor;
if ( confBg != defaBg)
s.setValue(keyNameBg, confBg.name());
QString keyNameFo = QString(i) + "Fo";
QFont confFo = wMap.value(k).Font;
QFont defaFo = dMap.value(k).Font;
if ( confFo.toString() != defaFo.toString())
s.setValue(keyNameFo, confFo.toString());
}
}
};
void FormStyle::SetCustomPalette()
{
if ( ui.colorsB->currentIndex() < 0 )
return;
colorSet = new QSettings( "colors/"+ui.colorsB->currentText()+colorExt,QSettings::IniFormat );
ReadOnly = colorSet->value("QMPColorFileInfo/ReadOnly").toBool();
mainWindowPixmap = colorSet->value("QMPColor/mainWindowPixmap").value<QPixmap>();
ui.use2->setChecked( colorSet->value("QMPColor/mainWindowUse2").toBool() );
ui.bP2_1->setValue( colorSet->value("QMPColor/mainWindowbP2_1").toDouble() );
ui.bHt2->setChecked( colorSet->value("QMPColor/mainWindowbHt2").toBool() );
ui.bSt2->setChecked( colorSet->value("QMPColor/mainWindowbSt2").toBool() );
applicationPalette = colorSet->value("QMPColor/applicationPalette").value<QPalette>();
sliderButtonColor = colorSet->value("QMPColor/sliderButtonColor").value<QColor>();
#ifdef Q_WS_X11
QString fN = colorSet->value("QMPFont/applicationFontNameX11").toString();
#endif
// #ifdef Q_OS_MAC
// QString fN = colorSet->value("QMPFont/applicationFontNameMac").toString();
// #endif
#ifdef Q_WS_WIN
QString fN = colorSet->value("QMPFont/applicationFontNameWin").toString();
#endif
#ifndef Q_OS_MAC
if ( fN.isEmpty() )
fN = SystemFont.toString();
ui.bF1->setCurrentFont( fN );
if ( ui.bF1->currentFont().toString() != fN )
ui.bF1->setCurrentFont( SystemFont.toString() );
#endif
#ifdef Q_WS_X11
int fS = colorSet->value("QMPFont/applicationFontSizeX11").toInt();
#endif
// #ifdef Q_OS_MAC
// int fS = colorSet->value("QMPFont/applicationFontSizeMac").toInt();
// #endif
#ifdef Q_WS_WIN
int fS = colorSet->value("QMPFont/applicationFontSizeWin").toInt();
#endif
#ifndef Q_OS_MAC
if ( !fS )
fS = SystemFont.pointSize();
ui.bFSize1->setValue( fS );
#endif
delete colorSet;
}
void OptionsDialog::writSettings()
{
#ifdef Q_OS_WIN32
QSettings settings(QDir::homePath()+tr("/Application Data/")+qApp->applicationName()+".ini", QSettings::IniFormat);
#else
QSettings settings;
#endif
settings.setValue("Colors/FontColor", fcolor.name() );
settings.setValue("Colors/Background", bgcolor.name() );
settings.setValue("Colors/StatusColor", scolor.name() );
settings.setValue("Colors/StatusBg", sbcolor.name() );
settings.setValue("RecentFiles/OpenLastFile", ui.loadOnStartCheckBox->isChecked() );
settings.setValue("RecentFiles/SavePosition", ui.saveCursorCheckBox->isChecked() );
settings.setValue("ScrollBar", ui.scrollBarCheckBox->isChecked() );
settings.setValue("WindowState/ShowFullScreen", ui.fullScreenCheckBox->isChecked() );
settings.setValue("WindowState/ShowSplashScreen", ui.splashScreenCheckBox->isChecked() );
settings.setValue("Sound", ui.soundCheckBox->isChecked() );
settings.setValue("AutoSave", ui.autoSaveCheckBox->isChecked() );
settings.setValue("FlowMode", ui.flowModeCheckBox->isChecked() );
settings.setValue("PageCount", ui.pageCountCheckBox->isChecked() );
settings.setValue("WordCount", ui.wordCountSpinBox->value() );
settings.setValue("Deadline", ui.calendarWidget->selectedDate().toString("yyyyMMdd"));
settings.setValue("EditorWidth", ui.editorWidthSpinBox->value() );
settings.setValue("TimedWriting", setAlarm );
settings.setValue("EditorTopSpace", ui.editorTopSpaceSpinBox->value() );
settings.setValue("EditorBottomSpace", ui.editorBottomSpaceSpinBox->value() );
settings.setValue("PageCountFormula", ui.pageCountSpinBox->value() );
settings.setValue("DateFormat", ui.dateFormat->text() );
settings.setValue("TimeFormat", ui.timeFormat->text() );
QFont font;
QFont defaultFont;
font = ui.statusbarFontComboBox->currentFont();
font.setBold(ui.statusbarBoldCheckBox->isChecked() );
font.setItalic(ui.statusbarItalicCheckBox->isChecked() );
font.setPointSize(ui.statusbarSpinBox->value() );
settings.setValue("Font/FileName_Settings", font.toString() );
font = ui.statusbarFontComboBox->currentFont();
font.setBold(ui.statusbarBoldCheckBox->isChecked() );
font.setItalic(ui.statusbarItalicCheckBox->isChecked() );
font.setPointSize(ui.statusbarSpinBox->value() );
settings.setValue("Font/Statistics_Settings", font.toString() );
defaultFont = ui.fontComboBox->currentFont();
defaultFont.setPointSize(ui.fontSizeSpinBox->value() );
settings.setValue("Font/DefaultFont", defaultFont.toString() );
}
void SettingsGUI::slotBrowseFont() {
bool ok = false;
QFont f = QFontDialog::getFont(&ok, this);
if (ok) {
qApp->setFont(f);
lineEdit_APPFONT->setText(f.toString());
WSSET(WS_APP_FONT, f.toString());
}
}
QString QFontProto::toString() const
{
QFont *item = qscriptvalue_cast<QFont*>(thisObject());
if (item)
return item->toString();
return QString();
}
LabelCreator::LabelCreator(QWidget *parent)
: QDialog(parent) {
setupUi(this);
setWindowTitle(tr("Create Label Dialog"));
_bold->setFixedWidth(32);
_bold->setFixedHeight(32);
_bold->setIcon(QPixmap(":kst_bold.png"));
_italic->setFixedWidth(32);
_italic->setFixedHeight(32);
_italic->setIcon(QPixmap(":kst_italic.png"));
_labelColor->setFixedWidth(32);
_labelColor->setFixedHeight(32);
_labelText->setObjectStore(kstApp->mainWindow()->document()->objectStore());
QFont font;
font.fromString(dialogDefaults().value("label/font",font.toString()).toString());
_family->setCurrentFont(font);
_bold->setChecked(font.bold());
_italic->setChecked(font.italic());
_labelColor->setColor(dialogDefaults().value("label/color",QColor(Qt::black)).value<QColor>());
_labelFontScale->setValue(dialogDefaults().value("label/fontScale",12).toDouble());
if (dialogDefaults().value("label/fixLeft",true).toBool()) {
_left->setChecked(true);
} else {
_right->setChecked(true);
}
_lockPosToData->setChecked(dialogDefaultsLockPosToData("label"));
_saveAsDefault->show();
_Label_11->setProperty("si","Font &size:");
_Label_12->setProperty("si","Font famil&y:");
}
void ConfigPrintDialog::saveFont(QFontComboBox *box, QSpinBox *spin, QString setting_key)
{
qDebug() << "ConfigPrintDialog::saveFont()";
QFont titleFont = box->currentFont();
titleFont.setPointSize(spin->value());
m_settings.setValue(setting_key, titleFont.toString());
}
void PHIContext2D::setFont( const QString &f )
{
QFont font;
QFont::StyleHint hint=QFont::AnyStyle;
font.setPixelSize( 10 );
QString str=f;
str.replace( QRegExp( QStringLiteral( "[1-9]00" ) ), QString() );
str.replace( QLatin1Char( '"' ), QString() );
if ( str.contains( QLatin1String( "italic" ) ) ) {
font.setItalic( true );
str.replace( QLatin1String( "italic" ), QString() );
}
if ( str.contains( QLatin1String( "bold" ) ) ) {
font.setWeight( QFont::Bold );
str.replace( QLatin1String( "bold" ), QString() );
} else if ( str.contains( QLatin1String( "lighter" ) ) ) {
font.setWeight( QFont::Light );
str.replace( QLatin1String( "lighter" ), QString() );
} else if ( str.contains( QLatin1String( "bolder" ) ) ) {
font.setWeight( QFont::Black );
str.replace( QLatin1String( "bolder" ), QString() );
}
if ( str.contains( QLatin1String( "sans-serif" ) ) ) {
hint=QFont::SansSerif;
str.replace( QLatin1String( "sans-serif" ), QString() );
} else if ( f.contains( QLatin1String( "monospace" ) ) ) {
hint=QFont::Monospace;
str.replace( QLatin1String( "monospace" ), QString() );
} else if ( f.contains( QLatin1String( "fantasy" ) ) ) {
hint=QFont::Fantasy;
str.replace( QLatin1String( "fantasy" ), QString() );
} else if ( f.contains( QLatin1String( "cursive" ) ) ) {
hint=QFont::Cursive;
str.replace( QLatin1String( "cursive" ), QString() );
}
int s;
QString size=str;
if ( size.contains( QLatin1String( "px" ) ) ) {
size.replace( QRegExp( QStringLiteral( "px.*" ) ), QString() );
size.replace( QRegExp( QStringLiteral( ".* " ) ), QString() );
s=size.toInt();
if ( s>0 ) font.setPixelSize( s );
str.replace( QRegExp( QStringLiteral( "[0-9]*px" ) ), QString() );
}
if ( size.contains( QLatin1String( "pt" ) ) ) {
size.replace( QRegExp( QStringLiteral( "pt.*" ) ), QString() );
size.replace( QRegExp( QStringLiteral( ".* " ) ), QString() );
s=size.toInt();
if ( s>0 ) font.setPointSize( s );
str.replace( QRegExp( QStringLiteral( "[0-9]*pt" ) ), QString() );
}
str.replace( QRegExp( QStringLiteral( ",.*" ) ), QString() );
str=str.trimmed();
if ( !str.isEmpty() ) font.setFamily( str );
font.setStyleHint( hint );
qDebug( "setFont: %s", qPrintable( font.toString() ) );
_state.font=font;
_state.flags |= DirtyFont;
}
void DisplayPrefsDialog::setSummaryFont()
{
bool ok;
QFont tf = QFontDialog::getFont( &ok, opts.summaryFont, this );
if( ok ){
opts.summaryFont = tf;
SummaryFontEdit->setText( tf.toString() );
}
}
void LabelItem::applyDefaults() {
QFont font;
font.fromString(dialogDefaults().value(defaultsGroupName()+"/font",font.toString()).toString());
_font = font;
_color = dialogDefaults().value(defaultsGroupName()+"/color",QColor(Qt::black)).value<QColor>();
_scale = dialogDefaults().value(defaultsGroupName()+"/fontScale",12).toDouble();
_fixleft = dialogDefaults().value(defaultsGroupName()+"/fixLeft",true).toBool();
applyDialogDefaultsLockPosToData();
}
void ConfigTabAppearance::fontButtonClicked(QObject *button)
{
QFont font = m_theme.themeFontFromString( button->property("VALUE").toString() );
QFontDialog dialog(font, this);
if ( dialog.exec() == QDialog::Accepted ) {
font = dialog.selectedFont();
button->setProperty( "VALUE", font.toString() );
decoratePreview();
updateFontButtons();
}
}
void PreferencesDialog::accept() {
QFont font = ui.font->currentFont();
font.setPointSize(ui.size->value());
settings.beginGroup("Editor");
settings.setValue("Font", font.toString());
settings.endGroup();
// set font to all TabEditors
reloadSettings();
close();
}
void LegendItem::applyDefaults() {
_auto = dialogDefaults().value(defaultsGroupName()+"/auto",true).toBool();
_color = dialogDefaults().value(defaultsGroupName()+"/color",QColor(Qt::black)).value<QColor>();
QFont font;
font.fromString(dialogDefaults().value(defaultsGroupName()+"/font",font.toString()).toString());
setLegendFont(font);
setFontScale(dialogDefaults().value(defaultsGroupName()+"/fontScale", 12.0).toDouble());
_verticalDisplay = dialogDefaults().value(defaultsGroupName()+"/verticalDisplay",true).toBool();
}
void
CQPropertyDelegate::
drawFont(QPainter *painter, const QStyleOptionViewItem &option,
const QFont &f, const QModelIndex &index) const
{
QItemDelegate::drawBackground(painter, option, index);
QRect rect = option.rect;
rect.setWidth(option.rect.height());
rect.adjust(0, 1, -3, -2);
QFont f1 = f;
QFont f2 = painter->font();
QFontMetrics fm1(f1);
QFontMetrics fm2(f2);
int fw = fm1.width("Abc");
int fh = fm1.height();
if (fh > rect.height()) {
f1.setPixelSize(rect.height());
fm1 = QFontMetrics(f1);
fw = fm1.width("Abc");
}
int x1 = rect.left();
int y1 = rect.top() + fm1.ascent();
painter->save();
painter->setFont(f1);
painter->setPen(QColor(0,0,0));
painter->drawText(x1, y1, "Abc");
painter->restore();
int x2 = x1 + fw + 4;
//int y2 = rect.top() + fm2.ascent();
QRect rect1;
rect1.setCoords(x2, option.rect.top(), option.rect.right(), option.rect.bottom());
//painter->drawText(x2, y2, f.toString());
QItemDelegate::drawDisplay(painter, option, rect1, f.toString());
}
void Monitor_Window::on_Button_Font_clicked()
{
bool ok = false;
QFont font = QFontDialog::getFont( &ok, Get_Font(), this );
if( ok )
{
ui.Edit_Monitor_Out->setFont( font );
QSettings settings;
settings.setValue( "Emulator_Monitor_Font", font.toString() );
}
}
void PrefInterface::on_changeFontButton_clicked() {
QFont f = qApp->font();
if (!default_font_edit->text().isEmpty()) {
f.fromString(default_font_edit->text());
}
bool ok;
f = QFontDialog::getFont( &ok, f, this);
if (ok) {
default_font_edit->setText( f.toString() );
}
}
QString SongSettingWidget::getFontText(QFont font)
{
QString f = font.toString().split(",").at(0);
QString st(QString("%1: %2").arg(f).arg(font.pointSize()));
if(font.bold())
st += ", " + tr("Bold");
if(font.italic())
st += ", " + tr("Italic");
if(font.strikeOut())
st += ", " + tr("StrikeOut");
if(font.underline())
st += ", " + tr("Underline");
return st;
}
void
CurrentTrack::settingsAccepted()
{
QFont font = ui_Settings.fontRequester->font();
m_showEditTrackDetailsAction = (ui_Settings.editTrackDetailsCheckBox->checkState() == Qt::Checked);
m_title->setFont( font );
m_artist->setFont( font );
m_album->setFont( font );
KConfigGroup config = Amarok::config("Current Track Applet");
config.writeEntry( "Font", font.toString() );
config.writeEntry( "ShowEditTrackAction", m_showEditTrackDetailsAction );
clearTrackActions();
setupLayoutActions( The::engineController()->currentTrack() );
}
void ConfigAppearanceWidget::showFontDialog()
{
if (m_itemHighlighted < 0)
return;
bool ok;
QFont currentFont;
currentFont.fromString(m_itemFonts.at(m_itemHighlighted));
const QFont newFont = FontDialog::getFont(&ok, currentFont, this);
if (ok)
{
QTableWidgetItem *item = ui.itemTable->item(m_itemHighlighted, 0);
m_itemFonts.replace(m_itemHighlighted, newFont.toString());
item->setFont(newFont);
setItemToolTip(item, newFont);
}
}
void CustomFontModel::itemDoubleClicked(const QModelIndex &i){
if (!(i.isValid() && i.internalPointer()))
return;
CustomFontItem *item = reinterpret_cast<CustomFontItem*>(i.internalPointer());
bool ok = false;
QFont f = QFontDialog::getFont(&ok);
if (ok){
item->custom_font = f.toString();
item->updateColumn(COLUMN_CUSTOM_FONT_DISP, item->custom_font);
emit layoutChanged();
}
}
int VPreviewManager::calculateBlockMargin(const QTextBlock &p_block, int p_tabStopWidth)
{
static QHash<QString, int> spaceWidthOfFonts;
if (!p_block.isValid()) {
return 0;
}
QString text = p_block.text();
int nrSpaces = 0;
for (int i = 0; i < text.size(); ++i) {
if (!text[i].isSpace()) {
break;
} else if (text[i] == ' ') {
++nrSpaces;
} else if (text[i] == '\t') {
nrSpaces += p_tabStopWidth;
}
}
if (nrSpaces == 0) {
return 0;
}
int spaceWidth = 0;
QFont font;
QVector<QTextLayout::FormatRange> fmts = p_block.layout()->formats();
if (fmts.isEmpty()) {
font = p_block.charFormat().font();
} else {
font = fmts.first().format.font();
}
QString fontName = font.toString();
auto it = spaceWidthOfFonts.find(fontName);
if (it != spaceWidthOfFonts.end()) {
spaceWidth = it.value();
} else {
spaceWidth = QFontMetrics(font).width(' ');
spaceWidthOfFonts.insert(fontName, spaceWidth);
}
return spaceWidth * nrSpaces;
}
void lmcChatRoomWindow::sendMessage(void) {
if(ui.txtMessage->document()->isEmpty())
return;
if(bConnected) {
QString szHtmlMessage(ui.txtMessage->toHtml());
encodeMessage(&szHtmlMessage);
QTextDocument docMessage;
docMessage.setHtml(szHtmlMessage);
QString szMessage = docMessage.toPlainText();
QFont font = ui.txtMessage->font();
font.setPointSize(ui.txtMessage->fontPointSize());
MessageType type = groupMode ? MT_GroupMessage : MT_PublicMessage;
XmlMessage xmlMessage;
xmlMessage.addHeader(XN_TIME, QString::number(QDateTime::currentDateTime().toMSecsSinceEpoch()));
xmlMessage.addData(XN_FONT, font.toString());
xmlMessage.addData(XN_COLOR, messageColor.name());
xmlMessage.addData(XN_MESSAGE, szMessage);
if(groupMode) {
xmlMessage.addData(XN_THREAD, threadId);
xmlMessage.addData(XN_GROUPMSGOP, GroupMsgOpNames[GMO_Message]);
}
appendMessageLog(type, &localId, &localName, &xmlMessage);
if(groupMode) {
QHash<QString, QString>::const_iterator index = peerIds.constBegin();
while (index != peerIds.constEnd()) {
QString userId = index.value();
emit messageSent(type, &userId, &xmlMessage);
index++;
}
} else
emit messageSent(type, NULL, &xmlMessage);
}
else
appendMessageLog(MT_Error, NULL, NULL, NULL);
ui.txtMessage->clear();
ui.txtMessage->setFocus();
}
void tst_QFont::toAndFromString()
{
QFont defaultFont = QGuiApplication::font();
QString family = defaultFont.family();
QFontDatabase fdb;
const QStringList stylesList = fdb.styles(family);
if (stylesList.size() == 0)
QSKIP("Default font doesn't have any styles");
for (const QString &style : stylesList) {
QFont result;
QFont initial = fdb.font(family, style, defaultFont.pointSize());
result.fromString(initial.toString());
QCOMPARE(result, initial);
}
}
void CustomFontModel::addNewFont(const QString &wkey, const QString &desc){
if (wkey.isEmpty() || desc.isEmpty())
return;
QString font_desc = WSGET(wkey.toAscii().constData());
QFont f;
if (font_desc.isEmpty())
f = qApp->font();
else
f = f.fromString(font_desc)? f : qApp->font();
CustomFontItem *item = new CustomFontItem(QList<QVariant>() << desc << f.toString(), rootItem);
item->key = wkey;
item->custom_font = "";
rootItem->appendChild(item);
emit layoutChanged();
}
//------------------------------------------------------------------------------
//
QString XxOptionsDialog::getFontDisplayText(
const QFont& font
) const
{
QString displayText;
displayText = font.toString();
#if KEPT_FOR_HISTORY
QFontInfo fontInfo( font );
displayText = "Font: ";
displayText += fontInfo.family();
displayText += " Size: ";
displayText += QString::number( fontInfo.pointSize() );
displayText += " Style: ";
if ( !fontInfo.bold() && !fontInfo.italic() )
{
displayText += "Regular";
}
else if ( fontInfo.bold() && !fontInfo.italic() )
{
displayText += "Bold";
}
else if ( !fontInfo.bold() && fontInfo.italic() )
{
displayText += "Italic";
}
else if ( fontInfo.bold() && fontInfo.italic() )
{
displayText += "Bold + Italic";
}
else
{
displayText += "(unknown)";
}
#endif
return displayText;
}
void EditorPage::store( Manager *s )
{
s->beginGroup("IDE/editor");
s->setValue("spaceIndent", ui->spaceIndent->isChecked());
s->setValue("indentWidth", ui->indentWidth->value());
s->setValue("stepForwardEvaluation", ui->stepForwardEvaluation->isChecked());
s->setValue("blinkDuration", ui->blinkDuration->value());
QFont f = constructFont();
s->setValue("font", f.toString());
s->beginGroup("colors");
s->setValue("background", ui->bgColor->color());
s->setValue("text", ui->textColor->color());
s->setValue("matchingBrackets", ui->bracketColor->color());
s->setValue("evaluatedCodeText", ui->evalCodeFg->color());
s->setValue("evaluatedCodeBackground", ui->evalCodeBg->color());
s->setValue("lineNumbers", ui->lineNumbersFg->color());
s->setValue("lineNumbersBackground", ui->lineNumbersBg->color());
s->endGroup(); // colors
s->beginGroup("highlighting");
int formatCount = ui->textFormatList->count();
for(int i = 0; i < formatCount; ++i)
{
QString name = ui->textFormatList->name(i);
QTextCharFormat fm = ui->textFormatList->format(i);
s->setValue(name.toLower(), QVariant::fromValue<QTextCharFormat>(fm));
}
s->endGroup(); // highlighting
s->endGroup();
}
void Configurator::fontChoose()
{
bool ok;
QFont font = QFontDialog::getFont( &ok );
// if user pressed ok-button, then remember choosed font
if( ok )
{
QObjectList children = sender()->parent()->children();
// searching for the edit-control
foreach( QObject* child, children )
{
if(QString("QLineEdit") == child->metaObject()->className())
{
(qobject_cast<QLineEdit*>(child))->setText( font.toString() );
(qobject_cast<QLineEdit*>(child))->setFont( font );
break;
}
}
}
}
void FontsConfig::updateQtFont()
{
// FIXME: the change does not apply to some currently running Qt programs.
// FIXME: does not work with KDE apps
// TODO: also write the config values to GTK+ config files (gtk-2.0.rc and gtk3/settings.ini)
// FIXME: the selected font does not apply to our own application. Why?
QFont font = ui->fontName->currentFont();
int size = ui->fontSize->value();
bool bold = false;
bool italic = false;
switch(ui->fontStyle->currentIndex())
{
case 1:
bold = true;
break;
case 2:
italic = true;
break;
case 3:
bold = italic = true;
}
font.setPointSize(size);
font.setBold(bold);
font.setItalic(italic);
mQtSettings->beginGroup(QLatin1String("Qt"));
mQtSettings->setValue("font", font.toString());
mQtSettings->endGroup();
mQtSettings->sync();
#ifdef Q_WS_X11
qt_x11_apply_settings_in_all_apps();
#endif
update();
}
void tst_QFont::serialize()
{
QFETCH(QFont, font);
QFETCH(QDataStream::Version, minimumStreamVersion);
QDataStream stream;
const int thisVersion = stream.version();
for (int version = minimumStreamVersion; version <= thisVersion; ++version) {
QBuffer buffer;
buffer.open(QIODevice::WriteOnly);
stream.setDevice(&buffer);
stream.setVersion(version);
stream << font;
buffer.close();
buffer.open(QIODevice::ReadOnly);
QFont readFont;
stream >> readFont;
QVERIFY2(readFont == font, qPrintable(QString::fromLatin1("Fonts do not compare equal for QDataStream version ") +
QString::fromLatin1("%1:\nactual: %2\nexpected: %3").arg(version).arg(readFont.toString()).arg(font.toString())));
}
}
void tst_QFont::exactMatch()
{
QFont font;
// Check if a non-existing font hasn't an exact match
font = QFont( "BogusFont", 33 );
QVERIFY( !font.exactMatch() );
#ifdef Q_OS_WIN
QSKIP("Exact matching on windows misses a lot because of the sample chars");
#endif
if (QGuiApplication::platformName() == QLatin1String("xcb")) {
QVERIFY(QFont("sans").exactMatch());
QVERIFY(QFont("sans-serif").exactMatch());
QVERIFY(QFont("serif").exactMatch());
QVERIFY(QFont("monospace").exactMatch());
}
QSKIP("This test is bogus on Unix with support for font aliases in fontconfig");
QFontDatabase fdb;
QList<QFontDatabase::WritingSystem> systems = fdb.writingSystems();
for (int system = 0; system < systems.count(); ++system) {
QStringList families = fdb.families(systems[system]);
if (families.isEmpty())
return;
QStringList::ConstIterator f_it, f_end = families.end();
for (f_it = families.begin(); f_it != f_end; ++f_it) {
const QString &family = *f_it;
if (family.contains('['))
continue;
QStringList styles = fdb.styles(family);
QVERIFY(!styles.isEmpty());
QStringList::ConstIterator s_it, s_end = styles.end();
for (s_it = styles.begin(); s_it != s_end; ++s_it) {
const QString &style = *s_it;
if (fdb.isSmoothlyScalable(family, style)) {
// smoothly scalable font... don't need to load every pointsize
font = fdb.font(family, style, 12);
QFontInfo fontinfo(font);
if (! fontinfo.exactMatch()) {
// Unfortunately, this can fail, since
// QFontDatabase does not fill in all font
// properties. Check to make sure that the
// test didn't fail for obvious reasons
if (fontinfo.family().isEmpty()
&& fontinfo.pointSize() == 0) {
// this is a box rendering engine... this can happen from
// time to time, especially on X11 with iso10646-1 or
// unknown font encodings
continue;
}
#ifdef Q_OS_WIN
if (font.family().startsWith("MS ") || fontinfo.family().startsWith("MS ")) {
/* qDebug("Family matching skipped for MS-Alias font: %s, fontinfo: %s",
font.family().latin1(), fontinfo.family().latin1());
*/
} else
#endif
{
if (!(font.family() == fontinfo.family()
|| fontinfo.family().contains(font.family())
|| fontinfo.family().isEmpty())) {
qDebug("Test about to fail for font: %s, fontinfo: %s",
font.family().toLatin1().constData(),
fontinfo.family().toLatin1().constData());
}
QVERIFY(font.family() == fontinfo.family()
|| fontinfo.family().contains(font.family())
|| fontinfo.family().isEmpty());
}
if (font.pointSize() != -1) {
QVERIFY(font.pointSize() == fontinfo.pointSize());
} else {
QVERIFY(font.pixelSize() == fontinfo.pixelSize());
}
QVERIFY(font.italic() == fontinfo.italic());
if (font.weight() != fontinfo.weight()) {
qDebug("font is %s", font.toString().toLatin1().constData());
}
QVERIFY(font.weight() == fontinfo.weight());
} else {
font.setFixedPitch(!fontinfo.fixedPitch());
QFontInfo fontinfo1(font);
QVERIFY( !fontinfo1.exactMatch() );
font.setFixedPitch(fontinfo.fixedPitch());
QFontInfo fontinfo2(font);
QVERIFY( fontinfo2.exactMatch() );
}
}
#if 0
// ############## can only work if we have float point sizes in QFD
else {
QList<int> sizes = fdb.pointSizes(family, style);
QVERIFY(!sizes.isEmpty());
QList<int>::ConstIterator z_it, z_end = sizes.end();
for (z_it = sizes.begin(); z_it != z_end; ++z_it) {
const int size = *z_it;
// Initialize the font, and check if it is an exact match
font = fdb.font(family, style, size);
QFontInfo fontinfo(font, (QFont::Script) script);
if (! fontinfo.exactMatch()) {
// Unfortunately, this can fail, since
// QFontDatabase does not fill in all font
// properties. Check to make sure that the
// test didn't fail for obvious reasons
if (fontinfo.family().isEmpty()
&& fontinfo.pointSize() == 0) {
// this is a box rendering engine... this can happen from
// time to time, especially on X11 with iso10646-1 or
// unknown font encodings
continue;
}
// no need to skip MS-fonts here it seems
if (!(font.family() == fontinfo.family()
|| fontinfo.family().contains(font.family())
|| fontinfo.family().isEmpty())) {
qDebug("Test about to fail for font: %s, fontinfo: %s",
font.family().latin1(), fontinfo.family().latin1());
}
QVERIFY(font.family() == fontinfo.family()
|| fontinfo.family().contains(font.family())
|| fontinfo.family().isEmpty());
if (font.pointSize() != -1) {
QVERIFY(font.pointSize() == fontinfo.pointSize());
} else {
QVERIFY(font.pixelSize() == fontinfo.pixelSize());
}
QVERIFY(font.italic() == fontinfo.italic());
QVERIFY(font.weight() == fontinfo.weight());
} else {
font.setFixedPitch(!fontinfo.fixedPitch());
QFontInfo fontinfo1(font, (QFont::Script) script);
QVERIFY( !fontinfo1.exactMatch() );
font.setFixedPitch(fontinfo.fixedPitch());
QFontInfo fontinfo2(font, (QFont::Script) script);
QVERIFY( fontinfo2.exactMatch() );
}
}
}
#endif
}
}
}
}
