int main(int argc, char **argv)
{
QApplication app(argc, argv);
//! [0]
QFontDatabase database;
QTreeWidget fontTree;
fontTree.setColumnCount(2);
fontTree.setHeaderLabels(QStringList() << "Font" << "Smooth Sizes");
foreach (const QString &family, database.families()) {
QTreeWidgetItem *familyItem = new QTreeWidgetItem(&fontTree);
familyItem->setText(0, family);
foreach (const QString &style, database.styles(family)) {
QTreeWidgetItem *styleItem = new QTreeWidgetItem(familyItem);
styleItem->setText(0, style);
QString sizes;
foreach (int points, database.smoothSizes(family, style))
sizes += QString::number(points) + " ";
styleItem->setText(1, sizes.trimmed());
}
//! [0] //! [1]
}
//! [1]
fontTree.resizeColumnToContents(0);
fontTree.show();
return app.exec();
}
QStringList _k_fontList(const QFontComboBox::FontFilters &fontFilters = QFontComboBox::AllFonts)
{
QFontDatabase dbase;
QStringList families;
if (fontFilters == QFontComboBox::AllFonts) {
families = dbase.families();
} else {
const QFontComboBox::FontFilters scalableMask = (QFontComboBox::ScalableFonts | QFontComboBox::NonScalableFonts);
const QFontComboBox::FontFilters spacingMask = (QFontComboBox::ProportionalFonts | QFontComboBox::MonospacedFonts);
foreach (const QString &family, dbase.families()) {
if ((fontFilters & scalableMask) && (fontFilters & scalableMask) != scalableMask) {
if (bool(fontFilters & QFontComboBox::ScalableFonts) != dbase.isSmoothlyScalable(family))
continue;
}
if ((fontFilters & spacingMask) && (fontFilters & spacingMask) != spacingMask) {
if (bool(fontFilters & QFontComboBox::MonospacedFonts) != dbase.isFixedPitch(family))
continue;
}
families << family;
}
}
families.sort();
return families;
}
void tst_QFontDatabase::addAppFont()
{
QFETCH(bool, useMemoryFont);
QSignalSpy fontDbChangedSpy(QGuiApplication::instance(), SIGNAL(fontDatabaseChanged()));
QFontDatabase db;
const QStringList oldFamilies = db.families();
QVERIFY(!oldFamilies.isEmpty());
fontDbChangedSpy.clear();
int id;
if (useMemoryFont) {
QFile fontfile("FreeMono.ttf");
fontfile.open(QIODevice::ReadOnly);
QByteArray fontdata = fontfile.readAll();
QVERIFY(!fontdata.isEmpty());
id = QFontDatabase::addApplicationFontFromData(fontdata);
} else {
id = QFontDatabase::addApplicationFont("FreeMono.ttf");
}
#if defined(Q_OS_HPUX) && defined(QT_NO_FONTCONFIG)
// Documentation says that X11 systems that don't have fontconfig
// don't support application fonts.
QCOMPARE(id, -1);
return;
#endif
QCOMPARE(fontDbChangedSpy.count(), 1);
// addApplicationFont is supported on Mac, don't skip the test if it breaks.
#ifndef Q_OS_MAC
if (id == -1)
QSKIP("Skip the test since app fonts are not supported on this system");
#endif
const QStringList addedFamilies = QFontDatabase::applicationFontFamilies(id);
QVERIFY(!addedFamilies.isEmpty());
const QStringList newFamilies = db.families();
QVERIFY(!newFamilies.isEmpty());
QVERIFY(newFamilies.count() >= oldFamilies.count());
for (int i = 0; i < addedFamilies.count(); ++i)
QVERIFY(newFamilies.contains(addedFamilies.at(i)));
QVERIFY(QFontDatabase::removeApplicationFont(id));
QCOMPARE(fontDbChangedSpy.count(), 2);
#ifdef Q_OS_MAC
QEXPECT_FAIL("font file", "QTBUG-23062", Continue);
#endif
QCOMPARE(db.families(), oldFamilies);
}
QFont stringToFont(const QString& font)
{
QFontDatabase fdb;
QString fontFamily;
int familyIdx=-1;
QStringList allFamilies = fdb.families();
for(int idx=font.indexOf(' '); idx<font.size() && idx>=0; idx=font.indexOf(' ', idx+1)) {
QString testFont = font.left(idx);
if(allFamilies.contains(testFont)) {
fontFamily = testFont;
familyIdx = idx;
}
}
QFont f;
f.setFamily(fontFamily);
QRegularExpression fontRx(QStringLiteral(" (.*) +([0-9]+)$"));
QRegularExpressionMatch match = fontRx.match(font, familyIdx);
if (match.isValid()) {
QString fontStyle = match.captured(1).trimmed();
int fontSize = match.captured(2).toInt();
f.setStyleName(fontStyle);
f.setPointSize(fontSize);
} else {
qWarning() << "Couldn't figure out syle and size" << font;
}
return f;
}
void DevGUI::setupTextActions()
{
QToolBar *tb = new QToolBar(this);
tb->setAllowedAreas(Qt::TopToolBarArea | Qt::BottomToolBarArea);
tb->setWindowTitle(tr("Format Actions"));
addToolBarBreak(Qt::TopToolBarArea);
addToolBar(tb);
Font = new QComboBox(tb);
tb->addWidget(Font);
Font->setEditable(true);
QFontDatabase db;
Font->addItems(db.families());
connect(Font, SIGNAL(activated(const QString &)),
this, SLOT(textFamily(const QString &)));
Font->setCurrentIndex(Font->findText(DevApp::font().family()));
Size = new QComboBox(tb);
Size->setObjectName("Size");
tb->addWidget(Size);
Size->setEditable(true);
foreach(int size, db.standardSizes())
Size->addItem(QString::number(size));
connect(Size, SIGNAL(activated(const QString &)),
this, SLOT(textSize(const QString &)));
Size->setCurrentIndex(Size->findText(QString::number(DevApp::font().pointSize())));
}
void PreferencesDialog::initFontFamilyValues( QComboBox* comboBox, bool withEmptyEntry = false ) const {
QFontDatabase fontDatabase;
QStringList families = fontDatabase.families( false );
if( withEmptyEntry )
comboBox->insertItem( QString::null );
comboBox->insertStringList( families );
}
QRectF GlyphElement::renderToPath( const QString& raw, QPainterPath& path ) const
{
Q_UNUSED( raw )
Q_UNUSED( path )
// try to lookup the char in the font database
AttributeManager am;
QString fontFamily = am.stringOf( "fontfamily", this );
QFontDatabase db;
QFont tmpFont;
// determine if the specified font and glyph can be found
if( db.families().contains( fontFamily ) )
{
tmpFont.setFamily( fontFamily );
path.addText( path.currentPosition(), tmpFont,
QChar( am.stringOf( "index", this ).toInt() ) );
QFontMetricsF fm(tmpFont);
return fm.boundingRect(QChar( am.stringOf( "index", this ).toInt() ) );
}
else { // if not found use alt text
path.addText( path.currentPosition(), font(), am.stringOf( "alt", this ) );
QFontMetricsF fm(font());
return fm.boundingRect(am.stringOf( "alt", this ));
}
}
void SettingsDialog::setupFontLists()
{
QFontDatabase database;
const QStringList families = database.families();
console->post(PmChart::DebugUi,
"SettingsDialog::setupFontLists: default %s [%d]",
PmChart::defaultFontFamily(),
PmChart::defaultFontSize());
QCompleter *completeFamily = new QCompleter(families, familyLineEdit);
familyLineEdit->setCompleter(completeFamily);
familyListWidget->insertItems(0, families);
QString family = globalSettings.fontFamily;
familyLineEdit->setText(family);
updateFontList(familyListWidget, family);
styleListWidget->insertItems(0, database.styles(family));
QString style = globalSettings.fontStyle;
styleLineEdit->setText(style);
updateFontList(styleListWidget, style);
QStringList sizes;
foreach (int points, database.smoothSizes(family, style))
sizes << QString::number(points);
sizeListWidget->insertItems(0, sizes);
QString size = QString::number(globalSettings.fontSize);
sizeLineEdit->setText(size);
updateFontList(sizeListWidget, size);
}
void PreferencesDialog::initFontFamilyValues( QComboBox* comboBox, bool withEmptyEntry /*= false*/ ) const {
QFontDatabase fontDatabase;
QStringList families = fontDatabase.families();
if( withEmptyEntry )
comboBox->addItem( QString( "" ) );
comboBox->addItems( families );
}
// public QFontDatabase::WritingSystem writingSystem() const
void tst_QFontComboBox::writingSystem()
{
QFETCH(QFontDatabase::WritingSystem, writingSystem);
SubQFontComboBox box;
QSignalSpy spy0(&box, SIGNAL(currentFontChanged(QFont)));
QFont currentFont = box.currentFont();
box.setWritingSystem(writingSystem);
QCOMPARE(box.writingSystem(), writingSystem);
QFontDatabase db;
QStringList list = db.families(writingSystem);
int c = list.count();
for (int i = 0; i < list.count(); ++i) {
if (db.isPrivateFamily(list[i]))
c--;
}
QCOMPARE(box.model()->rowCount(), c);
if (list.count() == 0)
QCOMPARE(box.currentFont(), QFont());
QCOMPARE(spy0.count(), (currentFont != box.currentFont()) ? 1 : 0);
}
void tst_QFont::italicOblique()
{
QFontDatabase fdb;
QStringList families = fdb.families();
if (families.isEmpty())
return;
QStringList::ConstIterator f_it, f_end = families.end();
for (f_it = families.begin(); f_it != f_end; ++f_it) {
QString family = *f_it;
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) {
QString style = *s_it;
if (fdb.isSmoothlyScalable(family, style)) {
if (style.contains("Oblique")) {
style.replace("Oblique", "Italic");
} else if (style.contains("Italic")) {
style.replace("Italic", "Oblique");
} else {
continue;
}
QFont f = fdb.font(family, style, 12);
QVERIFY(f.italic());
}
}
}
}
/// Set a font
void ScriptFileInterpreter::setFont(const QString &fontFamily) {
// This needs to check if the font exists and use default if not
QFontDatabase database;
// Select saved choice. If not available, use current font
QString fontToUse = m_editor->lexer()->defaultFont().family();
if (database.families().contains(fontFamily))
fontToUse = fontFamily;
QFont defaultFont = m_editor->lexer()->defaultFont();
defaultFont.setFamily(fontToUse);
m_editor->lexer()->setDefaultFont(defaultFont);
// Check through all styles until it starts creating new ones (they match the
// default style)
// On each, copy the font and change only the family
int count = 0;
while (m_editor->lexer()->font(count) != m_editor->lexer()->defaultFont()) {
QFont font = m_editor->lexer()->font(count);
font.setFamily(fontToUse);
m_editor->lexer()->setFont(font, count);
count++;
}
}
void ZLQtPaintContext::fillFamiliesList(std::vector<std::string> &families) const {
bool helveticaFlag = false;
#ifdef USE_ZAURUS_FONTHACK
std::set<std::string> famSet = ZLZaurusFontHack::families();
for (std::set<std::string>::const_iterator it = famSet.begin(); it != famSet.end(); ++it) {
if (*it == HELVETICA) {
helveticaFlag = true;
}
families.push_back(*it);
}
#else /* USE_ZAURUS_FONTHACK */
QFontDatabase db;
QStringList qFamilies = db.families();
for (QStringList::Iterator it = qFamilies.begin(); it != qFamilies.end(); ++it) {
std::string family = (*it).ascii();
if (family == HELVETICA) {
helveticaFlag = true;
}
families.push_back(family);
}
#endif /* USE_ZAURUS_FONTHACK */
if (!helveticaFlag) {
families.push_back(HELVETICA);
}
}
X11FontDialog::X11FontDialog(QWidget *parent)
:QDialog( parent)
{
setModal(true);
ui.setupUi(this);
QFontDatabase fdb;
ui.comboBoxFont->addItems( fdb.families() );
}
void PreferencesBase::init()
{
setupUi(this);
QFontDatabase fdb;
comboFamily->addItems(fdb.families());
listElements->setCurrentItem( listElements->item(0) );
currentElement = "";
}
void ZLQtPaintContext::fillFamiliesList(std::vector<std::string> &families) const {
QFontDatabase db;
QStringList qFamilies = db.families();
for (QStringList::Iterator it = qFamilies.begin(); it != qFamilies.end(); ++it) {
std::string family = (*it).ascii();
families.push_back(family);
}
}
void MRichTextEditDialogsManager::initTextStylingDialog()
{
selectedFontSize = -1;
selectedFontFamily = QString();
selectedFontColor = QColor();
if (dialogs.textStyles.first) {
return;
}
//% "Text styles"
dialogs.textStyles.first = new MDialog(qtTrId("qtn_comm_text_styles"),M::DoneButton);
dialogs.textStyles.second = false;
QGraphicsWidget *centralWidget = dialogs.textStyles.first->centralWidget();
MLayout *layout = new MLayout(centralWidget);
MLinearLayoutPolicy *policy = new MLinearLayoutPolicy(layout, Qt::Vertical);
// Initialize Font Family combo box
QFontDatabase fontDatabase;
QStringList fontFamilyValues = fontDatabase.families();
// NOTE: black listing some ill-behaving fonts temporarily
fontFamilyValues.removeAll("Webdings");
fontFamilyValues.removeAll("Wingdings");
fontFamilyCombo = new MComboBox(centralWidget);
//% "Font"
fontFamilyCombo->setTitle(qtTrId("qtn_comm_font"));
QStringListModel *fontModel = new QStringListModel(centralWidget);
fontModel->setStringList(fontFamilyValues);
fontFamilyCombo->setItemModel(fontModel);
policy->addItem(fontFamilyCombo);
connect(fontFamilyCombo, SIGNAL(activated(QString)),
this, SLOT(rememberFontFamily(QString)));
// Initialize Font Size combo box
fontSizeCombo = new MComboBox(centralWidget);
//% "Font size"
fontSizeCombo->setTitle(qtTrId("qtn_comm_font_size"));
QStringListModel *sizeModel = new QStringListModel(centralWidget);
fontSizeCombo->setItemModel(sizeModel);
policy->addItem(fontSizeCombo);
connect(fontSizeCombo, SIGNAL(activated(QString)),
this, SLOT(rememberFontSize()));
// Initialize Font Color item
fontColorCombo = new MColorComboBox(centralWidget);
//% "Font color"
fontColorCombo->setTitle(qtTrId("qtn_comm_font_color_combobox"));
policy->addItem(fontColorCombo);
connect(fontColorCombo, SIGNAL(colorPicked(QColor)),
this, SLOT(rememberFontColor(QColor)));
// Selections are applied at pressing button "Done"
connect(dialogs.textStyles.first, SIGNAL(accepted()),
this, SLOT(applySelection()));
}
QFont KGlobalSettings::largeFont(const QString &text)
{
QFontDatabase db;
QStringList fam = db.families();
// Move a bunch of preferred fonts to the front.
if (fam.remove("Arial"))
fam.prepend("Arial");
if (fam.remove("Verdana"))
fam.prepend("Verdana");
if (fam.remove("Tahoma"))
fam.prepend("Tahoma");
if (fam.remove("Lucida Sans"))
fam.prepend("Lucida Sans");
if (fam.remove("Lucidux Sans"))
fam.prepend("Lucidux Sans");
if (fam.remove("Nimbus Sans"))
fam.prepend("Nimbus Sans");
if (fam.remove("Gothic I"))
fam.prepend("Gothic I");
if (_largeFont)
fam.prepend(_largeFont->family());
for(QStringList::ConstIterator it = fam.begin();
it != fam.end(); ++it)
{
if (db.isSmoothlyScalable(*it) && !db.isFixedPitch(*it))
{
QFont font(*it);
font.setPixelSize(75);
QFontMetrics metrics(font);
int h = metrics.height();
if ((h < 60) || ( h > 90))
continue;
bool ok = true;
for(unsigned int i = 0; i < text.length(); i++)
{
if (!metrics.inFont(text[i]))
{
ok = false;
break;
}
}
if (!ok)
continue;
font.setPointSize(48);
_largeFont = new QFont(font);
return *_largeFont;
}
}
_largeFont = new QFont(KGlobalSettings::generalFont());
_largeFont->setPointSize(48);
return *_largeFont;
}
UIMain::UIMain( QWidget* parent )
: QMainWindow( parent ), mProject( 0 ), mInit( false ),
mProcess( new QProcess( this ) ), cbFont( new QComboBox( this ) ),
cbFontSize( new QComboBox( this ) ), mManual( new QAssistantClient( Options::qtBin( "assistant" ), this ) ),
mAssistant( new QAssistantClient( Options::qtBin( "assistant" ), this ) )
{
mProcess->setObjectName( "mProcess" );
mProcess->setReadChannelMode( QProcess::MergedChannels );
cbFont->setObjectName( "cbFont" );
cbFontSize->setObjectName( "cbFontSize" );
mAssistant->setObjectName( "mAssistant" );
mManual->setObjectName( "mManual" );
setupUi( this );
// setting argument to manual
mManual->setArguments( QStringList() << "-profile" << Options::documentationFile( "html/qt4ds-monkey.adp" ) );
// workspace scrollbars
workspace->setScrollBarsEnabled( true );
// Adding Search Replace Dialog inside Messages Box
twMessagesBox->addTab( ReplaceDialog::self(), QIcon( ":/Icons/Icons/tabsearch.png" ), tr( "Search Replace" ) );
ReplaceDialog::self()->pbCancel->hide();
connect( qApp, SIGNAL( focusChanged( QWidget*, QWidget* ) ), this, SLOT( focusChanged( QWidget*, QWidget* ) ) );
// Adding buttons to status bar
sbBar->addPermanentWidget( pbWidgetsBox );
sbBar->addPermanentWidget( pbProjectsBox );
sbBar->addPermanentWidget( pbMessagesBox );
//
QFont myFont;
if ( !myFont.fromString( Options::self()->value( "Options/Editor/TextFont" ).toString() ) )
myFont = qApp->font();
// Font
fontToolBar->addWidget( cbFont );
cbFont->setEditable( true );
QFontDatabase fdb;
cbFont->addItems( fdb.families() );
cbFont->setCurrentIndex( cbFont->findText( myFont.family() ) );
// Font Size
fontToolBar->addWidget( cbFontSize );
cbFontSize->setEditable( true );
foreach ( int size, fdb.standardSizes() )
cbFontSize->addItem( QString::number( size ) );
cbFontSize->setCurrentIndex( cbFontSize->findText (QString::number( myFont.pointSize() ) ) );
// Adding a application background
//workspace->setBackground( QBrush( QPixmap( ":/Icons/Icons/background.png" ) ) );
// Setting corners
setCorner( Qt::TopLeftCorner, Qt::LeftDockWidgetArea );
setCorner( Qt::BottomLeftCorner, Qt::LeftDockWidgetArea );
// create action for styles
agStyles = new QActionGroup( this );
connect( agStyles, SIGNAL( triggered( QAction* ) ), this, SLOT( agStyles_triggered( QAction* ) ) );
QAction* action;
foreach ( QString style, QStyleFactory::keys() )
{
action = agStyles->addAction( style );
action->setCheckable( true );
if ( Options::self()->value( "Options/Style" ).toString() == style )
action->setChecked( true );
}
TextEditor::TextEditor(QMdiArea *area)
{
//extern QGraphicsScene *emscene;
createAction = new QAction(tr("&Новый файл"), this);
openAction = new QAction(tr("&Открыть"), this);
saveAction = new QAction(tr("&Сохранить"), this);
exitAction = new QAction(tr("&Выход"), this);
helpAction = new QAction(tr("&О редакторе"), this);
setFontAction = new QAction(this);
connect(createAction, SIGNAL(triggered()), this, SLOT(create()));
connect(openAction, SIGNAL(triggered()), this, SLOT(open()));
connect(saveAction, SIGNAL(triggered()), this, SLOT(save()));
connect(exitAction, SIGNAL(triggered()), this, SLOT(quit()));
connect(helpAction, SIGNAL(triggered()), this, SLOT(help()));
fileMenu = new QMenu(tr("&Файл"), this);
//emscene->addWidget(fileMenu)->setZValue(99);
//fileMenu->setVisible(false);
menuBar()->addMenu(fileMenu);
fileMenu->addAction(createAction);
fileMenu->addAction(openAction);
fileMenu->addAction(saveAction);
fileMenu->addSeparator();
fileMenu->addAction(helpAction);
fileMenu->addSeparator();
fileMenu->addAction(exitAction);
textEdit = new QTextEdit(this);
fileName = "";
QFontDatabase fontDataBase;
fontBox = new QComboBox();
fontBox->addItems(fontDataBase.families());
fontBox->addAction(setFontAction);
connect(fontBox , SIGNAL(currentIndexChanged(int)),this,SLOT(setFont(int)));
QGroupBox *groupBox = new QGroupBox;
QVBoxLayout *layout = new QVBoxLayout;
layout->addWidget(fontBox);
layout->addWidget(textEdit);
groupBox->setLayout(layout);
setCentralWidget(groupBox);
setWindowTitle(tr(TEDIT_APP_TITLE));
resize(640, 480);
subwindow = new TextEditorSubWindow(this);
subwindow->setWidget(this);
subwindow->setAttribute(Qt::WA_DeleteOnClose);
area->addSubWindow(subwindow, this->windowType());
TextEditor::textEditors << this;
}
void printFontList()
{
QFontDatabase db;
foreach (const QString &family, db.families()) {
qStdOut() << family << "\n";
foreach (const QString &style, db.styles(family)) {
qStdOut() << "\t" << style << "\n";
}
}
}
// Populates the 'family' ComboBox
void OptionsDialog::setupFontList()
{
QFontDatabase database;
// We only show the fixed fonts
foreach ( const QString &str, database.families() ) {
if ( database.isFixedPitch( str ) )
fontFamilyBox->addItem( str );
}
}
void QFontComboBoxPrivate::_q_updateModel()
{
Q_Q(QFontComboBox);
const int scalableMask = (QFontComboBox::ScalableFonts | QFontComboBox::NonScalableFonts);
const int spacingMask = (QFontComboBox::ProportionalFonts | QFontComboBox::MonospacedFonts);
QStringListModel *m = qobject_cast<QStringListModel *>(q->model());
if (!m)
return;
QFontFamilyDelegate *delegate = qobject_cast<QFontFamilyDelegate *>(q->view()->itemDelegate());
QFontDatabase::WritingSystem system = delegate ? delegate->writingSystem : QFontDatabase::Any;
QFontDatabase fdb;
QStringList list = fdb.families(system);
QStringList result;
int offset = 0;
QFontInfo fi(currentFont);
for (int i = 0; i < list.size(); ++i) {
if (fdb.isPrivateFamily(list.at(i)))
continue;
if ((filters & scalableMask) && (filters & scalableMask) != scalableMask) {
if (bool(filters & QFontComboBox::ScalableFonts) != fdb.isSmoothlyScalable(list.at(i)))
continue;
}
if ((filters & spacingMask) && (filters & spacingMask) != spacingMask) {
if (bool(filters & QFontComboBox::MonospacedFonts) != fdb.isFixedPitch(list.at(i)))
continue;
}
result += list.at(i);
if (list.at(i) == fi.family() || list.at(i).startsWith(fi.family() + QLatin1String(" [")))
offset = result.count() - 1;
}
list = result;
//we need to block the signals so that the model doesn't emit reset
//this prevents the current index from changing
//it will be updated just after this
///TODO: we should finda way to avoid blocking signals and have a real update of the model
{
const QSignalBlocker blocker(m);
m->setStringList(list);
}
if (list.isEmpty()) {
if (currentFont != QFont()) {
currentFont = QFont();
emit q->currentFontChanged(currentFont);
}
} else {
q->setCurrentIndex(offset);
}
}
QString GwtCallback::getFixedWidthFontList()
{
QFontDatabase db;
QStringList families = db.families();
QStringList::iterator it = std::remove_if(
families.begin(), families.end(), isProportionalFont);
families.erase(it, families.end());
return families.join(QString::fromUtf8("\n"));
}
// Load the list of font names
void EditorButtonBar::loadFontNames() {
QFontDatabase fonts;
QStringList fontFamilies = fonts.families();
fontFamilies.append(tr("Times"));
fontFamilies.sort();
for (int i = 0; i < fontFamilies.size(); i++) {
fontNames->addItem(fontFamilies[i], fontFamilies[i]);
if (i == 0) {
loadFontSizeComboBox(fontFamilies[i]);
}
}
}
void tst_QFontDatabase::trickyFonts()
{
QFETCH(QString, font);
QFontDatabase fdb;
if (!fdb.families().contains(font))
QSKIP( "Font not installed", SkipSingle);
QFont qfont(font);
QFontInfo fi(qfont);
QCOMPARE(fi.family(), font);
}
QString Util::getDefaultFontFamily() {
QFontDatabase fontDatabase;
QStringList families = fontDatabase.families( false );
int unifontCount = families.contains( QString( "unifont" ) );
int lcfontCount = families.contains( QString( "lcfont" ) );
if( unifontCount > 0 )
return( QString( "unifont" ) );
else if( lcfontCount > 0 )
return( QString( "lcfontCount" ) );
else
return( QFont::defaultFont().family() );
}
void tst_QFontComboBox::currentFont_data()
{
QTest::addColumn<QFont>("currentFont");
// Normalize the names
QTest::newRow("default") << QFont(QFontInfo(QFont()).family());
QFontDatabase db;
QStringList list = db.families();
for (int i = 0; i < list.count(); ++i) {
QFont f = QFont(QFontInfo(QFont(list.at(i))).family());
QTest::newRow(qPrintable(list.at(i))) << f;
}
}
bool QgsFontUtils::fontFamilyMatchOnSystem( const QString& family, QString* chosen, bool* match )
{
QFontDatabase fontDB;
QStringList fontFamilies = fontDB.families();
bool found = false;
QList<QString>::const_iterator it = fontFamilies.constBegin();
for ( ; it != fontFamilies.constEnd(); ++it )
{
// first compare just beginning of 'family [foundry]' string
if ( it->startsWith( family, Qt::CaseInsensitive ) )
{
found = true;
// keep looking if match info is requested
if ( match )
{
// full 'family [foundry]' strings have to match
*match = ( *it == family );
if ( *match )
break;
}
else
{
break;
}
}
}
if ( found )
{
if ( chosen )
{
// retrieve the family actually assigned by matching algorithm
QFont f = QFont( family );
*chosen = f.family();
}
}
else
{
if ( chosen )
{
*chosen = QString();
}
if ( match )
{
*match = false;
}
}
return found;
}
// Load the list of font names
void AppearancePreferences::loadFontNames(QComboBox *combo, QString defaultFont) {
QFontDatabase fonts;
QStringList fontFamilies = fonts.families();
combo->addItem(tr("System Default"), "System Default");
for (int i = 0; i < fontFamilies.size(); i++) {
combo->addItem(fontFamilies[i], fontFamilies[i]);
}
int idx = combo->findData(defaultFont, Qt::UserRole);
if (idx >=0) {
combo->setCurrentIndex(idx);
} else
combo->setCurrentIndex(0);
}
