void Font::update( QPaintDeviceMetrics* devMetrics ) const
{
f.setFamily( fontDef.family.isEmpty() ? KHTMLFactory::defaultHTMLSettings()->stdFontName() : fontDef.family );
f.setItalic( fontDef.italic );
f.setWeight( fontDef.weight );
QFontDatabase db;
int size = fontDef.size;
int lDpiY = kMax(devMetrics->logicalDpiY(), 96);
// ok, now some magic to get a nice unscaled font
// all other font properties should be set before this one!!!!
if( !db.isSmoothlyScalable(f.family(), db.styleString(f)) )
{
QValueList<int> pointSizes = db.smoothSizes(f.family(), db.styleString(f));
// lets see if we find a nice looking font, which is not too far away
// from the requested one.
// kdDebug(6080) << "khtml::setFontSize family = " << f.family() << " size requested=" << size << endl;
QValueList<int>::Iterator it;
float diff = 1; // ### 100% deviation
float bestSize = 0;
for( it = pointSizes.begin(); it != pointSizes.end(); ++it )
{
float newDiff = ((*it)*(lDpiY/72.) - float(size))/float(size);
//kdDebug( 6080 ) << "smooth font size: " << *it << " diff=" << newDiff << endl;
if(newDiff < 0) newDiff = -newDiff;
if(newDiff < diff)
{
diff = newDiff;
bestSize = *it;
}
}
//kdDebug( 6080 ) << "best smooth font size: " << bestSize << " diff=" << diff << endl;
if ( bestSize != 0 && diff < 0.2 ) // 20% deviation, otherwise we use a scaled font...
size = (int)((bestSize*lDpiY) / 72);
}
// make sure we don't bust up X11
size = KMAX(0, KMIN(255, size));
// qDebug("setting font to %s, italic=%d, weight=%d, size=%d", fontDef.family.latin1(), fontDef.italic,
// fontDef.weight, size );
f.setPixelSize( size );
fm = QFontMetrics( f );
fontDef.hasNbsp = fm.inFont( 0xa0 );
}
QFont stripStyleName(QFont &f, QFontDatabase &db)
{
const QString &styleName = f.styleName();
if (styleName.isEmpty()) {
return f;
} else {
QFont g = (db.styleString(f) != styleName) ?
db.font(f.family(), styleName, f.pointSize())
: QFont(f.family(), f.pointSize(), f.weight());
if (auto s = f.pixelSize() > 0) {
g.setPixelSize(s);
}
g.setStyleHint(f.styleHint(), f.styleStrategy());
g.setStyle(f.style());
if (f.underline()) {
g.setUnderline(true);
}
if (f.strikeOut()) {
g.setStrikeOut(true);
}
if (f.fixedPitch()) {
g.setFixedPitch(true);
}
return g;
}
}
bool Font::isFontScalable(QFontDatabase &db, const QFont &font)
{
if(!scalCache)
scalCache = new QMap< ScalKey, ScalInfo >;
ScalKey key(font);
ScalInfo &s = (*scalCache)[key];
if(s == Unknown)
{
s = db.isSmoothlyScalable(font.family(), db.styleString(font)) ? Yes : No;
if(s == No)
{
/* Cache size info */
if(!scalSizesCache)
scalSizesCache = new QMap< ScalKey, QValueList< int > >;
(*scalSizesCache)[key] = db.smoothSizes(font.family(), db.styleString(font));
}
}
return (s == Yes);
}
void
CQFontChooser::
updateWidgets()
{
cedit_ ->setVisible(style_ == FontEdit );
cbutton_->setVisible(style_ == FontButton);
clabel_ ->setVisible(style_ == FontLabel || style_ == FontDetailLabel);
button_ ->setVisible(style_ != FontCombo );
ncombo_ ->setVisible(style_ == FontCombo );
scombo_ ->setVisible(style_ == FontCombo );
zcombo_ ->setVisible(style_ == FontCombo );
if (fixedWidth_)
ncombo_->setFontFilters(QFontComboBox::MonospacedFonts);
else
ncombo_->setFontFilters(QFontComboBox::AllFonts);
ncombo_->setWritingSystem(QFontDatabase::Latin);
//ncombo_->setCurrentIndex(1);
cedit_->setText(fontName_);
cbutton_->setFont(font_);
cbutton_->setText(exampleText());
clabel_->setFont(font_);
if (style_ == FontDetailLabel) {
QFontDatabase database;
QString style = database.styleString(font_);
clabel_->setText(QString("%1, %2, %3").
arg(font_.substitute(font_.family())).arg(style).arg(font_.pointSize()));
}
else
clabel_->setText(exampleText());
int nind = ncombo_->findText(font_.family());
if (nind >= 0)
ncombo_->setCurrentIndex(nind);
updateStyles();
updateSizes ();
updateCombos();
layout()->invalidate();
}
void
CQFontChooser::
updateCombos()
{
QFontDatabase database;
QString style = database.styleString(font_);
int sind = scombo_->findText(style);
if (sind == -1) {
bool italic = (style == "Italic" || style == "Bold Italic");
if (italic) {
if (style == "Italic" ) style = "Oblique";
if (style == "Bold Italic") style = "Bold Oblique";
sind = scombo_->findText(style);
if (sind == -1) {
if (style == "Bold Oblique") style = "Oblique";
sind = scombo_->findText(style);
}
if (sind == -1) {
if (style == "Oblique") style = "Italic";
sind = scombo_->findText(style);
}
}
}
if (sind >= 0)
scombo_->setCurrentIndex(sind);
int zind = zcombo_->findText(QString("%1").arg(font_.pointSize()));
if (zind >= 0)
zcombo_->setCurrentIndex(zind);
}
void BtFontChooserWidget::setFont(const QFont& font) {
disconnect(m_fontListWidget, nullptr, nullptr, nullptr);
disconnect(m_styleListWidget, nullptr, nullptr, nullptr);
disconnect(m_sizeListWidget, nullptr, nullptr, nullptr);
// set the font
m_font = font;
const QString fontFamily = font.family();
restoreListWidgetValue(m_fontListWidget, fontFamily);
// set the style
loadStyles(fontFamily);
QFontDatabase database;
const QString styleString = database.styleString(m_font);
m_choosenStyle = styleString;
restoreListWidgetValue(m_styleListWidget, styleString);
// set the size
loadSizes(fontFamily, styleString);
restoreListWidgetValue(m_sizeListWidget, QString::number(m_font.pointSize()) );
outputHtmlText();
connectListWidgets();
}
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;
}
}
}
Dialog::Dialog(QWidget *parent)
: QDialog(parent)
{
setAttribute(Qt::WA_QuitOnClose, true);
qApp->setStyleSheet("QLabel{ background: white }");
int frameStyle = QFrame::Sunken | QFrame::Panel;
QSettings store;
QVariant prefStoreType = store.value("storeNativeQFont");
if (prefStoreType != QVariant()) {
storeNativeQFont = prefStoreType.toBool();
}
else{
storeNativeQFont = true;
}
QVariant prefFont = store.value("font");
fontLabel = new QLabel;
fontLabel->setFrameStyle(frameStyle);
fontLabel->setToolTip(tr("this shows what QFont::key() returns for the current font"));
font = fontLabel->font();
if (prefFont != QVariant()) {
if (storeNativeQFont) {
if (prefFont.canConvert<QFont>()) {
font = prefFont.value<QFont>();
qWarning() << "Restoring saved native font" << font << "from" << prefFont;
fontDetails(font, stdout);
}
else {
qWarning() << "Cannot restore font from" << prefFont;
}
}
else {
QFont fn;
if (!fn.fromString(prefFont.toString())) {
qWarning() << "Failed to restore font from" << prefFont << "toString=" << prefFont.toString();
}
else {
qWarning() << "Restoring saved font" << fn;
fontDetails(fn, stdout);
font = fn;
}
}
}
fontLabel->setFont(font);
fontLabel->setText(font.key());
QPushButton *fontButton = new QPushButton(tr("QFontDialog::get&Font()"));
fontButton->setToolTip(tr("this initialises the getFont dialog with the font object selected previously"));
fontLabel2 = new QLabel;
fontLabel2->setFrameStyle(frameStyle);
fontLabel2->setToolTip(tr("this shows the current font's common attributes"));
fontLabel2->setFont(font);
fontLabel2->setText(fontRepr(font));
QPushButton *fontButton2 = new QPushButton(tr("QFontDialog::getFont(font.key())"));
fontButton2->setToolTip(tr("this initialises the getFont dialog with the shown representation of previously selected font"));
connect(fontButton, SIGNAL(clicked()), this, SLOT(setFont()));
connect(fontButton2, SIGNAL(clicked()), this, SLOT(setFontFromSpecs()));
fontPreview = new QLabel;
fontPreview->setFrameStyle(frameStyle);
fontPreview->setToolTip(tr("this shows current font family, QFont::styleString() and decimal point size"));
fontPreview->setFont(font);
QFontDatabase db;
fontPreview->setText( font.family() + tr(" ") + db.styleString(font) + tr(" @ ") + QString("%1pt").arg(font.pointSizeF()) );
clonedFontPreview = new QLabel;
clonedFontPreview->setFrameStyle(frameStyle);
clonedFontPreview->setToolTip(tr("this shows the font cloned without styleName"));
clonedBoldFontPreview = new QLabel;
clonedBoldFontPreview->setFrameStyle(frameStyle);
clonedBoldFontPreview->setToolTip(tr("this shows the font cloned without styleName and made bold"));
{ QFontDatabase db;
QFont tmp = stripStyleName(font, db);
clonedFontPreview->setFont(tmp);
tmp.setBold(true);
clonedBoldFontPreview->setFont(tmp);
}
clonedFontPreview->setText(clonedFontPreview->font().key());
clonedBoldFontPreview->setText(clonedBoldFontPreview->font().key());
QPushButton *styleButton = new QPushButton(tr("set styleName"));
styledFontPreview = new QLabel;
styledFontPreview->setFrameStyle(frameStyle);
#define STYLEDFNTPREVIEWTT "this shows the result of setting a stylename on the selected font\nResolves to: %1"
styledFontPreview->setToolTip(tr(STYLEDFNTPREVIEWTT).arg(styledFontPreview->font().toString()));
connect(styleButton, SIGNAL(clicked()), this, SLOT(setFontStyleName()));
QPushButton *famButton = new QPushButton(tr("Lookup from Family"));
fontFamilyPreview = new QLabel;
fontFamilyPreview->setFrameStyle(frameStyle);
connect(famButton, SIGNAL(clicked()), this, SLOT(getFontFromFamily()));
fontStyleName = new QLabel;
fontStyleName->setFrameStyle(frameStyle);
fontStyleName->setToolTip(tr("this shows the current styleName attribute that has been set on the font"));
QGridLayout *layout = new QGridLayout;
const QString doNotUseNativeDialog = tr("Do not use native dialog");
layout->setColumnStretch(1, 1);
layout->addWidget(fontButton, 0, 0);
layout->addWidget(fontLabel, 0, 1);
layout->addWidget(fontButton2, 1, 0);
layout->addWidget(fontLabel2, 1, 1);
layout->addWidget(fontPreview, 2, 0);
layout->addWidget(fontStyleName, 2, 1);
layout->addWidget(clonedFontPreview, 3, 0);
layout->addWidget(clonedBoldFontPreview, 3, 1);
layout->addWidget(styleButton, 4, 0);
layout->addWidget(styledFontPreview, 4, 1);
layout->addWidget(famButton, 5, 0);
layout->addWidget(fontFamilyPreview, 5, 1);
QPushButton *rawButton = new QPushButton(tr("Load font file"));
connect(rawButton, SIGNAL(clicked()), this, SLOT(getFontFromFile()));
rawFontSize = new QSpinBox;
rawFontSize->setRange(1, 256);
rawFontSize->setValue(12);
rawFontSize->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Preferred);
connect(rawFontSize, SIGNAL(valueChanged(int)), this, SLOT(getFontFromFile()));
paintLabel = new QFrame;
paintLabel->setFrameStyle(frameStyle);
paintLabel->setToolTip(tr("This shows a low-level render of the font file via QRawFont"));
QGridLayout *rf = new QGridLayout;
rf->addWidget(rawButton, 0, 0);
rf->addWidget(rawFontSize, 0, 1);
layout->addLayout(rf, 7, 0);
layout->addWidget(paintLabel, 7, 1);
// layout->addItem(new QSpacerItem(0, 0, QSizePolicy::Ignored, QSizePolicy::MinimumExpanding), 1, 0);
fontStretchOrSpace = new QCheckBox(tr("stretch/space"), this);
fontStretchOrSpace->setToolTip(tr("Apply stretch (checked) or letter-spacing (unchecked)"));
fontStretchOrSpace->setChecked(true);
stretchedFontPreview = new QLabel(this);
stretchedFontPreview->setFrameStyle(frameStyle);
stretchedFontPreview->setToolTip(tr("this shows the current font after stretching"));
fontStretch = new QSpinBox(this);
fontStretch->setRange(1, 4000);
fontStretch->setValue(QFont::Unstretched);
fontStretch->setToolTip(tr("stretch or letter-spacing in percentage"));
connect(fontStretch, SIGNAL(valueChanged(int)), this, SLOT(applyStretch()));
rf = new QGridLayout;
rf->addWidget(fontStretchOrSpace, 0, 0);
rf->addWidget(fontStretch, 0, 1);
layout->addLayout(rf, 8, 0);
layout->addWidget(stretchedFontPreview, 8, 1);
fontDialogOptionsWidget = new DialogOptionsWidget;
fontDialogOptionsWidget->addCheckBox(doNotUseNativeDialog, QFontDialog::DontUseNativeDialog);
fontDialogOptionsWidget->addCheckBox(tr("No buttons") , QFontDialog::NoButtons);
fontStoreTypeSel = fontDialogOptionsWidget->addCheckBox(tr("Store the selected font as a text representation"), 0);
fontStoreTypeSel->setToolTip(tr("Store the selected font as a text representation (QFont::toString()) or as a QFont"));
fontStoreTypeSel->setChecked(!storeNativeQFont);
connect(fontStoreTypeSel, SIGNAL(clicked()), this, SLOT(setFontStoreType()));
#if 0
layout->addItem(new QSpacerItem(0, 0, QSizePolicy::Ignored, QSizePolicy::MinimumExpanding), 1, 0);
#endif
layout->addWidget(fontDialogOptionsWidget, 9, 0, 1 ,2);
setLayout(layout);
setWindowTitle(tr("Font Selection"));
update();
#if QT_VERSION >= QT_VERSION_CHECK(5,5,0)
qWarning() << "For reference: QFont::ExtraLight=" << QFont::ExtraLight
<< "QFont::Thin=" << QFont::Thin
<< "QFont::Light=" << QFont::Light
<< "QFont::Normal=" << QFont::Normal
<< "QFont::Medium" << QFont::Medium
<< "QFont::DemiBold=" << QFont::DemiBold
<< "QFont::Bold=" << QFont::Bold
<< "QFont::Black=" << QFont::Black;
#elif QT_VERSION >= QT_VERSION_CHECK(5,4,0)
qWarning() << "For reference: qt_extralightFontWeight=" << qt_extralightFontWeight
<< "qt_thinFontWeight=" << qt_thinFontWeight
<< "QFont::Light=" << QFont::Light
<< "QFont::Normal=" << QFont::Normal
<< "qt_mediumFontWeight" << qt_mediumFontWeight
<< "QFont::DemiBold=" << QFont::DemiBold
<< "QFont::Bold=" << QFont::Bold
<< "QFont::Black=" << QFont::Black;
#else
qWarning() << "For reference: QFont::Light=" << QFont::Light
<< "QFont::Normal=" << QFont::Normal
<< "QFont::DemiBold=" << QFont::DemiBold
<< "QFont::Bold=" << QFont::Bold
<< "QFont::Black=" << QFont::Black;
#endif
styleString[QFont::StyleNormal] = "normal";
styleString[QFont::StyleItalic] = "italic";
styleString[QFont::StyleOblique] = "oblique";
styleHintString[QFont::Helvetica] = "Helvetica";
styleHintString[QFont::SansSerif] = "SansSerif (Helvetica)";
styleHintString[QFont::Times] = "Times";
styleHintString[QFont::Serif] = "Serif (Times)";
styleHintString[QFont::Courier] = "Courier";
styleHintString[QFont::TypeWriter] = "TypeWriter (Courier)";
styleHintString[QFont::OldEnglish] = "OldEnglish";
styleHintString[QFont::Decorative] = "Decorative (OldEnglish)";
styleHintString[QFont::System] = "System";
styleHintString[QFont::AnyStyle] = "AnyStyle";
styleHintString[QFont::Cursive] = "Cursive";
styleHintString[QFont::Monospace] = "Monospace";
styleHintString[QFont::Fantasy] = "Fantasy";
QFont::insertSubstitution(QStringLiteral("Helvetica"), QStringLiteral("Helvetica Neue"));
qWarning() << "Current substitutions:";
foreach (const auto subst, QFont::substitutions()) {
qWarning() << "\t" << subst << "->" << QFont::substitutes(subst);
}
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();
}
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();
}