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();
}
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);
}
bool QgsFontUtils::updateFontViaStyle( QFont& f, const QString& fontstyle, bool fallback )
{
if ( fontstyle.isEmpty() )
{
return false;
}
QFontDatabase fontDB;
if ( !fallback )
{
// does the font even have the requested style?
bool hasstyle = false;
foreach ( const QString &style, fontDB.styles( f.family() ) )
{
if ( style == fontstyle )
{
hasstyle = true;
break;
}
}
if ( !hasstyle )
{
return false;
}
}
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());
}
}
}
}
void BtFontChooserWidget::loadStyles(const QString& font) {
m_styleListWidget->clear();
QFontDatabase database;
Q_FOREACH (const QString &style, database.styles(font)) {
m_styleListWidget->addItem(style);
// This triggers loading the sizes for the first style
restoreListWidgetValue(m_styleListWidget, m_choosenStyle);
}
}
void MainWindow::familySelected(const QString &family)
{
QFontDatabase db;
QStringList styles = db.styles(family);
ui->fontStyleCombo->clear();
ui->fontStyleCombo->addItems(styles);
ui->familySubstitutionCombo->addItem(family);
buildFont();
}
void MainWindow::familySelected(const QString &family)
{
QFontDatabase db;
QStringList styles = db.styles(family);
stylecombo->clear();
stylecombo->insertStringList(styles);
familysubcombo->insertItem(family);
buildFont();
}
void printFontList()
{
QFontDatabase db;
foreach (const QString &family, db.families()) {
qStdOut() << family << "\n";
foreach (const QString &style, db.styles(family)) {
qStdOut() << "\t" << style << "\n";
}
}
}
void
CQFontChooser::
updateStyles()
{
QFontDatabase database;
const QString &family = ncombo_->itemText(ncombo_->currentIndex());
scombo_->clear();
scombo_->addItems(database.styles(family));
}
bool QgsFontUtils::fontFamilyHasStyle( const QString& family, const QString& style )
{
QFontDatabase fontDB;
if ( !fontFamilyOnSystem( family ) )
return false;
if ( fontDB.styles( family ).contains( style ) )
return true;
#ifdef Q_OS_WIN
QString modified( style );
if ( style == "Roman" )
modified = "Normal";
if ( style == "Oblique" )
modified = "Italic";
if ( style == "Bold Oblique" )
modified = "Bold Italic";
if ( fontDB.styles( family ).contains( modified ) )
return true;
#endif
return false;
}
void tst_QFontMetrics::metrics()
{
QFont font;
QFontDatabase fdb;
// Query the QFontDatabase for a specific font, store the
// result in family, style and size.
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) {
const QString &family = *f_it;
QStringList styles = fdb.styles(family);
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);
QFontMetrics fontmetrics(font);
QCOMPARE(fontmetrics.ascent() + fontmetrics.descent(),
fontmetrics.height());
QCOMPARE(fontmetrics.height() + fontmetrics.leading(),
fontmetrics.lineSpacing());
} 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);
QFontMetrics fontmetrics(font);
QCOMPARE(fontmetrics.ascent() + fontmetrics.descent(),
fontmetrics.height());
QCOMPARE(fontmetrics.height() + fontmetrics.leading(),
fontmetrics.lineSpacing());
}
}
}
}
}
void tst_QFontDatabase::styles()
{
QFETCH( QString, font );
QFontDatabase fdb;
QStringList styles = fdb.styles( font );
QStringList::Iterator it = styles.begin();
while ( it != styles.end() ) {
QString style = *it;
QString trimmed = style.trimmed();
++it;
QCOMPARE( style, trimmed );
}
}
QList<int> FontSettingsPage::pointSizesForSelectedFont() const
{
QFontDatabase db;
const QString familyName = d_ptr->m_ui->fontComboBox->currentFont().family();
QList<int> sizeLst = db.pointSizes(familyName);
if (!sizeLst.isEmpty())
return sizeLst;
QStringList styles = db.styles(familyName);
if (!styles.isEmpty())
sizeLst = db.pointSizes(familyName, styles.first());
if (sizeLst.isEmpty())
sizeLst = QFontDatabase::standardSizes();
return sizeLst;
}
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 DFontChooser::loadFontInfo(const QString &family)
{
QString currentSize = m_fontSize->currentText();
QString currentStyle = m_fontStyle->currentText();
QFontDatabase fdb;
m_fontStyle->clear();
m_fontStyle->addItems(fdb.styles(family));
m_fontSize->clear();
QList<int> points = fdb.pointSizes(family);
foreach(int point, points)
{
m_fontSize->addItem(QString::number(point));
}
FontBrowserServer::FontBrowserServer(ProbeInterface *probe, QObject *parent)
: FontBrowserInterface(parent)
, m_selectedFontModel(new FontModel(this))
{
QStandardItemModel *model = new QStandardItemModel(this);
model->setHorizontalHeaderLabels(QStringList() << tr("Fonts") << tr("Smooth sizes"));
QFontDatabase database;
foreach (const QString &family, database.families()) {
QStandardItem *familyItem = new QStandardItem;
familyItem->setText(family);
familyItem->setEditable(false);
familyItem->setData(QFont(family));
foreach (const QString &style, database.styles(family)) {
QStandardItem *styleItem0 = new QStandardItem;
styleItem0->setText(style);
styleItem0->setEditable(false);
styleItem0->setData(database.font(family, style, 10));
QString sizes;
foreach (int points, database.smoothSizes(family, style)) {
sizes += QString::number(points) + ' ';
}
QStandardItem *styleItem1 = new QStandardItem;
styleItem1->setText(sizes.trimmed());
styleItem1->setEditable(false);
styleItem1->setToolTip(sizes.trimmed());
familyItem->appendRow(QList<QStandardItem*>() << styleItem0 << styleItem1);
}
model->appendRow(familyItem);
}
probe->registerModel("com.kdab.GammaRay.FontModel", model);
m_fontSelectionModel = ObjectBroker::selectionModel(model);
connect(m_fontSelectionModel, SIGNAL(selectionChanged(QItemSelection,QItemSelection)),
SLOT(updateFonts()));
probe->registerModel("com.kdab.GammaRay.SelectedFontModel", m_selectedFontModel);
}
void FontsTest::testBruteForce()
{
QFontDatabase fdb;
QStringList allfamilies = fdb.families();
foreach(const QString& family, allfamilies) {
QStringList styles = fdb.styles(family);
foreach(const QString& style, styles) {
QFont f(family);
f.setStyleName(style);
QString str = fontToString(f);
QFont f2 = stringToFont(str);
QCOMPARE(f2.styleName(), style);
if(str != fontToString(f2)) {
qDebug() << "faulty font:" << str << f << f2;
}
QCOMPARE(fontToString(f2), str);
if(f != f2) {
qDebug() << "faulty font:" << f << f2;
}
// QCOMPARE(f, f2);
}
/**
* \brief Loads the fonts in font files within the given directory structure
*
* Scans directory and its subdirectories, up to MAX_DIRS total, looking for
* TrueType (.ttf) and OpenType (.otf) font files or TrueType font
* collections (.ttc) and loads the fonts to make them available to the
* application.
*
* \param directory The directory to scan
* \param registeredFor The user of the font. Used with releaseFonts() to
* unload the font if no longer in use (by any users)
* \sa LoadFonts(const QString &, const QString &, int *)
*/
void MythFontManager::LoadFonts(const QString &directory,
const QString ®isteredFor)
{
int maxDirs = MAX_DIRS;
LoadFonts(directory, registeredFor, &maxDirs);
QFontDatabase database;
foreach (const QString & family, database.families())
{
QString result = QString("Font Family '%1': ").arg(family);
foreach (const QString &style, database.styles(family))
{
result += QString("%1(").arg(style);
QString sizes;
foreach (int points, database.smoothSizes(family, style))
sizes += QString::number(points) + ' ';
result += QString("%1) ").arg(sizes.trimmed());
}
LOG(VB_GUI, LOG_DEBUG, LOC + result.trimmed());
}
}
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
}
}
}
}
MainWindow::MainWindow()
: ui(new Ui::MainWindow),
editPalette(palette()),
previewPalette(palette()),
previewstyle(0)
{
ui->setupUi(this);
statusBar();
// signals and slots connections
connect(ui->fontPathLineEdit, SIGNAL(returnPressed()), SLOT(addFontpath()));
connect(ui->addFontPathButton, SIGNAL(clicked()), SLOT(addFontpath()));
connect(ui->addSubstitutionButton, SIGNAL(clicked()), SLOT(addSubstitute()));
connect(ui->browseFontPathButton, SIGNAL(clicked()), SLOT(browseFontpath()));
connect(ui->fontStyleCombo, SIGNAL(activated(int)), SLOT(buildFont()));
connect(ui->pointSizeCombo, SIGNAL(activated(int)), SLOT(buildFont()));
connect(ui->downFontpathButton, SIGNAL(clicked()), SLOT(downFontpath()));
connect(ui->downSubstitutionButton, SIGNAL(clicked()), SLOT(downSubstitute()));
connect(ui->fontFamilyCombo, SIGNAL(activated(QString)), SLOT(familySelected(QString)));
connect(ui->fileExitAction, SIGNAL(triggered()), SLOT(fileExit()));
connect(ui->fileSaveAction, SIGNAL(triggered()), SLOT(fileSave()));
connect(ui->helpAboutAction, SIGNAL(triggered()), SLOT(helpAbout()));
connect(ui->helpAboutQtAction, SIGNAL(triggered()), SLOT(helpAboutQt()));
connect(ui->mainTabWidget, SIGNAL(currentChanged(int)), SLOT(pageChanged(int)));
connect(ui->paletteCombo, SIGNAL(activated(int)), SLOT(paletteSelected(int)));
connect(ui->removeFontpathButton, SIGNAL(clicked()), SLOT(removeFontpath()));
connect(ui->removeSubstitutionButton, SIGNAL(clicked()), SLOT(removeSubstitute()));
connect(ui->toolBoxEffectCombo, SIGNAL(activated(int)), SLOT(somethingModified()));
connect(ui->doubleClickIntervalSpinBox, SIGNAL(valueChanged(int)), SLOT(somethingModified()));
connect(ui->cursorFlashTimeSpinBox, SIGNAL(valueChanged(int)), SLOT(somethingModified()));
connect(ui->wheelScrollLinesSpinBox, SIGNAL(valueChanged(int)), SLOT(somethingModified()));
connect(ui->menuEffectCombo, SIGNAL(activated(int)), SLOT(somethingModified()));
connect(ui->comboEffectCombo, SIGNAL(activated(int)), SLOT(somethingModified()));
connect(ui->toolTipEffectCombo, SIGNAL(activated(int)), SLOT(somethingModified()));
connect(ui->strutWidthSpinBox, SIGNAL(valueChanged(int)), SLOT(somethingModified()));
connect(ui->strutHeightSpinBox, SIGNAL(valueChanged(int)), SLOT(somethingModified()));
connect(ui->effectsCheckBox, SIGNAL(toggled(bool)), SLOT(somethingModified()));
connect(ui->resolveLinksCheckBox, SIGNAL(toggled(bool)), SLOT(somethingModified()));
connect(ui->fontEmbeddingCheckBox, SIGNAL(clicked()), SLOT(somethingModified()));
connect(ui->rtlExtensionsCheckBox, SIGNAL(toggled(bool)), SLOT(somethingModified()));
connect(ui->inputStyleCombo, SIGNAL(activated(int)), SLOT(somethingModified()));
connect(ui->inputMethodCombo, SIGNAL(activated(int)), SLOT(somethingModified()));
connect(ui->guiStyleCombo, SIGNAL(activated(QString)), SLOT(styleSelected(QString)));
connect(ui->familySubstitutionCombo, SIGNAL(activated(QString)), SLOT(substituteSelected(QString)));
connect(ui->tunePaletteButton, SIGNAL(clicked()), SLOT(tunePalette()));
connect(ui->upFontpathButton, SIGNAL(clicked()), SLOT(upFontpath()));
connect(ui->upSubstitutionButton, SIGNAL(clicked()), SLOT(upSubstitute()));
modified = true;
desktopThemeName = tr("Desktop Settings (Default)");
setWindowIcon(QPixmap(":/qt-project.org/qtconfig/images/appicon.png"));
QStringList gstyles = QStyleFactory::keys();
gstyles.sort();
ui->guiStyleCombo->addItem(desktopThemeName);
ui->guiStyleCombo->setItemData(ui->guiStyleCombo->findText(desktopThemeName),
tr("Choose style and palette based on your desktop settings."),
Qt::ToolTipRole);
ui->guiStyleCombo->addItems(gstyles);
QSettings settings(QLatin1String("QtProject"));
settings.beginGroup(QLatin1String("Qt"));
QString currentstyle = settings.value(QLatin1String("style")).toString();
if (currentstyle.isEmpty()) {
ui->guiStyleCombo->setCurrentIndex(ui->guiStyleCombo->findText(desktopThemeName));
currentstyle = QApplication::style()->objectName();
} else {
int index = ui->guiStyleCombo->findText(currentstyle, Qt::MatchFixedString);
if (index != -1) {
ui->guiStyleCombo->setCurrentIndex(index);
} else { // we give up
ui->guiStyleCombo->addItem(tr("Unknown"));
ui->guiStyleCombo->setCurrentIndex(ui->guiStyleCombo->count() - 1);
}
}
ui->buttonMainColor->setColor(palette().color(QPalette::Active, QPalette::Button));
ui->buttonWindowColor->setColor(palette().color(QPalette::Active, QPalette::Window));
connect(ui->buttonMainColor, SIGNAL(colorChanged(QColor)), SLOT(buildPalette()));
connect(ui->buttonWindowColor, SIGNAL(colorChanged(QColor)), SLOT(buildPalette()));
#ifdef Q_WS_X11
if (X11->desktopEnvironment == DE_KDE)
ui->colorConfig->hide();
else
ui->kdeNoteLabel->hide();
#else
ui->colorConfig->hide();
ui->kdeNoteLabel->hide();
#endif
QFontDatabase db;
QStringList families = db.families();
ui->fontFamilyCombo->addItems(families);
QStringList fs = families;
QStringList fs2 = QFont::substitutions();
QStringList::Iterator fsit = fs2.begin();
while (fsit != fs2.end()) {
if (!fs.contains(*fsit))
fs += *fsit;
fsit++;
}
fs.sort();
ui->familySubstitutionCombo->addItems(fs);
ui->chooseSubstitutionCombo->addItems(families);
QList<int> sizes = db.standardSizes();
foreach(int i, sizes)
ui->pointSizeCombo->addItem(QString::number(i));
ui->doubleClickIntervalSpinBox->setValue(QApplication::doubleClickInterval());
ui->cursorFlashTimeSpinBox->setValue(QApplication::cursorFlashTime());
ui->wheelScrollLinesSpinBox->setValue(QApplication::wheelScrollLines());
// #############
// resolveLinksCheckBox->setChecked(qt_resolve_symlinks);
ui->effectsCheckBox->setChecked(QApplication::isEffectEnabled(Qt::UI_General));
ui->effectsFrame->setEnabled(ui->effectsCheckBox->isChecked());
if (QApplication::isEffectEnabled(Qt::UI_FadeMenu))
ui->menuEffectCombo->setCurrentIndex(2);
else if (QApplication::isEffectEnabled(Qt::UI_AnimateMenu))
ui->menuEffectCombo->setCurrentIndex(1);
if (QApplication::isEffectEnabled(Qt::UI_AnimateCombo))
ui->comboEffectCombo->setCurrentIndex(1);
if (QApplication::isEffectEnabled(Qt::UI_FadeTooltip))
ui->toolTipEffectCombo->setCurrentIndex(2);
else if (QApplication::isEffectEnabled(Qt::UI_AnimateTooltip))
ui->toolTipEffectCombo->setCurrentIndex(1);
if (QApplication::isEffectEnabled(Qt::UI_AnimateToolBox))
ui->toolBoxEffectCombo->setCurrentIndex(1);
QSize globalStrut = QApplication::globalStrut();
ui->strutWidthSpinBox->setValue(globalStrut.width());
ui->strutHeightSpinBox->setValue(globalStrut.height());
// find the default family
QStringList::Iterator sit = families.begin();
int i = 0, possible = -1;
while (sit != families.end()) {
if (*sit == QApplication::font().family())
break;
if ((*sit).contains(QApplication::font().family()))
possible = i;
i++;
sit++;
}
if (sit == families.end())
i = possible;
if (i == -1) // no clue about the current font
i = 0;
ui->fontFamilyCombo->setCurrentIndex(i);
QStringList styles = db.styles(ui->fontFamilyCombo->currentText());
ui->fontStyleCombo->addItems(styles);
QString stylestring = db.styleString(QApplication::font());
sit = styles.begin();
i = 0;
possible = -1;
while (sit != styles.end()) {
if (*sit == stylestring)
break;
if ((*sit).contains(stylestring))
possible = i;
i++;
sit++;
}
if (sit == styles.end())
i = possible;
if (i == -1) // no clue about the current font
i = 0;
ui->fontStyleCombo->setCurrentIndex(i);
i = 0;
for (int psize = QApplication::font().pointSize(); i < ui->pointSizeCombo->count(); ++i) {
const int sz = ui->pointSizeCombo->itemText(i).toInt();
if (sz == psize) {
ui->pointSizeCombo->setCurrentIndex(i);
break;
} else if(sz > psize) {
ui->pointSizeCombo->insertItem(i, QString::number(psize));
ui->pointSizeCombo->setCurrentIndex(i);
break;
}
}
QStringList subs = QFont::substitutes(ui->familySubstitutionCombo->currentText());
ui->substitutionsListBox->clear();
ui->substitutionsListBox->insertItems(0, subs);
ui->rtlExtensionsCheckBox->setChecked(settings.value(QLatin1String("useRtlExtensions"), false)
.toBool());
#ifdef Q_WS_X11
QString settingsInputStyle = settings.value(QLatin1String("XIMInputStyle")).toString();
if (!settingsInputStyle.isEmpty())
ui->inputStyleCombo->setCurrentIndex(ui->inputStyleCombo->findText(settingsInputStyle));
#else
ui->inputStyleCombo->hide();
ui->inputStyleLabel->hide();
#endif
#if defined(Q_WS_X11) && !defined(QT_NO_XIM)
QStringList inputMethodCombo = QInputContextFactory::keys();
int inputMethodComboIndex = -1;
QString defaultInputMethod = settings.value(QLatin1String("DefaultInputMethod"), QLatin1String("xim")).toString();
for (int i = inputMethodCombo.size()-1; i >= 0; --i) {
const QString &im = inputMethodCombo.at(i);
if (im.contains(QLatin1String("imsw"))) {
inputMethodCombo.removeAt(i);
if (inputMethodComboIndex > i)
--inputMethodComboIndex;
} else if (im == defaultInputMethod) {
inputMethodComboIndex = i;
}
}
if (inputMethodComboIndex == -1 && !inputMethodCombo.isEmpty())
inputMethodComboIndex = 0;
ui->inputMethodCombo->addItems(inputMethodCombo);
ui->inputMethodCombo->setCurrentIndex(inputMethodComboIndex);
#else
ui->inputMethodCombo->hide();
ui->inputMethodLabel->hide();
#endif
ui->fontEmbeddingCheckBox->setChecked(settings.value(QLatin1String("embedFonts"), true)
.toBool());
fontpaths = settings.value(QLatin1String("fontPath")).toStringList();
ui->fontpathListBox->insertItems(0, fontpaths);
settings.endGroup(); // Qt
ui->helpView->setText(tr(appearance_text));
setModified(false);
updateStyleLayout();
}
void IanniXApp::launch(int &argc, char **argv) {
//Display splash
Application::splash = new UiSplashScreen(QPixmap(":/general/res_splash.png"));
//Start
setHelp();
QDir pathApplicationDir = QDir(QCoreApplication::applicationDirPath()).absolutePath();
#ifdef Q_OS_MAC
pathApplicationDir.cdUp();
pathApplicationDir.cdUp();
pathApplicationDir.cdUp();
#endif
#ifdef QT4
Application::pathDocuments = QFileInfo(QDesktopServices::storageLocation(QDesktopServices::DocumentsLocation) + "/IanniX");
#else
Application::pathDocuments = QFileInfo(QStandardPaths::standardLocations(QStandardPaths::DocumentsLocation).first() + "/IanniX");
#endif
Application::pathApplication = QFileInfo(pathApplicationDir.absolutePath());
Application::pathCurrent = QFileInfo(QDir::currentPath());
if((Application::pathApplication.absoluteFilePath().endsWith("/IanniX-build-64")) || (Application::pathApplication.absoluteFilePath().endsWith("/IanniX-build-32")))
Application::pathApplication = QFileInfo(Application::pathApplication.absoluteFilePath().remove("-build-64").remove("-build-32"));
if(Application::pathApplication.absoluteFilePath().endsWith("/IanniX-build/release"))
Application::pathApplication = QFileInfo(Application::pathApplication.absoluteFilePath().remove("-build/release"));
if(Application::pathApplication.absoluteFilePath().endsWith("/IanniX-build"))
Application::pathApplication = QFileInfo(Application::pathApplication.absoluteFilePath().remove("-build"));
qDebug("Pathes");
qDebug("\tDocuments : %s", qPrintable(Application::pathDocuments .absoluteFilePath()));
qDebug("\tApplication: %s", qPrintable(Application::pathApplication.absoluteFilePath()));
qDebug("\tCurrent : %s", qPrintable(Application::pathCurrent .absoluteFilePath()));
qDebug("Arguments");
for(quint16 i = 0 ; i < argc ; i++) {
qDebug("\t%2d=\t%s", i, argv[i]);
}
/*
if(Application::pathCurrent.absoluteFilePath().startsWith("/Users/Guillaume/Documents/buzzinglight/Projets/Coduys/IanniX/IanniX"))
generateHelp();
*/
QFileInfo file;
for(quint16 i = 0 ; i < argc ; i++) {
file = QFileInfo(argv[i]);
if((file.exists()) && (file.suffix().toLower().contains("iannix"))) {
project = file;
break;
}
file = QFileInfo(Application::pathCurrent.absoluteFilePath() + "/" + argv[i]);
if((file.exists()) && (file.suffix().toLower().contains("iannix"))) {
project = file;
break;
}
file = QFileInfo(Application::pathDocuments.absoluteFilePath() + "/" + argv[i]);
if((file.exists()) && (file.suffix().toLower().contains("iannix"))) {
project = file;
break;
}
}
//Add font
if(QFontDatabase::addApplicationFont(Application::pathApplication.absoluteFilePath() + "/Tools/Museo.ttf"))
qDebug("Loading IanniX font failed : %s", qPrintable(Application::pathApplication.absoluteFilePath() + "/Tools/Museo.ttf"));
//List of fonts
if(false) {
qDebug("[FONTS]");
QFontDatabase fontDb;
QStringList fontList = fontDb.families();
foreach(const QString &font, fontList) {
qDebug("\tFamille : %s", qPrintable(font));
if(true) {
qDebug("\t\tFont : %s", qPrintable(font));
QStringList styleList = fontDb.styles(font);
foreach(const QString &style, styleList) {
int weight = fontDb.weight(font, style);
qDebug("\t\t\t > Style / Graisse %s %d", qPrintable(style), weight);
}
bool QgsFontUtils::fontFamilyHasStyle( const QString& family, const QString& style )
{
QFontDatabase fontDB;
return ( fontFamilyOnSystem( family ) && fontDB.styles( family ).contains( style ) );
}
bool QgsFontUtils::updateFontViaStyle( QFont& f, const QString& fontstyle, bool fallback )
{
if ( fontstyle.isEmpty() )
{
return false;
}
QFontDatabase fontDB;
if ( !fallback )
{
// does the font even have the requested style?
bool hasstyle = fontFamilyHasStyle( f.family(), fontstyle );
if ( !hasstyle )
{
return false;
}
}
// is the font's style already the same as requested?
if ( fontstyle == fontDB.styleString( f ) )
{
return false;
}
QFont appfont = QApplication::font();
int defaultSize = appfont.pointSize(); // QFontDatabase::font() needs an integer for size
QFont styledfont;
bool foundmatch = false;
// if fontDB.font() fails, it returns the default app font; but, that may be the target style
styledfont = fontDB.font( f.family(), fontstyle, defaultSize );
if ( appfont != styledfont || fontstyle != fontDB.styleString( f ) )
{
foundmatch = true;
}
// default to first found style if requested style is unavailable
// this helps in the situations where the passed-in font has to have a named style applied
if ( fallback && !foundmatch )
{
QFont testFont = QFont( f );
testFont.setPointSize( defaultSize );
// prefer a style that mostly matches the passed-in font
Q_FOREACH ( const QString &style, fontDB.styles( f.family() ) )
{
styledfont = fontDB.font( f.family(), style, defaultSize );
styledfont = styledfont.resolve( f );
if ( testFont.toString() == styledfont.toString() )
{
foundmatch = true;
break;
}
}
// fallback to first style found that works
if ( !foundmatch )
{
Q_FOREACH ( const QString &style, fontDB.styles( f.family() ) )
{
styledfont = fontDB.font( f.family(), style, defaultSize );
if ( QApplication::font() != styledfont )
{
foundmatch = true;
break;
}
}
}
MythFontProperties *MythFontProperties::ParseFromXml(
const QString &filename,
const QDomElement &element,
MythUIType *parent,
bool addToGlobal,
bool showWarnings)
{
// Crappy, but cached. Move to GlobalFontMap?
static bool show_available = true;
bool fromBase = false;
MythFontProperties *newFont = new MythFontProperties();
newFont->Freeze();
if (element.tagName() == "font")
LOG(VB_GENERAL, LOG_WARNING, LOC +
QString("File %1: Use of 'font' is deprecated in favour of "
"'fontdef'") .arg(filename));
QString name = element.attribute("name", "");
if (name.isEmpty())
{
VERBOSE_XML(VB_GENERAL, LOG_ERR,
filename, element, "Font requires a name");
delete newFont;
return NULL;
}
QString base = element.attribute("from", "");
if (!base.isEmpty())
{
MythFontProperties *tmp = NULL;
if (parent)
tmp = parent->GetFont(base);
if (!tmp)
tmp = GetGlobalFontMap()->GetFont(base);
if (!tmp)
{
VERBOSE_XML(VB_GENERAL, LOG_ERR, filename, element,
QString("Specified base font '%1' does not exist.").arg(base));
delete newFont;
return NULL;
}
*newFont = *tmp;
fromBase = true;
}
int size, pixelsize;
size = pixelsize = -1;
QString face = element.attribute("face", "");
if (face.isEmpty())
{
if (!fromBase)
{
VERBOSE_XML(VB_GENERAL, LOG_ERR, filename, element,
"Font needs a face");
delete newFont;
return NULL;
}
}
else
{
newFont->m_face.setFamily(face);
}
if (addToGlobal && GetGlobalFontMap()->Contains(name))
{
MythFontProperties *tmp = GetGlobalFontMap()->GetFont(name);
if (showWarnings)
{
VERBOSE_XML(VB_GENERAL, LOG_WARNING, filename, element,
QString("Attempting to define '%1'\n\t\t\t"
"with face '%2', but it already "
"exists with face '%3'")
.arg(name).arg(QFontInfo(newFont->m_face).family())
.arg((tmp) ? QFontInfo(tmp->m_face).family() : "ERROR"));
}
delete newFont;
return NULL;
}
QString hint = element.attribute("stylehint", "");
if (!hint.isEmpty())
{
newFont->m_face.setStyleHint((QFont::StyleHint)hint.toInt());
}
for (QDomNode child = element.firstChild(); !child.isNull();
child = child.nextSibling())
{
QDomElement info = child.toElement();
if (!info.isNull())
{
if (info.tagName() == "size")
{
size = getFirstText(info).toInt();
}
else if (info.tagName() == "pixelsize")
{
pixelsize = getFirstText(info).toInt();
}
else if (info.tagName() == "color")
{
newFont->m_brush = QBrush(QColor(getFirstText(info)));
}
else if (info.tagName() == "gradient")
{
newFont->m_brush = parseGradient(info);
}
else if (info.tagName() == "shadowcolor")
{
newFont->m_shadowColor = QColor(getFirstText(info));
}
else if (info.tagName() == "shadowoffset")
{
newFont->m_hasShadow = true;
newFont->m_shadowOffset = parsePoint(info, false);
}
else if (info.tagName() == "shadowalpha")
{
newFont->m_shadowAlpha = getFirstText(info).toInt();
}
else if (info.tagName() == "outlinecolor")
{
newFont->m_outlineColor = QColor(getFirstText(info));
}
else if (info.tagName() == "outlinesize")
{
newFont->m_hasOutline = true;
newFont->m_outlineSize = getFirstText(info).toInt();
}
else if (info.tagName() == "outlinealpha")
{
newFont->m_outlineAlpha = getFirstText(info).toInt();
}
else if (info.tagName() == "italics")
{
newFont->m_face.setItalic(parseBool(info));
}
else if (info.tagName() == "letterspacing")
{
newFont->m_face.setLetterSpacing(QFont::AbsoluteSpacing,
getFirstText(info).toInt());
}
else if (info.tagName() == "wordspacing")
{
newFont->m_face.setWordSpacing(getFirstText(info).toInt());
}
else if (info.tagName() == "decoration")
{
QString dec = getFirstText(info).toLower();
QStringList values = dec.split(',');
QStringList::Iterator it;
for ( it = values.begin(); it != values.end(); ++it )
{
if (*it == "underline")
newFont->m_face.setUnderline(true);
else if (*it == "overline")
newFont->m_face.setOverline(true);
else if (*it == "strikeout")
newFont->m_face.setStrikeOut(true);
}
}
else if (info.tagName() == "weight")
{
QString weight = getFirstText(info).toLower();
if (weight == "ultralight" ||
weight == "1")
newFont->m_face.setWeight(1);
else if (weight == "light" ||
weight == "2")
newFont->m_face.setWeight(QFont::Light);
else if (weight == "normal" ||
weight == "3")
newFont->m_face.setWeight(QFont::Normal);
else if (weight == "demibold" ||
weight == "4")
newFont->m_face.setWeight(QFont::DemiBold);
else if (weight == "bold" ||
weight == "5")
newFont->m_face.setWeight(QFont::Bold);
else if (weight == "black" ||
weight == "6")
newFont->m_face.setWeight(QFont::Black);
else if (weight == "ultrablack" ||
weight == "7")
newFont->m_face.setWeight(99);
else
newFont->m_face.setWeight(QFont::Normal);
}
else if (info.tagName() == "stretch")
{
QString stretch = getFirstText(info).toLower();
if (stretch == "ultracondensed" ||
stretch == "1")
newFont->m_stretch = QFont::UltraCondensed;
else if (stretch == "extracondensed" ||
stretch == "2")
newFont->m_stretch = QFont::ExtraCondensed;
else if (stretch == "condensed" ||
stretch == "3")
newFont->m_stretch = QFont::Condensed;
else if (stretch == "semicondensed" ||
stretch == "4")
newFont->m_stretch = QFont::SemiCondensed;
else if (stretch == "unstretched" ||
stretch == "5")
newFont->m_stretch = QFont::Unstretched;
else if (stretch == "semiexpanded" ||
stretch == "6")
newFont->m_stretch = QFont::SemiExpanded;
else if (stretch == "expanded" ||
stretch == "7")
newFont->m_stretch = QFont::Expanded;
else if (stretch == "extraexpanded" ||
stretch == "8")
newFont->m_stretch = QFont::ExtraExpanded;
else if (stretch == "ultraexpanded" ||
stretch == "9")
newFont->m_stretch = QFont::UltraExpanded;
else
newFont->m_stretch = QFont::Unstretched;
newFont->m_face.setStretch(newFont->m_stretch);
}
else
{
VERBOSE_XML(VB_GENERAL, LOG_ERR, filename, info,
QString("Unknown tag in font '%1'").arg(name));
delete newFont;
return NULL;
}
}
}
if (size <= 0 && pixelsize <= 0 && !fromBase)
{
VERBOSE_XML(VB_GENERAL, LOG_ERR, filename, element,
"Font size must be greater than 0.");
delete newFont;
return NULL;
}
else if (pixelsize > 0)
{
newFont->SetPixelSize(pixelsize);
}
else if (size > 0)
{
newFont->SetPointSize(size);
}
newFont->Unfreeze();
QFontInfo fi(newFont->m_face);
if (newFont->m_face.family() != fi.family())
{
VERBOSE_XML(VB_GENERAL, LOG_ERR, filename, element,
QString("Failed to load '%1', got '%2' instead")
.arg(newFont->m_face.family()).arg(fi.family()));
if (show_available)
{
LOG(VB_GUI, LOG_DEBUG, "Available fonts:");
QFontDatabase database;
foreach (const QString &family, database.families())
{
QStringList family_styles;
family_styles << family + "::";
foreach (const QString &style, database.styles(family))
{
family_styles << style + ":";
QString sizes;
bool tic = false;
foreach (int points, database.smoothSizes(family, style))
{
if (tic)
sizes += ",";
tic = true;
sizes += QString::number(points);
}
sizes += "; ";
family_styles << sizes.trimmed();
}
LOG(VB_GUI, LOG_DEBUG, family_styles.join(" "));
}
show_available = false;
}
}
FontBrowser::FontBrowser(ProbeInterface *probe, QWidget *parent)
: QWidget(parent),
ui(new Ui::FontBrowser)
{
Q_UNUSED(probe);
ui->setupUi(this);
QFontDatabase database;
m_selectedFontModel = new FontModel(this);
ui->selectedFontsView->setModel(m_selectedFontModel);
ui->selectedFontsView->setRootIsDecorated(false);
ui->fontTree->setSelectionMode(QAbstractItemView::ExtendedSelection);
QStandardItemModel *model = new QStandardItemModel(this);
model->setHorizontalHeaderLabels(QStringList() << tr("Fonts") << tr("Smooth sizes"));
foreach (const QString &family, database.families()) {
QStandardItem *familyItem = new QStandardItem;
familyItem->setText(family);
foreach (const QString &style, database.styles(family)) {
QStandardItem *styleItem0 = new QStandardItem;
styleItem0->setText(style);
QString sizes;
foreach (int points, database.smoothSizes(family, style)) {
sizes += QString::number(points) + ' ';
}
QStandardItem *styleItem1 = new QStandardItem;
styleItem1->setText(sizes.trimmed());
styleItem1->setToolTip(sizes.trimmed());
familyItem->appendRow(QList<QStandardItem*>() << styleItem0 << styleItem1);
}
model->appendRow(familyItem);
}
ui->fontTree->setModel(model);
ui->fontTree->header()->setResizeMode(0, QHeaderView::ResizeToContents);
ui->selectedFontsView->header()->setResizeMode(0, QHeaderView::ResizeToContents);
connect(ui->fontTree->selectionModel(),
SIGNAL(selectionChanged(QItemSelection,QItemSelection)),
SLOT(updateFonts(QItemSelection,QItemSelection)));
connect(ui->fontText, SIGNAL(textChanged(QString)),
m_selectedFontModel, SLOT(updateText(QString)));
ui->pointSize->setValue(font().pointSize());
connect(ui->boldBox, SIGNAL(toggled(bool)),
m_selectedFontModel, SLOT(toggleBoldFont(bool)));
connect(ui->italicBox, SIGNAL(toggled(bool)),
m_selectedFontModel, SLOT(toggleItalicFont(bool)));
connect(ui->underlineBox, SIGNAL(toggled(bool)),
m_selectedFontModel, SLOT(toggleUnderlineFont(bool)));
connect(ui->pointSize, SIGNAL(valueChanged(int)),
m_selectedFontModel, SLOT(setPointSize(int)));
// init
m_selectedFontModel->updateText(ui->fontText->text());
}
MainWindow::MainWindow()
: MainWindowBase(0, "main window"),
editPalette(palette()), previewPalette(palette()), previewstyle(0)
{
modified = true;
desktopThemeName = tr("Desktop Settings (Default)");
setIcon(QPixmap(":/trolltech/qtconfig/images/appicon.png"));
QStringList gstyles = QStyleFactory::keys();
gstyles.sort();
gstylecombo->addItem(desktopThemeName);
gstylecombo->setItemData(gstylecombo->findText(desktopThemeName),
tr("Choose style and palette based on your desktop settings."), Qt::ToolTipRole);
gstylecombo->insertStringList(gstyles);
QSettings settings(QLatin1String("Trolltech"));
settings.beginGroup(QLatin1String("Qt"));
QString currentstyle = settings.value(QLatin1String("style")).toString();
if (currentstyle.isEmpty()) {
gstylecombo->setCurrentItem(gstylecombo->findText(desktopThemeName));
currentstyle = QLatin1String(QApplication::style()->name());
} else {
int index = gstylecombo->findText(currentstyle, Qt::MatchFixedString);
if (index != -1) {
gstylecombo->setCurrentItem(index);
} else { // we give up
gstylecombo->insertItem(QLatin1String("Unknown"));
gstylecombo->setCurrentItem(gstylecombo->count() - 1);
}
}
buttonMainColor->setColor(palette().color(QPalette::Active,
QColorGroup::Button));
buttonMainColor2->setColor(palette().color(QPalette::Active,
QColorGroup::Window));
connect(buttonMainColor, SIGNAL(colorChanged(QColor)),
this, SLOT(buildPalette()));
connect(buttonMainColor2, SIGNAL(colorChanged(QColor)),
this, SLOT(buildPalette()));
if (X11->desktopEnvironment == DE_KDE)
colorConfig->hide();
else
labelKDENote->hide();
QFontDatabase db;
QStringList families = db.families();
familycombo->insertStringList(families);
QStringList fs = families;
QStringList fs2 = QFont::substitutions();
QStringList::Iterator fsit = fs2.begin();
while (fsit != fs2.end()) {
if (! fs.contains(*fsit))
fs += *fsit;
fsit++;
}
fs.sort();
familysubcombo->insertStringList(fs);
choosesubcombo->insertStringList(families);
Q3ValueList<int> sizes = db.standardSizes();
Q3ValueList<int>::Iterator it = sizes.begin();
while (it != sizes.end())
psizecombo->insertItem(QString::number(*it++));
dcispin->setValue(QApplication::doubleClickInterval());
cfispin->setValue(QApplication::cursorFlashTime());
wslspin->setValue(QApplication::wheelScrollLines());
// #############
// resolvelinks->setChecked(qt_resolve_symlinks);
effectcheckbox->setChecked(QApplication::isEffectEnabled(Qt::UI_General));
effectbase->setEnabled(effectcheckbox->isChecked());
if (QApplication::isEffectEnabled(Qt::UI_FadeMenu))
menueffect->setCurrentItem(2);
else if (QApplication::isEffectEnabled(Qt::UI_AnimateMenu))
menueffect->setCurrentItem(1);
if (QApplication::isEffectEnabled(Qt::UI_AnimateCombo))
comboeffect->setCurrentItem(1);
if (QApplication::isEffectEnabled(Qt::UI_FadeTooltip))
tooltipeffect->setCurrentItem(2);
else if (QApplication::isEffectEnabled(Qt::UI_AnimateTooltip))
tooltipeffect->setCurrentItem(1);
if ( QApplication::isEffectEnabled( Qt::UI_AnimateToolBox ) )
toolboxeffect->setCurrentItem( 1 );
QSize globalStrut = QApplication::globalStrut();
strutwidth->setValue(globalStrut.width());
strutheight->setValue(globalStrut.height());
// find the default family
QStringList::Iterator sit = families.begin();
int i = 0, possible = -1;
while (sit != families.end()) {
if (*sit == QApplication::font().family())
break;
if ((*sit).contains(QApplication::font().family()))
possible = i;
i++;
sit++;
}
if (sit == families.end())
i = possible;
if (i == -1) // no clue about the current font
i = 0;
familycombo->setCurrentItem(i);
QStringList styles = db.styles(familycombo->currentText());
stylecombo->insertStringList(styles);
QString stylestring = db.styleString(QApplication::font());
sit = styles.begin();
i = 0;
possible = -1;
while (sit != styles.end()) {
if (*sit == stylestring)
break;
if ((*sit).contains(stylestring))
possible = i;
i++;
sit++;
}
if (sit == styles.end())
i = possible;
if (i == -1) // no clue about the current font
i = 0;
stylecombo->setCurrentItem(i);
i = 0;
for (int psize = QApplication::font().pointSize(); i < psizecombo->count(); ++i) {
const int sz = psizecombo->text(i).toInt();
if (sz == psize) {
psizecombo->setCurrentItem(i);
break;
} else if(sz > psize) {
psizecombo->insertItem(i, QString::number(psize));
psizecombo->setCurrentItem(i);
break;
}
}
QStringList subs = QFont::substitutes(familysubcombo->currentText());
sublistbox->clear();
sublistbox->insertStringList(subs);
rtlExtensions->setChecked(settings.value(QLatin1String("useRtlExtensions"), false).toBool());
#ifdef Q_WS_X11
inputStyle->setCurrentText(settings.value(QLatin1String("XIMInputStyle"), trUtf8("On The Spot")).toString());
#else
inputStyle->hide();
inputStyleLabel->hide();
#endif
#if defined(Q_WS_X11) && !defined(QT_NO_XIM)
QStringList inputMethods = QInputContextFactory::keys();
int inputMethodIndex = -1;
QString defaultInputMethod = settings.value(QLatin1String("DefaultInputMethod"), QLatin1String("xim")).toString();
for (int i = inputMethods.size()-1; i >= 0; --i) {
const QString &im = inputMethods.at(i);
if (im.contains(QLatin1String("imsw"))) {
inputMethods.removeAt(i);
if (inputMethodIndex > i)
--inputMethodIndex;
} else if (im == defaultInputMethod) {
inputMethodIndex = i;
}
}
if (inputMethodIndex == -1 && !inputMethods.isEmpty())
inputMethodIndex = 0;
inputMethod->addItems(inputMethods);
inputMethod->setCurrentIndex(inputMethodIndex);
#else
inputMethod->hide();
inputMethodLabel->hide();
#endif
fontembeddingcheckbox->setChecked(settings.value(QLatin1String("embedFonts"), true).toBool());
fontpaths = settings.value(QLatin1String("fontPath")).toStringList();
fontpathlistbox->insertStringList(fontpaths);
audiosinkCombo->addItem(tr("Auto (default)"), QLatin1String("Auto"));
audiosinkCombo->setItemData(audiosinkCombo->findText(tr("Auto (default)")),
tr("Choose audio output automatically."), Qt::ToolTipRole);
audiosinkCombo->addItem(tr("aRts"), QLatin1String("artssink"));
audiosinkCombo->setItemData(audiosinkCombo->findText(tr("aRts")),
tr("Experimental aRts support for GStreamer."), Qt::ToolTipRole);
#ifdef HAVE_PHONON
phononVersionLabel->setText(QLatin1String(Phonon::phononVersion()));
#endif
#ifndef QT_NO_GSTREAMER
if (gst_init_check(0, 0, 0)) {
gchar *versionString = gst_version_string();
gstversionLabel->setText(QLatin1String(versionString));
g_free(versionString);
GList* factoryList = gst_registry_get_feature_list(gst_registry_get_default (), GST_TYPE_ELEMENT_FACTORY);
QString name, klass, description;
for (GList* iter = g_list_first(factoryList) ; iter != NULL ; iter = g_list_next(iter)) {
GstPluginFeature *feature = GST_PLUGIN_FEATURE(iter->data);
klass = QLatin1String(gst_element_factory_get_klass(GST_ELEMENT_FACTORY(feature)));
if (klass == QLatin1String("Sink/Audio")) {
name = QLatin1String(GST_PLUGIN_FEATURE_NAME(feature));
if (name == QLatin1String("sfsink"))
continue; //useless to output audio to file when you cannot set the file path
else if (name == QLatin1String("autoaudiosink"))
continue; //This is used implicitly from the auto setting
GstElement *sink = gst_element_factory_make (qPrintable(name), NULL);
if (sink) {
description = QLatin1String(gst_element_factory_get_description (GST_ELEMENT_FACTORY(feature)));
audiosinkCombo->addItem(name, name);
audiosinkCombo->setItemData(audiosinkCombo->findText(name), description, Qt::ToolTipRole);
gst_object_unref (sink);
}
}
}
g_list_free(factoryList);
}
#else
tab4->setEnabled(false);
phononLabel->setText(tr("Phonon GStreamer backend not available."));
#endif
videomodeCombo->addItem(tr("Auto (default)"), QLatin1String("Auto"));
videomodeCombo->setItemData(videomodeCombo->findText(tr("Auto (default)")), tr("Choose render method automatically"), Qt::ToolTipRole);
#ifdef Q_WS_X11
videomodeCombo->addItem(tr("X11"), QLatin1String("X11"));
videomodeCombo->setItemData(videomodeCombo->findText(tr("X11")), tr("Use X11 Overlays"), Qt::ToolTipRole);
#endif
#ifndef QT_NO_OPENGL
videomodeCombo->addItem(tr("OpenGL"), QLatin1String("OpenGL"));
videomodeCombo->setItemData(videomodeCombo->findText(tr("OpenGL")), tr("Use OpenGL if available"), Qt::ToolTipRole);
#endif
videomodeCombo->addItem(tr("Software"), QLatin1String("Software"));
videomodeCombo->setItemData(videomodeCombo->findText(tr("Software")), tr("Use simple software rendering"), Qt::ToolTipRole);
QString audioSink = settings.value(QLatin1String("audiosink"), QLatin1String("Auto")).toString();
QString videoMode = settings.value(QLatin1String("videomode"), QLatin1String("Auto")).toString();
audiosinkCombo->setCurrentItem(audiosinkCombo->findData(audioSink));
videomodeCombo->setCurrentItem(videomodeCombo->findData(videoMode));
settings.endGroup(); // Qt
helpview->setText(tr(appearance_text));
setModified(false);
updateStyleLayout();
}
int main(int argc, char *argv[])
{
// Workaround to start browser from QTextView
qputenv( "BROWSER", "browser --url" );
// @AP: Reset the locale that is used for number formatting to "C" locale.
setlocale(LC_NUMERIC, "C");
#ifdef ANDROID
// Gets the additional data directory from our app. That is normally the
// storage path to the SD-Card as /sdcard/Cumulus.
QString addDir = jniGetAddDataDir();
while( addDir.isEmpty() )
{
qDebug() << " Waiting for Cumulus addDir ...";
usleep(250000);
addDir = jniGetAddDataDir();
}
// Assign the original path name
addDir = QDir(addDir).canonicalPath();
// Nice trick to overwrite the HOME directory under Android by us ;-)
// That must be done before the QApplication constructor is called.
// Otherwise another HOME is used by QApplication.
qputenv ( "HOME", addDir.toLatin1().data() );
#endif
#ifndef ANDROID
#if QT_VERSION < 0x050000
// Note this must be called before QApplication constructor
QApplication::setGraphicsSystem( "raster" );
#endif
#endif
QApplication app(argc, argv, true);
QCoreApplication::setApplicationName( "Cumulus" );
QCoreApplication::setApplicationVersion( CU_VERSION );
QCoreApplication::setOrganizationName( "KFLog" );
QCoreApplication::setOrganizationDomain( "www.kflog.org" );
// Make sure the application uses utf8 encoding for translated widgets
#if QT_VERSION < 0x050000
QTextCodec::setCodecForTr( QTextCodec::codecForName ("UTF-8") );
#endif
// Note, that first $HOME must be overwritten under Android otherwise the
// setting file is created/searched in the internal data area under:
// /data/data/org.kflog.cumulus/files. That is the $HOME, set by Necessitas.
GeneralConfig *conf = GeneralConfig::instance();
#ifdef ANDROID
// Set the add data directory in our configuration
conf->setDataRoot( addDir );
// Set data directory after every startup because different Android APIs
// uses different locations. Otherwise that can cause problems during Andoid
// updates to a newer release.
conf->setUserDataDirectory( addDir );
// As next we must wait, that the add data are installed. That is done
// at the Java side.
while( jniAddDataInstalled() == false )
{
qDebug() << " Waiting for Cumulus addData installed ...";
usleep(250000);
}
// Gets the internal data directory from our App
QString appDir = jniGetAppDataDir();
while (appDir.isEmpty())
{
qDebug() << " Waiting for Cumulus appDir ...";
usleep(250000);
appDir = jniGetAppDataDir();
}
conf->setAppRoot( appDir );
#endif /* ANDROID */
// @AP: we installing our own message handler
#if QT_VERSION < 0x050000
qInstallMsgHandler(messageHandler);
#else
qInstallMessageHandler(messageHandler);
#endif
// @AP: to make trace output available, if process is started via
// QT/X11, we can redirect all output into a file, if configuration option
// Log2File is set to true.
#ifndef ANDROID
// @AP: make install root of Cumulus available for other modules via
// GeneralConfig. The assumption is that Cumulus is installed at
// <root>/bin/cumulus. The <root> path will be passed to GeneralConfig.
QDir rootDir( QFileInfo(argv[0]).canonicalPath() );
if( rootDir.cdUp() == false )
{
qWarning() << "main: Cumulus App has no parent directory! InstallDir is" << rootDir;
}
QString rootPath = rootDir.canonicalPath();
conf->setAppRoot( rootPath );
#endif
#ifdef MAEMO
bool isLog2File = true;
#else
bool isLog2File = conf->getLog2FileMode();
#endif
QString logDir = "/tmp";
#ifdef ANDROID
// always log on Android for now
isLog2File = true;
logDir = QDir::homePath();
#endif
if( isLog2File )
{
#ifdef MAEMO
// check for alternate paths under Maemo
QDir path1("/media/mmc1"); // N8x0
QDir path2("/media/mmc2"); // N8x0
QDir path3("/home/user/MyDocs");
if( path1.exists() && HwInfo::isMounted(path1.absolutePath()) )
{
logDir = path1.absolutePath();
}
else if( path2.exists() && HwInfo::isMounted(path2.absolutePath()) )
{
logDir = path2.absolutePath();
}
else if( path3.exists() )
{
logDir = path3.absolutePath();
}
#endif
logDir += "/cumulus.log";
// Save one old log file version.
rename( logDir.toLatin1().data(), (logDir + ".old").toLatin1().data() );
int i = open( logDir.toLatin1().data(), O_RDWR|O_CREAT|O_TRUNC,
S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH );
// Duplicate file descriptors 1, 2 that the output goes into a logfile
// dup2( i, fileno(stdin) );
dup2( i, fileno(stdout) );
dup2( i, fileno(stderr) );
close(i);
}
#ifdef ANDROID
qDebug() << "Cumulus addDir and QtHome:" << addDir;
qDebug() << "Cumulus appDir:" << appDir;
qDebug() << "Cumulus LogDir:" << logDir;
#endif
/*
@AP: check, if environment variable LD_BIND_NOW is set. In this case reset
it to avoid a gps client crash during fork under Opie.
If the process environment [see exec(base operating system)] contains a
variable named LD_BIND_NOW with a non-null value, the dynamic linker processes
all relocations before transferring control to the program. For example, all
the following environment entries would specify this behavior.
* LD_BIND_NOW=1
* LD_BIND_NOW=on
* LD_BIND_NOW=off
Otherwise, LD_BIND_NOW either does not occur in the environment or has a null
value. The dynamic linker is permitted to evaluate procedure linkage table
entries lazily, thus avoiding symbol resolution and relocation overhead for
functions that are not called. See the Procedure Linkage Table in this chapter
of the processor supplement for more information.
*/
char *env = getenv("LD_BIND_NOW");
qDebug( "LD_BIND_NOW=%s", env ? env : "NULL" );
// if( env != 0 )
// {
// unsetenv("LD_BIND_NOW");
// }
// Load language translation file for Cumulus.
#ifndef ANDROID
conf->setLanguage( conf->getLanguage() );
#else
// Gets the default language from the Android device.
QString language = jniGetLanguage();
// Put Android's default language into the program environment.
qputenv( "LANG", language.toLatin1().data() );
qDebug() << "Android sets language to" << language;
if( language.startsWith( "de" ) )
{
// In case of German there is a translation available.
conf->setLanguage( "de" );
}
else
{
conf->setLanguage( conf->getLanguage() );
}
QFontDatabase database;
foreach (const QString &family, database.families())
{
foreach (const QString &style, database.styles(family))
{
QString sizes;
foreach (int points, database.smoothSizes(family, style))
sizes += QString::number(points) + " ";
qDebug() << "Installed Font:" << family << style << sizes.trimmed();
}
}
QHash <QString, float> dmh = jniGetDisplayMetrics();
QHashIterator<QString, float> i(dmh);
qDebug() << "Android display metrics as key value list";
while( i.hasNext() )
{
i.next();
qDebug() << i.key() << "=" << i.value();
}
QHash <QString, QString> bdh = jniGetBuildData();
QHashIterator<QString, QString> j(bdh);
qDebug() << "Android build data as key value list";
while( j.hasNext() )
{
j.next();
qDebug() << j.key() << "=" << j.value();
}
#endif
// save done configuration settings
conf->save();
// create the Cumulus application window
MainWindow *cumulus = new MainWindow( Qt::WindowContextHelpButtonHint );
// start window manager event processing loop
int result = QApplication::exec();
// remove as first MainWindow because class objects inside can call GeneralConfig
delete cumulus;
// remove GeneralConfig, it is created during first call to it
delete GeneralConfig::instance();
return result;
}
