Katana_mirror/kdelibs
1
0
Fork 0
mirror of https://bitbucket.org/smil3y/kdelibs.git synced 2025-02-23 10:22:48 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

kdeui: replace KFontDialog and KFontChooser with QFontDialog

Browse source 
requires the following commit from the Katie repo:
97fea30784dfdc41a6599ea31219d0b366d8efaa

Signed-off-by: Ivailo Monev <xakepa10@gmail.com>
This commit is contained in:
Ivailo Monev 2024-03-31 19:01:42 +03:00
parent 688f770e6e
commit 45674c0c4e
19 changed files with 21 additions and 1841 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
includes/CMakeLists.txt
View file

@ -121,8 +121,6 @@ install(
KFindDialog
KFloatValidator
KFontAction
KFontChooser
KFontDialog
KFontRequester
KFontSizeAction
KUnitConversion

1
includes/KFontChooser
View file

@ -1 +0,0 @@
#include "../kfontchooser.h"

1
includes/KFontDialog
View file

@ -1 +0,0 @@
#include "../kfontdialog.h"

3
kdecore/sycoca/kprotocolinfo.cpp
View file

@ -52,8 +52,7 @@ KProtocolInfo::KProtocolInfo(const QString &path)
{
Q_D(KProtocolInfo);
const QString fullPath = KStandardDirs::locate("services", path);
KConfig sconfig(fullPath);
KConfig sconfig(KStandardDirs::locate("services", path));
KConfigGroup config(&sconfig, "Protocol");
m_name = config.readEntry("protocol");

4
kdeui/CMakeLists.txt
View file

@ -110,8 +110,6 @@ set(kdeui_LIB_SRCS
findreplace/kfinddialog.cpp
findreplace/kreplacedialog.cpp
fonts/fonthelpers.cpp
fonts/kfontchooser.cpp
fonts/kfontdialog.cpp
fonts/kfontrequester.cpp
icons/kiconeffect.cpp
icons/kiconengine.cpp
@ -398,8 +396,6 @@ install(
findreplace/kreplace.h
findreplace/kfinddialog.h
findreplace/kreplacedialog.h
fonts/kfontchooser.h
fonts/kfontdialog.h
fonts/kfontrequester.h
icons/kiconeffect.h
icons/kicon.h

24
kdeui/actions/kfontaction.cpp
View file

@ -29,14 +29,13 @@
#include "kfontaction.h"
#include <QToolBar>
#include <QFontDatabase>
#include <QFontComboBox>
#include <QStringListModel>
#include <kdebug.h>
#include <kfontdialog.h>
#include <kicon.h>
#include <klocale.h>
#include <kfontchooser.h>
class KFontAction::KFontActionPrivate
{
@ -65,39 +64,24 @@ class KFontAction::KFontActionPrivate
int settingFont;
};
KFontAction::KFontAction(uint fontListCriteria, QObject *parent)
: KSelectAction(parent), d(new KFontActionPrivate(this))
{
QStringList list;
KFontChooser::getFontList( list, fontListCriteria );
KSelectAction::setItems( list );
setEditable( true );
}
KFontAction::KFontAction(QObject *parent)
: KSelectAction(parent), d(new KFontActionPrivate(this))
{
QStringList list;
KFontChooser::getFontList( list, 0 );
KSelectAction::setItems( list );
KSelectAction::setItems( QFontDatabase().families() );
setEditable( true );
}
KFontAction::KFontAction(const QString & text, QObject *parent)
: KSelectAction(text, parent), d(new KFontActionPrivate(this))
{
QStringList list;
KFontChooser::getFontList( list, 0 );
KSelectAction::setItems( list );
KSelectAction::setItems( QFontDatabase().families() );
setEditable( true );
}
KFontAction::KFontAction(const KIcon &icon, const QString &text, QObject *parent)
: KSelectAction(icon, text, parent), d(new KFontActionPrivate(this))
{
QStringList list;
KFontChooser::getFontList( list, 0 );
KSelectAction::setItems( list );
KSelectAction::setItems( QFontDatabase().families() );
setEditable( true );
}

3
kdeui/actions/kfontaction.h
View file

@ -39,8 +39,7 @@ class KDEUI_EXPORT KFontAction : public KSelectAction
Q_PROPERTY( QString font READ font WRITE setFont )
public:
KFontAction(uint fontListCriteria, QObject *parent);
explicit KFontAction(QObject *parent);
KFontAction(QObject *parent);
KFontAction(const QString& text, QObject *parent);
KFontAction(const KIcon &icon, const QString &text, QObject *parent);
virtual ~KFontAction();

1
kdeui/dialogs/kconfigdialogmanager.cpp
View file

@ -126,7 +126,6 @@ void KConfigDialogManager::initMaps()
// KDE
s_changedMap->insert( "KComboBox", SIGNAL(activated(int)));
s_changedMap->insert( "KFontRequester", SIGNAL(fontSelected(QFont)));
s_changedMap->insert( "KFontChooser", SIGNAL(fontSelected(QFont)));
s_changedMap->insert( "KHistoryCombo", SIGNAL(activated(int)));
s_changedMap->insert( "KColorCombo", SIGNAL(activated(QColor)));
s_changedMap->insert( "KColorButton", SIGNAL(changed(QColor)));

960
kdeui/fonts/kfontchooser.cpp
View file

@ -1,960 +0,0 @@
/*
Copyright (C) 1996 Bernd Johannes Wuebben <wuebben@kde.org>
Copyright (c) 1999 Preston Brown <pbrown@kde.org>
Copyright (c) 1999 Mario Weilguni <mweilguni@kde.org>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public License
along with this library; see the file COPYING.LIB. If not, write to
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA.
*/
#include "kfontchooser.h"
#include "fonthelpers_p.h"
#include "sampleedit_p.h"
#include <QtGui/QCheckBox>
#include <QtGui/QLabel>
#include <QtGui/QLayout>
#include <QtGui/QSplitter>
#include <QtGui/QScrollBar>
#include <QtGui/QFontDatabase>
#include <QtGui/QGroupBox>
#include <kcharsets.h>
#include <kconfig.h>
#include <kdialog.h>
#include <kglobal.h>
#include <kglobalsettings.h>
#include <klistwidget.h>
#include <klocale.h>
#include <kstandarddirs.h>
#include <kdebug.h>
#include <knuminput.h>
#include <kconfiggroup.h>
#include <cmath>
// When message extraction needs to be avoided.
#define I18NC_NOX i18nc
static int minimumListWidth(const QListWidget *list)
{
int w = 0;
for(int i = 0; i < list->count(); i++) {
int itemWidth = list->visualItemRect(list->item(i)).width();
// ...and add a space on both sides for not too tight look.
itemWidth += (list->fontMetrics().width(' ') * 2);
w = qMax(w,itemWidth);
}
if (w == 0) {
w = 40;
}
w += (list->frameWidth() * 2);
w += list->verticalScrollBar()->sizeHint().width();
return w;
}
static int minimumListHeight(const QListWidget *list, int numVisibleEntry)
{
int w = (list->count() > 0 ? list->visualItemRect(list->item(0)).height() : list->fontMetrics().lineSpacing());
if (w < 0 ) {
w = 10;
}
if (numVisibleEntry <= 0) {
numVisibleEntry = 4;
}
return (w * numVisibleEntry + 2 * list->frameWidth());
}
static QString formatFontSize(const qreal size)
{
return KGlobal::locale()->formatNumber(size, (size == floor(size)) ? 0 : 1);
}
class KFontChooser::Private
{
public:
Private(KFontChooser *qq)
: q(qq)
{
m_palette.setColor(QPalette::Active, QPalette::Text, Qt::black);
m_palette.setColor(QPalette::Active, QPalette::Base, Qt::white);
signalsAllowed = true;
selectedSize = -1;
customSizeRow = -1;
}
void setFamilyBoxItems(const QStringList &fonts);
void fillFamilyListBox(bool onlyFixedFonts = false);
int nearestSizeRow(qreal val, bool customize);
qreal fillSizeList(const QList<qreal> &sizes = QList<qreal>());
qreal setupSizeListBox(const QString& family, const QString& style);
void setupDisplay();
QString styleIdentifier (const QFont &font);
void _k_toggled_checkbox();
void _k_family_chosen_slot(const QString&);
void _k_size_chosen_slot(const QString&);
void _k_style_chosen_slot(const QString&);
void _k_displaySample(const QFont &font);
void _k_size_value_slot(double);
KFontChooser *q;
QPalette m_palette;
bool signalsAllowed;
bool usingFixed;
KDoubleNumInput *sizeOfFont;
SampleEdit *sampleEdit;
QLabel *familyLabel;
QLabel *styleLabel;
QCheckBox *familyCheckbox;
QCheckBox *styleCheckbox;
QCheckBox *sizeCheckbox;
QLabel *sizeLabel;
KListWidget *familyListBox;
KListWidget *styleListBox;
KListWidget *sizeListBox;
QCheckBox *sizeIsRelativeCheckBox;
QFont selFont;
QString selectedStyle;
qreal selectedSize;
int customSizeRow;
QString standardSizeAtCustom;
QFontDatabase fontdb;
// Mappings of translated to Qt originated family and style strings.
QHash<QString, QString> qtFamilies;
QHash<QString, QString> qtStyles;
// Mapping of translated style strings to internal style identifiers.
QHash<QString, QString> styleIDs;
};
KFontChooser::KFontChooser(QWidget *parent,
const DisplayFlags flags,
const QStringList &fontList,
int visibleListSize,
Qt::CheckState *sizeIsRelativeState)
: QWidget(parent),
d(new KFontChooser::Private(this))
{
d->usingFixed = (flags & FixedFontsOnly);
setWhatsThis(i18nc("@info:whatsthis", "Here you can choose the font to be used."));
// The top layout is divided vertically into a splitter with font
// attribute widgets and preview on the top, and fonts at the bottom.
QVBoxLayout *topLayout = new QVBoxLayout( this );
topLayout->setMargin( 0 );
int checkBoxGap = KDialog::spacingHint() / 2;
// The splitter contains font attribute widgets in the top part,
// and the font preview in the bottom part.
// The splitter is there to allow the user to resize the font preview.
QSplitter *splitter = new QSplitter(Qt::Vertical, this);
splitter->setChildrenCollapsible(false);
topLayout->addWidget(splitter);
// Build the grid of font attribute widgets for the upper splitter part.
QWidget *page;
QGridLayout *gridLayout;
int row = 0;
if (flags & DisplayFrame) {
page = new QGroupBox(i18n("Requested Font"), this);
splitter->addWidget(page);
gridLayout = new QGridLayout( page );
row = 1;
} else {
page = new QWidget(this);
splitter->addWidget(page);
gridLayout = new QGridLayout(page);
gridLayout->setMargin(0);
}
//
// first, create the labels across the top
//
QHBoxLayout *familyLayout = new QHBoxLayout();
familyLayout->addSpacing(checkBoxGap);
if (flags & ShowDifferences) {
d->familyCheckbox = new QCheckBox(i18nc("@option:check","Font"), page);
connect(d->familyCheckbox, SIGNAL(toggled(bool)), this, SLOT(_k_toggled_checkbox()));
familyLayout->addWidget(d->familyCheckbox, 0, Qt::AlignLeft);
d->familyCheckbox->setWhatsThis(i18nc("@info:whatsthis","Enable this checkbox to change the font family settings."));
d->familyCheckbox->setToolTip(i18nc("@info:tooltip","Change font family?") );
d->familyLabel = nullptr;
} else {
d->familyCheckbox = nullptr;
d->familyLabel = new QLabel(i18nc("@label","Font:"), page);
familyLayout->addWidget(d->familyLabel, 1, Qt::AlignLeft);
}
gridLayout->addLayout(familyLayout, row, 0);
QHBoxLayout *styleLayout = new QHBoxLayout();
if (flags & ShowDifferences) {
d->styleCheckbox = new QCheckBox(i18nc("@option:check","Font style"), page);
connect(d->styleCheckbox, SIGNAL(toggled(bool)), this, SLOT(_k_toggled_checkbox()));
styleLayout->addWidget(d->styleCheckbox, 0, Qt::AlignLeft);
d->styleCheckbox->setWhatsThis(i18nc("@info:whatsthis","Enable this checkbox to change the font style settings."));
d->styleCheckbox->setToolTip(i18nc("@info:tooltip","Change font style?"));
d->styleLabel = nullptr;
} else {
d->styleCheckbox = nullptr;
d->styleLabel = new QLabel(i18n("Font style:"), page);
styleLayout->addWidget(d->styleLabel, 1, Qt::AlignLeft);
}
styleLayout->addSpacing(checkBoxGap);
gridLayout->addLayout(styleLayout, row, 1);
QHBoxLayout *sizeLayout = new QHBoxLayout();
if ( flags & ShowDifferences ) {
d->sizeCheckbox = new QCheckBox(i18nc("@option:check","Size"),page);
connect(d->sizeCheckbox, SIGNAL(toggled(bool)), this, SLOT(_k_toggled_checkbox()));
sizeLayout->addWidget(d->sizeCheckbox, 0, Qt::AlignLeft);
d->sizeCheckbox->setWhatsThis(i18nc("@info:whatsthis","Enable this checkbox to change the font size settings."));
d->sizeCheckbox->setToolTip(i18nc("@info:tooltip","Change font size?"));
d->sizeLabel = nullptr;
} else {
d->sizeCheckbox = nullptr;
d->sizeLabel = new QLabel(i18nc("@label:listbox Font size", "Size:"), page);
sizeLayout->addWidget(d->sizeLabel, 1, Qt::AlignLeft);
}
sizeLayout->addSpacing(checkBoxGap);
sizeLayout->addSpacing(checkBoxGap); // prevent label from eating border
gridLayout->addLayout(sizeLayout, row, 2);
row ++;
//
// now create the actual boxes that hold the info
//
d->familyListBox = new KListWidget(page);
d->familyListBox->setEnabled(flags ^ ShowDifferences);
gridLayout->addWidget(d->familyListBox, row, 0);
QString fontFamilyWhatsThisText = i18nc("@info:whatsthis","Here you can choose the font family to be used.");
d->familyListBox->setWhatsThis(fontFamilyWhatsThisText);
if (flags & ShowDifferences) {
d->familyCheckbox->setWhatsThis(fontFamilyWhatsThisText);
} else {
d->familyLabel->setWhatsThis(fontFamilyWhatsThisText);
}
connect(d->familyListBox, SIGNAL(currentTextChanged(QString)), this, SLOT(_k_family_chosen_slot(QString)));
if (!fontList.isEmpty()) {
d->setFamilyBoxItems(fontList);
} else {
d->fillFamilyListBox(flags & FixedFontsOnly);
}
d->familyListBox->setMinimumWidth(minimumListWidth(d->familyListBox));
d->familyListBox->setMinimumHeight(minimumListHeight(d->familyListBox, visibleListSize));
d->styleListBox = new KListWidget(page);
d->styleListBox->setEnabled(flags ^ ShowDifferences);
gridLayout->addWidget(d->styleListBox, row, 1);
d->styleListBox->setWhatsThis(i18nc("@info:whatsthis","Here you can choose the font style to be used."));
if ( flags & ShowDifferences) {
d->styleCheckbox->setWhatsThis(fontFamilyWhatsThisText);
} else {
d->styleLabel->setWhatsThis(fontFamilyWhatsThisText);
}
// Populate usual styles, to determine minimum list width;
// will be replaced later with correct styles.
d->styleListBox->addItem(I18NC_NOX("QFontDatabase", "Normal"));
d->styleListBox->addItem(i18nc("@item font","Italic"));
d->styleListBox->addItem(i18nc("@item font","Oblique"));
d->styleListBox->addItem(i18nc("@item font","Bold"));
d->styleListBox->addItem(i18nc("@item font","Bold Italic"));
d->styleListBox->setMinimumWidth(minimumListWidth( d->styleListBox));
d->styleListBox->setMinimumHeight(minimumListHeight(d->styleListBox, visibleListSize));
connect(d->styleListBox, SIGNAL(currentTextChanged(QString)), this, SLOT(_k_style_chosen_slot(QString)));
d->sizeListBox = new KListWidget(page);
d->sizeOfFont = new KDoubleNumInput(page);
d->sizeOfFont->setMinimum(4);
d->sizeOfFont->setMaximum(999);
d->sizeOfFont->setDecimals(1);
d->sizeOfFont->setSingleStep(1);
d->sizeOfFont->setSliderEnabled(false);
d->sizeListBox->setEnabled(flags ^ ShowDifferences);
d->sizeOfFont->setEnabled(flags ^ ShowDifferences);
if( sizeIsRelativeState ) {
QString sizeIsRelativeCBText = i18nc("@item font size","Relative");
QString sizeIsRelativeCBToolTipText = i18n("Font size<br /><i>fixed</i> or <i>relative</i><br />to environment");
QString sizeIsRelativeCBWhatsThisText = i18n(
"Here you can switch between fixed font size and font size "
"to be calculated dynamically and adjusted to changing "
"environment (e.g. widget dimensions, paper size)."
);
d->sizeIsRelativeCheckBox = new QCheckBox(sizeIsRelativeCBText, page);
d->sizeIsRelativeCheckBox->setTristate(flags & ShowDifferences);
QGridLayout *sizeLayout2 = new QGridLayout();
sizeLayout2->setSpacing( KDialog::spacingHint() / 2);
gridLayout->addLayout(sizeLayout2, row, 2);
sizeLayout2->setColumnStretch(1, 1); // to prevent text from eating the right border
sizeLayout2->addWidget( d->sizeOfFont, 0, 0, 1, 2);
sizeLayout2->addWidget(d->sizeListBox, 1,0, 1,2);
sizeLayout2->addWidget(d->sizeIsRelativeCheckBox, 2, 0, Qt::AlignLeft);
d->sizeIsRelativeCheckBox->setWhatsThis(sizeIsRelativeCBWhatsThisText);
d->sizeIsRelativeCheckBox->setToolTip(sizeIsRelativeCBToolTipText);
} else {
d->sizeIsRelativeCheckBox = nullptr;
QGridLayout *sizeLayout2 = new QGridLayout();
sizeLayout2->setSpacing( KDialog::spacingHint() / 2);
gridLayout->addLayout(sizeLayout2, row, 2);
sizeLayout2->addWidget( d->sizeOfFont, 0, 0);
sizeLayout2->addWidget(d->sizeListBox, 1,0);
}
QString fontSizeWhatsThisText = i18n("Here you can choose the font size to be used.");
d->sizeListBox->setWhatsThis(fontSizeWhatsThisText);
if ( flags & ShowDifferences ) {
d->sizeCheckbox->setWhatsThis(fontSizeWhatsThisText);
} else {
d->sizeLabel->setWhatsThis(fontSizeWhatsThisText);
}
// Populate with usual sizes, to determine minimum list width;
// will be replaced later with correct sizes.
d->fillSizeList();
d->sizeListBox->setMinimumWidth(minimumListWidth(d->sizeListBox) + d->sizeListBox->fontMetrics().maxWidth());
d->sizeListBox->setMinimumHeight(minimumListHeight(d->sizeListBox, visibleListSize));
connect(d->sizeOfFont, SIGNAL(valueChanged(double)), this, SLOT(_k_size_value_slot(double)));
connect(d->sizeListBox, SIGNAL(currentTextChanged(QString)), this, SLOT(_k_size_chosen_slot(QString)) );
row++;
// Completed the font attribute grid.
// Add the font preview into the lower part of the splitter.
d->sampleEdit = new SampleEdit(page);
d->sampleEdit->setAcceptRichText(false);
QFont tmpFont( KGlobalSettings::generalFont().family(), 64, QFont::Black );
d->sampleEdit->setFont(tmpFont);
d->sampleEdit->setMinimumHeight( d->sampleEdit->fontMetrics().lineSpacing() );
// i18n: A classical test phrase, with all letters of the English alphabet.
// Replace it with a sample text in your language, such that it is
// representative of language's writing system.
// If you wish, you can input several lines of text separated by \n.
setSampleText(i18n("The Quick Brown Fox Jumps Over The Lazy Dog"));
d->sampleEdit->setTextCursor(QTextCursor(d->sampleEdit->document()));
QString sampleEditWhatsThisText = i18n(
"This sample text illustrates the current settings. "
"You may edit it to test special characters."
);
d->sampleEdit->setWhatsThis(sampleEditWhatsThisText );
connect(this, SIGNAL(fontSelected(QFont)), this, SLOT(_k_displaySample(QFont)));
splitter->addWidget(d->sampleEdit);
// Finished setting up the splitter.
// lets initialize the display if possible
setFont(d->usingFixed ? KGlobalSettings::fixedFont() : KGlobalSettings::generalFont(), d->usingFixed);
// check or uncheck or gray out the "relative" checkbox
if (sizeIsRelativeState && d->sizeIsRelativeCheckBox) {
setSizeIsRelative(*sizeIsRelativeState);
}
// Set focus to the size list as this is the most commonly changed property
d->sizeListBox->setFocus();
}
KFontChooser::~KFontChooser()
{
delete d;
}
void KFontChooser::setColor( const QColor & col )
{
d->m_palette.setColor( QPalette::Active, QPalette::Text, col );
QPalette pal = d->sampleEdit->palette();
pal.setColor( QPalette::Active, QPalette::Text, col );
d->sampleEdit->setPalette( pal );
QTextCursor cursor = d->sampleEdit->textCursor();
d->sampleEdit->selectAll();
d->sampleEdit->setTextColor( col );
d->sampleEdit->setTextCursor( cursor );
}
QColor KFontChooser::color() const
{
return d->m_palette.color(QPalette::Active, QPalette::Text);
}
void KFontChooser::setBackgroundColor(const QColor &col)
{
d->m_palette.setColor(QPalette::Active, QPalette::Base, col);
QPalette pal = d->sampleEdit->palette();
pal.setColor(QPalette::Active, QPalette::Base, col);
d->sampleEdit->setPalette(pal);
}
QColor KFontChooser::backgroundColor() const
{
return d->m_palette.color(QPalette::Active, QPalette::Base);
}
void KFontChooser::setSizeIsRelative(const Qt::CheckState relative)
{
// check or uncheck or gray out the "relative" checkbox
if (d->sizeIsRelativeCheckBox) {
if (Qt::PartiallyChecked == relative) {
d->sizeIsRelativeCheckBox->setCheckState(Qt::PartiallyChecked);
} else {
d->sizeIsRelativeCheckBox->setCheckState(Qt::Checked == relative ? Qt::Checked : Qt::Unchecked);
}
}
}
Qt::CheckState KFontChooser::sizeIsRelative() const
{
if (d->sizeIsRelativeCheckBox) {
return d->sizeIsRelativeCheckBox->checkState();
}
return Qt::PartiallyChecked;
}
QString KFontChooser::sampleText() const
{
return d->sampleEdit->toPlainText();
}
void KFontChooser::setSampleText(const QString &text)
{
d->sampleEdit->setPlainText(text);
}
void KFontChooser::setSampleBoxVisible(bool visible)
{
d->sampleEdit->setVisible(visible);
}
QSize KFontChooser::sizeHint() const
{
return minimumSizeHint();
}
void KFontChooser::enableColumn(int column, bool state)
{
if (column & FamilyList) {
d->familyListBox->setEnabled(state);
}
if (column & StyleList) {
d->styleListBox->setEnabled(state);
}
if (column & SizeList) {
d->sizeListBox->setEnabled(state);
d->sizeOfFont->setEnabled(state);
}
}
void KFontChooser::setFont(const QFont &aFont, bool onlyFixed)
{
d->selFont = aFont;
d->selectedSize=aFont.pointSizeF();
if (d->selectedSize == -1) {
d->selectedSize = d->fontdb.font(aFont.family(), aFont.styleName(), aFont.pointSize()).pointSizeF();
}
if (onlyFixed != d->usingFixed) {
d->usingFixed = onlyFixed;
d->fillFamilyListBox(d->usingFixed);
}
d->setupDisplay();
}
KFontChooser::FontDiffFlags KFontChooser::fontDiffFlags() const
{
FontDiffFlags diffFlags = NoFontDiffFlags;
if (d->familyCheckbox && d->familyCheckbox->isChecked()) {
diffFlags |= FontDiffFamily;
}
if (d->styleCheckbox && d->styleCheckbox->isChecked()) {
diffFlags |= FontDiffStyle;
}
if (d->sizeCheckbox && d->sizeCheckbox->isChecked()) {
diffFlags |= FontDiffSize;
}
return diffFlags;
}
QFont KFontChooser::font() const
{
return d->selFont;
}
void KFontChooser::Private::_k_toggled_checkbox()
{
familyListBox->setEnabled(familyCheckbox->isChecked());
styleListBox->setEnabled(styleCheckbox->isChecked());
sizeListBox->setEnabled(sizeCheckbox->isChecked());
sizeOfFont->setEnabled(sizeCheckbox->isChecked());
}
void KFontChooser::Private::_k_family_chosen_slot(const QString &family)
{
if (!signalsAllowed) {
return;
}
signalsAllowed = false;
QString currentFamily;
if (family.isEmpty()) {
Q_ASSERT(familyListBox->currentItem());
if (familyListBox->currentItem()) {
currentFamily = qtFamilies[familyListBox->currentItem()->text()];
}
} else {
currentFamily = qtFamilies[family];
}
// Get the list of styles available in this family.
QStringList styles = fontdb.styles(currentFamily);
if (styles.isEmpty()) {
// Avoid extraction, it is in kdeqt.po
styles.append(I18NC_NOX("QFontDatabase", "Normal"));
}
// Filter style strings and add to the listbox.
QStringList filteredStyles;
qtStyles.clear();
styleIDs.clear();
QMutableListIterator<QString> stylesit(styles);
while (stylesit.hasNext()) {
const QString style = stylesit.next();
// Sometimes the font database will report an invalid style,
// that falls back back to another when set.
// Remove such styles, by checking set/get round-trip.
QFont testFont = fontdb.font(currentFamily, style, 10);
if (fontdb.styleString(testFont) != style) {
stylesit.remove();
continue;
}
// i18n: Filtering message, so that translators can script the
// style string according to the font family name (e.g. may need
// noun-adjective congruence wrt. gender of the family name).
// The message provides the dynamic context 'family', which is
// the family name to which the style string corresponds.
QString fstyle = ki18nc("@item Font style", "%1").subs(style).toString();
if (!filteredStyles.contains(fstyle)) {
filteredStyles.append(fstyle);
qtStyles.insert(fstyle, style);
styleIDs.insert(fstyle, styleIdentifier(testFont));
}
}
styleListBox->clear();
styleListBox->addItems(filteredStyles);
// Try to set the current style in the listbox to that previous.
int listPos = filteredStyles.indexOf(selectedStyle.isEmpty() ? I18NC_NOX("QFontDatabase", "Normal") : selectedStyle);
if (listPos < 0) {
// Make extra effort to have Italic selected when Oblique was chosen,
// and vice versa, as that is what the user would probably want.
QString styleIt = i18nc("@item font", "Italic");
QString styleOb = i18nc("@item font", "Oblique");
for (int i = 0; i < 2; ++i) {
int pos = selectedStyle.indexOf(styleIt);
if (pos >= 0) {
QString style = selectedStyle;
style.replace(pos, styleIt.length(), styleOb);
listPos = filteredStyles.indexOf(style);
if (listPos >= 0) break;
}
qSwap(styleIt, styleOb);
}
}
styleListBox->setCurrentRow(listPos >= 0 ? listPos : 0);
QListWidgetItem* currentitem = styleListBox->currentItem();
if (currentitem) {
QString currentStyle = qtStyles[currentitem->text()];
// Recompute the size listbox for this family/style.
qreal currentSize = setupSizeListBox(currentFamily, currentStyle);
sizeOfFont->setValue(currentSize);
selFont = fontdb.font(currentFamily, currentStyle, int(currentSize));
if (fontdb.isScalable(currentFamily, currentStyle) && selFont.pointSize() == floor(currentSize)) {
selFont.setPointSizeF(currentSize);
}
emit q->fontSelected(selFont);
}
signalsAllowed = true;
}
void KFontChooser::Private::_k_style_chosen_slot(const QString &style)
{
if (!signalsAllowed) {
return;
}
signalsAllowed = false;
QString currentFamily = qtFamilies[familyListBox->currentItem()->text()];
QString currentStyle;
if (style.isEmpty()) {
currentStyle = qtStyles[styleListBox->currentItem()->text()];
} else {
currentStyle = qtStyles[style];
}
// Recompute the size listbox for this family/style.
qreal currentSize = setupSizeListBox(currentFamily, currentStyle);
sizeOfFont->setValue(currentSize);
selFont = fontdb.font(currentFamily, currentStyle, int(currentSize));
if (fontdb.isScalable(currentFamily, currentStyle) && selFont.pointSize() == floor(currentSize)) {
selFont.setPointSizeF(currentSize);
}
emit q->fontSelected(selFont);
if (!style.isEmpty()) {
selectedStyle = currentStyle;
}
signalsAllowed = true;
}
void KFontChooser::Private::_k_size_chosen_slot(const QString &size)
{
if (!signalsAllowed) {
return;
}
signalsAllowed = false;
qreal currentSize;
if (size.isEmpty()) {
currentSize = KGlobal::locale()->readNumber(sizeListBox->currentItem()->text());
} else {
currentSize = KGlobal::locale()->readNumber(size);
}
// Reset the customized size slot in the list if not needed.
if (customSizeRow >= 0 && selFont.pointSizeF() != currentSize) {
sizeListBox->item(customSizeRow)->setText(standardSizeAtCustom);
customSizeRow = -1;
}
sizeOfFont->setValue(currentSize);
selFont.setPointSizeF(currentSize);
emit q->fontSelected(selFont);
if (!size.isEmpty()) {
selectedSize = currentSize;
}
signalsAllowed = true;
}
void KFontChooser::Private::_k_size_value_slot(double dval)
{
if (!signalsAllowed) {
return;
}
signalsAllowed = false;
// We compare with qreal, so convert for platforms where qreal != double.
qreal val = qreal(dval);
QString family = qtFamilies[familyListBox->currentItem()->text()];
QString style = qtStyles[styleListBox->currentItem()->text()];
// Reset current size slot in list if it was customized.
if (customSizeRow >= 0 && sizeListBox->currentRow() == customSizeRow) {
sizeListBox->item(customSizeRow)->setText(standardSizeAtCustom);
customSizeRow = -1;
}
bool canCustomize = fontdb.isScalable(family, style);
// Set the current size in the size listbox.
int row = nearestSizeRow(val, canCustomize);
sizeListBox->setCurrentRow(row);
selectedSize = val;
selFont.setPointSizeF(val);
emit q->fontSelected( selFont );
signalsAllowed = true;
}
void KFontChooser::Private::_k_displaySample(const QFont &font)
{
sampleEdit->setFont(font);
// sampleEdit->setCursorPosition(0);
// kDebug() << "font:" << font.toString();
}
int KFontChooser::Private::nearestSizeRow(qreal val, bool customize)
{
qreal diff = 1000;
int row = 0;
for (int r = 0; r < sizeListBox->count(); ++r) {
qreal cval = KGlobal::locale()->readNumber(sizeListBox->item(r)->text());
if (qAbs(cval - val) < diff) {
diff = qAbs(cval - val);
row = r;
}
}
// For Qt-bad-sizes workaround: ignore value of customize, use true
if (customize && diff > 0) {
customSizeRow = row;
standardSizeAtCustom = sizeListBox->item(row)->text();
sizeListBox->item(row)->setText(formatFontSize(val));
}
return row;
}
qreal KFontChooser::Private::fillSizeList(const QList<qreal> &sizes_)
{
if (!sizeListBox) {
return 0; // assertion.
}
QList<qreal> sizes = sizes_;
bool canCustomize = false;
if (sizes.count() == 0) {
static const int c[] = {
4, 5, 6, 7,
8, 9, 10, 11,
12, 13, 14, 15,
16, 17, 18, 19,
20, 22, 24, 26,
28, 32, 48, 64,
72, 80, 96, 128,
0
};
for (int i = 0; c[i]; ++i) {
sizes.append(c[i]);
}
// Since sizes were not supplied, this is a vector font,
// and size slot customization is allowed.
canCustomize = true;
}
// Insert sizes into the listbox.
sizeListBox->clear();
qSort(sizes);
foreach (const qreal size, sizes) {
sizeListBox->addItem(formatFontSize(size));
}
// Return the nearest to selected size.
// If the font is vector, the nearest size is always same as selected,
// thus size slot customization is allowed.
// If the font is bitmap, the nearest size need not be same as selected,
// thus size slot customization is not allowed.
customSizeRow = -1;
int row = nearestSizeRow(selectedSize, canCustomize);
return KGlobal::locale()->readNumber(sizeListBox->item(row)->text());
}
qreal KFontChooser::Private::setupSizeListBox(const QString &family, const QString &style)
{
QList<qreal> sizes;
if (fontdb.isScalable(family, style)) {
// A vector font.
// sampleEdit->setPaletteBackgroundPixmap( VectorPixmap ); // TODO
} else {
// A bitmap font.
// sampleEdit->setPaletteBackgroundPixmap( BitmapPixmap ); // TODO
QList<int> pointSizes = fontdb.pointSizes(family, style);
foreach (const int size, pointSizes) {
sizes.append(qreal(size));
}
}
// Fill the listbox (uses default list of sizes if the given is empty).
// Collect the best fitting size to selected size, to use if not smooth.
qreal bestFitSize = fillSizeList(sizes);
// Set the best fit size as current in the listbox if available.
const QList<QListWidgetItem*> selectedSizeList = sizeListBox->findItems(formatFontSize(bestFitSize), Qt::MatchExactly);
if ( !selectedSizeList.isEmpty() ) {
sizeListBox->setCurrentItem(selectedSizeList.first());
}
//TODO - KDE4 : sizeListBox->scrollTo(sizeListBox->currentItem());
return bestFitSize;
}
void KFontChooser::Private::setupDisplay()
{
QString family = selFont.family().toLower();
QString styleID = styleIdentifier(selFont);
qreal size = selFont.pointSizeF();
if (size == -1) {
size = fontdb.font(selFont.family(), selFont.styleName(), selFont.pointSize()).pointSizeF();
}
int numEntries, i;
// Direct family match.
numEntries = familyListBox->count();
for (i = 0; i < numEntries; i++) {
if (family == qtFamilies[familyListBox->item(i)->text()].toLower()) {
familyListBox->setCurrentRow(i);
break;
}
}
// 1st family fallback.
if (i == numEntries) {
if (family.contains('[')) {
family = family.left(family.indexOf('[')).trimmed();
for (i = 0; i < numEntries; i++) {
if (family == qtFamilies[familyListBox->item(i)->text()].toLower()) {
familyListBox->setCurrentRow(i);
break;
}
}
}
}
// 2nd family fallback.
if (i == numEntries) {
QString fallback = family+" [";
for (i = 0; i < numEntries; i++) {
if (qtFamilies[familyListBox->item(i)->text()].toLower().startsWith(fallback)) {
familyListBox->setCurrentRow(i);
break;
}
}
}
// 3rd family fallback.
if (i == numEntries) {
for (i = 0; i < numEntries; i++) {
if (qtFamilies[familyListBox->item(i)->text()].toLower().startsWith(family)) {
familyListBox->setCurrentRow(i);
break;
}
}
}
// Family fallback in case nothing matched. Otherwise, diff doesn't work
if (i == numEntries) {
familyListBox->setCurrentRow(0);
}
// By setting the current item in the family box, the available
// styles and sizes for that family have been collected.
// Try now to set the current items in the style and size boxes.
// Set current style in the listbox.
numEntries = styleListBox->count();
for (i = 0; i < numEntries; i++) {
if (styleID == styleIDs[styleListBox->item(i)->text()]) {
styleListBox->setCurrentRow(i);
break;
}
}
if (i == numEntries) {
// Style not found, fallback.
styleListBox->setCurrentRow(0);
}
// Set current size in the listbox.
// If smoothly scalable, allow customizing one of the standard size slots,
// otherwise just select the nearest available size.
QString currentFamily = qtFamilies[familyListBox->currentItem()->text()];
QString currentStyle = qtStyles[styleListBox->currentItem()->text()];
bool canCustomize = fontdb.isScalable(currentFamily, currentStyle);
sizeListBox->setCurrentRow(nearestSizeRow(size, canCustomize));
// Set current size in the spinbox.
sizeOfFont->setValue(KGlobal::locale()->readNumber(sizeListBox->currentItem()->text()));
}
void KFontChooser::getFontList(QStringList &list, const uint fontListCriteria)
{
QFontDatabase fdb;
QStringList lstSys(fdb.families());
// if we have criteria; then check fonts before adding
if (fontListCriteria) {
QStringList lstFonts;
for (QStringList::const_iterator it = lstSys.constBegin(); it != lstSys.constEnd(); ++it) {
if ((fontListCriteria & FixedWidthFonts) > 0 && !fdb.isFixedPitch(*it)) continue;
if ((fontListCriteria & SmoothScalableFonts) > 0 && !fdb.isScalable(*it)) continue;
lstFonts.append(*it);
}
if((fontListCriteria & FixedWidthFonts) > 0) {
// Fallback.. if there are no fixed fonts found, it's probably a
// bug in the font server or Qt. In this case, just use 'fixed'
if (lstFonts.count() == 0) {
lstFonts.append("fixed");
}
}
lstSys = lstFonts;
}
lstSys.sort();
list = lstSys;
}
void KFontChooser::Private::setFamilyBoxItems(const QStringList &fonts)
{
signalsAllowed = false;
QStringList trfonts = translateFontNameList(fonts, &qtFamilies);
familyListBox->clear();
familyListBox->addItems(trfonts);
signalsAllowed = true;
}
void KFontChooser::Private::fillFamilyListBox(bool onlyFixedFonts)
{
QStringList fontList;
getFontList(fontList, onlyFixedFonts ? FixedWidthFonts : 0);
setFamilyBoxItems(fontList);
}
// Human-readable style identifiers returned by QFontDatabase::styleString()
// do not always survive round trip of QFont serialization/deserialization,
// causing wrong style in the style box to be highlighted when
// the chooser dialog is opened. This will cause the style to be changed
// when the dialog is closed and the user did not touch the style box.
// Hence, construct custom style identifiers sufficient for the purpose.
QString KFontChooser::Private::styleIdentifier(const QFont &font)
{
const QChar comma(QLatin1Char(','));
return QString::number(font.weight()) + comma
+ QString::number((int)font.style()) + comma
+ QString::number(font.stretch());
}
#include "moc_kfontchooser.cpp"
#include "moc_sampleedit_p.cpp"

274
kdeui/fonts/kfontchooser.h
View file

@ -1,274 +0,0 @@
/*
Requires the Qt widget libraries, available at no cost at
http://www.troll.no
Copyright (C) 1997 Bernd Johannes Wuebben <wuebben@kde.org>
Copyright (c) 1999 Preston Brown <pbrown@kde.org>
Copyright (c) 1999 Mario Weilguni <mweilguni@kde.org>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public License
along with this library; see the file COPYING.LIB. If not, write to
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA.
*/
#ifndef KFONTCHOOSER_H
#define KFONTCHOOSER_H
#include <kdeui_export.h>
#include <QtGui/QWidget>
#include <QFont>
#include <QStringList>
/**
* @short A font selection widget.
*
* While KFontChooser as an ordinary widget can be embedded in
* custom dialogs and therefore is very flexible, in most cases
* it is preferable to use the convenience functions in
* KFontDialog.
*
* \image html kfontchooser.png "KDE Font Chooser Widget"
*
* @see KFontRequester
*
* @author Preston Brown <pbrown@kde.org>, Bernd Wuebben <wuebben@kde.org>
*/
class KDEUI_EXPORT KFontChooser : public QWidget
{
Q_OBJECT
Q_PROPERTY(QFont font READ font WRITE setFont NOTIFY fontSelected USER true)
Q_PROPERTY(QColor color READ color WRITE setColor)
Q_PROPERTY(QColor backgroundColor READ backgroundColor WRITE setBackgroundColor)
Q_PROPERTY(Qt::CheckState sizeIsRelative READ sizeIsRelative WRITE setSizeIsRelative)
Q_PROPERTY(QString sampleText READ sampleText WRITE setSampleText)
public:
/**
* The selection criteria for the font families shown in the dialog.
* @li @p FixedWidthFont when included only fixed-width fonts are returned.
* The fonts where the width of every character is equal.
* @li @p SmoothScalableFont when included only return smooth scalable fonts.
* this will return only non-bitmap fonts which are scalable to any size requested.
* Setting this option to true will mean the "scalable" flag is irrelavant.
*/
enum FontListCriteria {
FixedWidthFonts = 0x01,
SmoothScalableFonts = 0x02
};
/**
* @li @p FamilyList - Identifies the family (leftmost) list.
* @li @p StyleList - Identifies the style (center) list.
* @li @p SizeList - Identifies the size (rightmost) list.
*/
enum FontColumn {
FamilyList = 0x01,
StyleList = 0x02,
SizeList = 0x04
};
/**
* @li @p FontDiffFamily - Identifies a requested change in the font family.
* @li @p FontDiffStyle - Identifies a requested change in the font style.
* @li @p FontDiffSize - Identifies a requested change in the font size.
*/
enum FontDiff {
NoFontDiffFlags = 0,
FontDiffFamily = 1,
FontDiffStyle = 2,
FontDiffSize = 4,
AllFontDiffs = FontDiffFamily | FontDiffStyle | FontDiffSize
};
Q_DECLARE_FLAGS(FontDiffFlags, FontDiff)
/**
* @li @p FixedFontsOnly only show fixed fonts, excluding proportional fonts
* @li @p DisplayFrame show a visual frame around the chooser
* @li @p ShowDifferences display the font differences interfaces
*/
enum DisplayFlag {
NoDisplayFlags = 0,
FixedFontsOnly = 1,
DisplayFrame = 2,
ShowDifferences = 4
};
Q_DECLARE_FLAGS(DisplayFlags, DisplayFlag)
/**
* Constructs a font picker widget.
* It normally comes up with all font families present on the system; the
* getFont method below does allow some more fine-tuning of the selection of fonts
* that will be displayed in the dialog.
* <p>Consider the following code snippet;
* \code
* QStringList list;
* KFontChooser::getFontList(list, KFontChooser::SmoothScalableFonts);
* KFontChooser *chooseFont = new KFontChooser(0, NoDisplayFlags, list);
* \endcode
* <p>
* The above creates a font chooser dialog with only SmoothScaleble fonts.
*
* @param parent The parent widget.
* @param flags Defines how the font chooser is displayed. @see DisplayFlags
* @param fontList A list of fonts families to display. If the list is
* empty, all fonts available on the system are displayed.
* @param visibleListSize The minimum number of visible entries in the
* fontlists.
* @param sizeIsRelativeState If not zero the widget will show a
* checkbox where the user may choose whether the font size
* is to be interpreted as relative size.
* Initial state of this checkbox will be set according to
* *sizeIsRelativeState, user choice may be retrieved by
* calling sizeIsRelative().
*/
explicit KFontChooser(QWidget *parent = nullptr,
const DisplayFlags flags = DisplayFrame,
const QStringList &fontList = QStringList(),
int visibleListSize = 8,
Qt::CheckState *sizeIsRelativeState = nullptr);
/**
* Destructs the font chooser.
*/
virtual ~KFontChooser();
/**
* Enables or disable a font column in the chooser.
*
* Use this function if your application does not need or supports all font
* properties.
*
* @param column Specify the columns. An or'ed combination of
* @p FamilyList, @p StyleList and @p SizeList is possible.
* @param state If @p false the columns are disabled.
*/
void enableColumn(int column, bool state);
/**
* Sets the currently selected font in the chooser.
*
* @param font The font to select.
* @param onlyFixed Readjust the font list to display only fixed
* width fonts if @p true, or vice-versa.
*/
void setFont(const QFont &font, bool onlyFixed = false);
/**
* @return The bitmask corresponding to the attributes the user
* wishes to change.
*/
FontDiffFlags fontDiffFlags() const;
/**
* @return The currently selected font in the chooser.
*/
QFont font() const;
/**
* Sets the color to use in the preview.
*/
void setColor(const QColor &col);
/**
* @return The color currently used in the preview (default: the text
* color of the active color group)
*/
QColor color() const;
/**
* Sets the background color to use in the preview.
*/
void setBackgroundColor(const QColor &col);
/**
* @return The background color currently used in the preview (default:
* the base color of the active colorgroup)
*/
QColor backgroundColor() const;
/**
* Sets the state of the checkbox indicating whether the font size
* is to be interpreted as relative size.
* NOTE: If parameter sizeIsRelative was not set in the constructor
* of the widget this setting will be ignored.
*/
void setSizeIsRelative(const Qt::CheckState relative);
/**
* @return Whether the font size is to be interpreted as relative size
* (default: QButton:Off)
*/
Qt::CheckState sizeIsRelative() const;
/**
* @return The current text in the sample text input area.
*/
QString sampleText() const;
/**
* Sets the sample text.
*
* Normally you should not change this
* text, but it can be better to do this if the default text is
* too large for the edit area when using the default font of your
* application.
*
* @param text The new sample text. The current will be removed.
*/
void setSampleText(const QString &text);
/**
* Shows or hides the sample text box.
*
* @param visible Set it to true to show the box, to false to hide it.
*/
void setSampleBoxVisible(bool visible);
/**
* Creates a list of font strings.
*
* @param list The list is returned here.
* @param fontListCriteria should contain all the restrictions for font selection as OR-ed values
* @see KFontChooser::FontListCriteria for the individual values
*/
static void getFontList(QStringList &list, const uint fontListCriteria);
/**
* Reimplemented for internal reasons.
*/
virtual QSize sizeHint() const;
Q_SIGNALS:
/**
* Emitted whenever the selected font changes.
*/
void fontSelected(const QFont &font);
private:
Q_DISABLE_COPY(KFontChooser)
class Private;
Private * const d;
Q_PRIVATE_SLOT(d, void _k_toggled_checkbox())
Q_PRIVATE_SLOT(d, void _k_family_chosen_slot(const QString &))
Q_PRIVATE_SLOT(d, void _k_size_chosen_slot(const QString &))
Q_PRIVATE_SLOT(d, void _k_style_chosen_slot(const QString &))
Q_PRIVATE_SLOT(d, void _k_displaySample(const QFont &font))
Q_PRIVATE_SLOT(d, void _k_size_value_slot(double))
};
Q_DECLARE_OPERATORS_FOR_FLAGS(KFontChooser::DisplayFlags)
#endif // KFONTCHOOSER_H

174
kdeui/fonts/kfontdialog.cpp
View file

@ -1,174 +0,0 @@
/*
Requires the Qt widget libraries, available at no cost at
http://www.troll.no
Copyright (C) 1996 Bernd Johannes Wuebben <wuebben@kde.org>
Copyright (c) 1999 Preston Brown <pbrown@kde.org>
Copyright (c) 1999 Mario Weilguni <mweilguni@kde.org>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public License
along with this library; see the file COPYING.LIB. If not, write to
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA.
*/
#include "kfontdialog.h"
#include <config.h>
#include <stdio.h>
#include <stdlib.h>
#include <QComboBox>
#include <QCheckBox>
#include <QFile>
#include <QFont>
#include <QLabel>
#include <QLayout>
#include <QScrollBar>
#include <QStringList>
#include <QList>
#include <QGroupBox>
#include <kcharsets.h>
#include <kconfig.h>
#include <kdialog.h>
#include <kglobal.h>
#include <kglobalsettings.h>
#include <klistwidget.h>
#include <klocale.h>
#include <kstandarddirs.h>
#include <kdebug.h>
#include <knuminput.h>
#include <kconfiggroup.h>
class KFontDialog::Private
{
public:
Private()
: chooser(nullptr)
{
}
KFontChooser *chooser;
};
KFontDialog::KFontDialog(QWidget *parent,
const KFontChooser::DisplayFlags flags,
const QStringList &fontList,
Qt::CheckState *sizeIsRelativeState)
: KDialog(parent),
d(new Private())
{
setCaption(i18n("Select Font"));
setButtons(KDialog::Ok | KDialog::Cancel);
setDefaultButton(KDialog::Ok);
d->chooser = new KFontChooser(this, flags, fontList, 8, sizeIsRelativeState);
d->chooser->setObjectName("fontChooser");
connect(d->chooser , SIGNAL(fontSelected(QFont)), this , SIGNAL(fontSelected(QFont)));
setMainWidget(d->chooser);
}
KFontDialog::~KFontDialog()
{
delete d;
}
void KFontDialog::setFont(const QFont &font, bool onlyFixed)
{
d->chooser->setFont(font, onlyFixed);
}
QFont KFontDialog::font() const
{
return d->chooser->font();
}
void KFontDialog::setSizeIsRelative(const Qt::CheckState relative)
{
d->chooser->setSizeIsRelative(relative);
}
Qt::CheckState KFontDialog::sizeIsRelative() const
{
return d->chooser->sizeIsRelative();
}
int KFontDialog::getFontDiff(QFont &theFont,
KFontChooser::FontDiffFlags& diffFlags,
const KFontChooser::DisplayFlags flags,
QWidget *parent,
Qt::CheckState *sizeIsRelativeState )
{
KFontDialog dlg(parent, flags | KFontChooser::ShowDifferences, QStringList(), sizeIsRelativeState);
dlg.setModal(true);
dlg.setObjectName("Font Selector");
dlg.setFont(theFont, flags & KFontChooser::FixedFontsOnly);
const int result = dlg.exec();
if (result == KDialog::Accepted) {
theFont = dlg.d->chooser->font();
diffFlags = dlg.d->chooser->fontDiffFlags();
if (sizeIsRelativeState) {
*sizeIsRelativeState = dlg.d->chooser->sizeIsRelative();
}
}
return result;
}
int KFontDialog::getFont(QFont &theFont,
const KFontChooser::DisplayFlags flags,
QWidget *parent,
Qt::CheckState *sizeIsRelativeState)
{
KFontDialog dlg(parent, flags, QStringList(), sizeIsRelativeState);
dlg.setModal(true);
dlg.setObjectName("Font Selector");
dlg.setFont(theFont, flags & KFontChooser::FixedFontsOnly);
const int result = dlg.exec();
if (result == KDialog::Accepted) {
theFont = dlg.d->chooser->font();
if (sizeIsRelativeState) {
*sizeIsRelativeState = dlg.d->chooser->sizeIsRelative();
}
}
return result;
}
int KFontDialog::getFontAndText(QFont &theFont, QString &theString,
const KFontChooser::DisplayFlags flags,
QWidget *parent,
Qt::CheckState *sizeIsRelativeState)
{
KFontDialog dlg(parent, flags, QStringList(), sizeIsRelativeState );
dlg.setModal(true);
dlg.setObjectName("Font and Text Selector");
dlg.setFont(theFont, flags & KFontChooser::FixedFontsOnly);
const int result = dlg.exec();
if( result == KDialog::Accepted) {
theFont = dlg.d->chooser->font();
theString = dlg.d->chooser->sampleText();
if (sizeIsRelativeState) {
*sizeIsRelativeState = dlg.d->chooser->sizeIsRelative();
}
}
return result;
}
#include "moc_kfontdialog.cpp"

214
kdeui/fonts/kfontdialog.h
View file

@ -1,214 +0,0 @@
/*
Requires the Qt widget libraries, available at no cost at
http://www.troll.no
Copyright (C) 1997 Bernd Johannes Wuebben <wuebben@kde.org>
Copyright (c) 1999 Preston Brown <pbrown@kde.org>
Copyright (c) 1999 Mario Weilguni <mweilguni@kde.org>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public License
along with this library; see the file COPYING.LIB. If not, write to
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA.
*/
#ifndef KFONTDIALOG_H
#define KFONTDIALOG_H
#include <kdialog.h>
#include <kfontchooser.h>
#include <QFont>
#include <QStringList>
/**
* @short A font selection dialog.
*
* The KFontDialog provides a dialog for interactive font selection.
* It is basically a thin wrapper around the KFontChooser widget,
* which can also be used standalone. In most cases, the simplest
* use of this class is the static method KFontDialog::getFont(),
* which pops up the dialog, allows the user to select a font, and
* returns when the dialog is closed.
*
* Example:
*
* \code
* QFont myFont;
* int result = KFontDialog::getFont( myFont );
* if ( result == KFontDialog::Accepted )
* ...
* \endcode
*
* \image html kfontdialog.png "KDE Font Dialog"
*
* @author Preston Brown <pbrown@kde.org>, Bernd Wuebben <wuebben@kde.org>
*/
class KDEUI_EXPORT KFontDialog : public KDialog
{
Q_OBJECT
public:
/**
* Constructs a font selection dialog.
*
* @param parent The parent widget of the dialog, if any.
* @param flags Defines how the font chooser is displayed.
* @see KFontChooser::DisplayFlags
* @param fontlist a list of fonts to display, in XLFD format. If
* no list is formatted, the internal KDE font list is used.
* If that has not been created, X is queried, and all fonts
* available on the system are displayed.
* @param sizeIsRelativeState If not zero the widget will show a
* checkbox where the user may choose whether the font size
* is to be interpreted as relative size.
* Initial state of this checkbox will be set according to
* *sizeIsRelativeState, user choice may be retrieved by
* calling sizeIsRelative().
*
*/
explicit KFontDialog(QWidget *parent = nullptr,
const KFontChooser::DisplayFlags flags = KFontChooser::NoDisplayFlags,
const QStringList &fontlist = QStringList(),
Qt::CheckState *sizeIsRelativeState = nullptr);
~KFontDialog();
/**
* Sets the currently selected font in the dialog.
*
* @param font The font to select.
* @param onlyFixed readjust the font list to display only fixed
* width fonts if true, or vice-versa
*/
void setFont(const QFont &font, bool onlyFixed = false);
/**
* @return The currently selected font in the dialog.
*/
QFont font() const;
/**
* Sets the state of the checkbox indicating whether the font size
* is to be interpreted as relative size.
* NOTE: If parameter sizeIsRelative was not set in the constructor
* of the dialog this setting will be ignored.
*/
void setSizeIsRelative(const Qt::CheckState relative);
/**
* @return Whether the font size is to be interpreted as relative size
* (default: false)
*/
Qt::CheckState sizeIsRelative() const;
/**
* Creates a modal font dialog, lets the user choose a font,
* and returns when the dialog is closed.
*
* @param theFont a reference to the font to write the chosen font
* into.
* @param flags Defines how the font chooser is displayed.
* @see KFontChooser::DisplayFlags
* @param parent Parent widget of the dialog. Specifying a widget different
* from 0 (Null) improves centering (looks better).
* @param makeFrame Draws a frame with titles around the contents.
* @param sizeIsRelativeState If not zero the widget will show a
* checkbox where the user may choose whether the font size
* is to be interpreted as relative size.
* Initial state of this checkbox will be set according to
* *sizeIsRelativeState and user choice will be returned
* therein.
*
* @return QDialog::result().
*/
static int getFont(QFont &theFont,
const KFontChooser::DisplayFlags flags = KFontChooser::NoDisplayFlags,
QWidget *parent = nullptr,
Qt::CheckState *sizeIsRelativeState = nullptr);
/**
* Creates a modal font difference dialog, lets the user choose a selection
* of changes that should be made to a set of fonts, and returns when the
* dialog is closed. Useful for choosing slight adjustments to the font set
* when the user would otherwise have to manually edit a number of fonts.
*
* @param theFont a reference to the font to write the chosen font
* into.
* @param flags Defines how the font chooser is displayed.
* @see KFontChooser::DisplayFlags
* @param diffFlags a reference to the int into which the chosen
* difference selection bitmask should be written.
* Check the returned bitmask like:
* \code
* if ( diffFlags & KFontChooser::FontDiffFamily )
* [...]
* if ( diffFlags & KFontChooser::FontDiffStyle )
* [...]
* if ( diffFlags & KFontChooser::FontDiffSize )
* [...]
* \endcode
* @param parent Parent widget of the dialog. Specifying a widget different
* from 0 (Null) improves centering (looks better).
* @param sizeIsRelativeState If not zero the widget will show a
* checkbox where the user may choose whether the font size
* is to be interpreted as relative size.
* Initial state of this checkbox will be set according to
* *sizeIsRelativeState and user choice will be returned
* therein.
*
* @returns QDialog::result().
*/
static int getFontDiff(QFont &theFont,
KFontChooser::FontDiffFlags& diffFlags,
const KFontChooser::DisplayFlags flags = KFontChooser::NoDisplayFlags,
QWidget *parent = nullptr,
Qt::CheckState *sizeIsRelativeState = nullptr);
/**
* When you are not only interested in the font selected, but also
* in the example string typed in, you can call this method.
*
* @param theFont a reference to the font to write the chosen font
* into.
* @param theString a reference to the example text that was typed.
* @param flags Defines how the font chooser is displayed.
* @see KFontChooser::DisplayFlags
* @param parent Parent widget of the dialog. Specifying a widget different
* from 0 (Null) improves centering (looks better).
* @param sizeIsRelativeState If not zero the widget will show a
* checkbox where the user may choose whether the font size
* is to be interpreted as relative size.
* Initial state of this checkbox will be set according to
* *sizeIsRelativeState and user choice will be returned
* therein.
* @return The result of the dialog.
*/
static int getFontAndText(QFont &theFont, QString &theString,
const KFontChooser::DisplayFlags flags = KFontChooser::NoDisplayFlags,
QWidget *parent = nullptr,
Qt::CheckState *sizeIsRelativeState = nullptr);
Q_SIGNALS:
/**
* Emitted whenever the currently selected font changes.
* Connect to this to monitor the font as it is selected if you are
* not running modal.
*/
void fontSelected(const QFont &font);
private:
Q_DISABLE_COPY(KFontDialog)
class Private;
Private * const d;
};
#endif // KFONTDIALOG_H

19
kdeui/fonts/kfontrequester.cpp
View file

@ -19,14 +19,15 @@
#include "kfontrequester.h"
#include "fonthelpers_p.h"
#include "kglobal.h"
#include "klocale.h"
#include "kdialog.h"
#include <QtGui/QLabel>
#include <QtGui/QPushButton>
#include <QtGui/QLayout>
#include <QtGui/QFontDatabase>
#include <kfontdialog.h>
#include <klocale.h>
#include <QtGui/QFontDialog>
#include <cmath>
@ -182,14 +183,16 @@ void KFontRequester::setTitle(const QString &title)
void KFontRequester::KFontRequesterPrivate::_k_buttonClicked()
{
KFontChooser::DisplayFlags flags = KFontChooser::NoDisplayFlags;
QFontDialog::FontDialogOptions options = QFontDialog::AllFonts;
if (m_onlyFixed) {
flags |= KFontChooser::FixedFontsOnly;
options = QFontDialog::MonospacedFonts;
}
int result = KFontDialog::getFont(m_selFont, flags, q->parentWidget());
if (result == KDialog::Accepted) {
bool ok = false;
const QString title = KDialog::makeStandardCaption(i18n("Select Font"), q);
QFont result = QFontDialog::getFont(&ok, m_selFont, q->parentWidget(), title, options);
if (ok) {
m_selFont = result;
displaySampleText();
emit q->fontSelected(m_selFont);
}

2
kdeui/fonts/kfontrequester.h
View file

@ -31,7 +31,7 @@
/**
* This class provides a widget with a lineedit and a button, which invokes
* a font dialog (KFontDialog).
* a font dialog (QFontDialog).
*
* The lineedit provides a preview of the selected font. The preview text can
* be customized. You can also have the font dialog show only the fixed fonts.

161
kdeui/fonts/sampleedit_p.h
View file

@ -1,161 +0,0 @@
/*
Requires the Qt widget libraries, available at no cost at
http://www.troll.no
Copyright (C) 2007 Chusslove Illich <caslav.ilic@gmx.net>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public License
along with this library; see the file COPYING.LIB. If not, write to
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA.
*/
#ifndef SAMPLEEDIT_P_H
#define SAMPLEEDIT_P_H
#include <ktextedit.h>
#include <QFont>
#include <QString>
#include <QStringList>
#include <QSize>
#include <QTextFrame>
#include <kdebug.h>
// Derived to keep text centered when there is not enough of it for scrolling.
// Needed in KFontChooser for sample text.
class SampleEdit : public KTextEdit
{
Q_OBJECT
public:
SampleEdit (QWidget *parent = 0);
// Reimplemented to recenter on font change.
void setFont (const QFont &font);
// Reimplemented to assure centered alignment.
void setPlainText (const QString &text);
// Reimplemented to always state the current size as preferred.
QSize sizeHint () const;
private:
bool m_signalsAllowed;
void showEvent (QShowEvent *);
void resizeEvent (QResizeEvent *);
private Q_SLOTS:
void m_setMargins ();
};
SampleEdit::SampleEdit (QWidget *parent_) :
KTextEdit(parent_),
m_signalsAllowed(true)
{
connect(this, SIGNAL(textChanged()),
this, SLOT(m_setMargins()));
}
void SampleEdit::m_setMargins ()
{
// The margins are determined in a bit roundabout manner,
// in order to avoid resetting margins each time, to avoid flicker.
m_signalsAllowed = false;
// Repeat setting margins until they no longer change between iterations.
int maxIterations=6;
while (maxIterations--) {
if (document()->isEmpty()) {
QTextCursor cursor(document());
}
QTextFrame *root = document()->rootFrame();
QTextFrameFormat format = root->frameFormat();
int documentHeight = document()->size().height() - format.topMargin() - format.bottomMargin();
if (documentHeight == 0) {
documentHeight = fontMetrics().height();
}
int lrMargin = viewport()->width() / 100;
int tbMargin = (viewport()->height() - documentHeight) / 2;
tbMargin = tbMargin > lrMargin ? tbMargin : lrMargin;
if (tbMargin != format.topMargin() || lrMargin != format.leftMargin()) {
// Set new margins.
format.setLeftMargin(lrMargin);
format.setRightMargin(lrMargin);
format.setTopMargin(tbMargin);
format.setBottomMargin(tbMargin);
// Setting the new margins triggers textChanged(), avoid recursion
disconnect(this, SIGNAL(textChanged()), this, SLOT(m_setMargins()));
root->setFrameFormat(format);
connect(this, SIGNAL(textChanged()), this, SLOT(m_setMargins()));
// To remind vertical scrollbar to disappear if not needed.
setLineWrapMode(KTextEdit::WidgetWidth);
setLineWrapColumnOrWidth(viewport()->width());
}
else {
break;
}
}
m_signalsAllowed = true;
}
void SampleEdit::setFont (const QFont &font)
{
KTextEdit::setFont(font);
m_setMargins();
}
void SampleEdit::setPlainText (const QString &text)
{
// Add text line by line, to keep centering each.
clear();
QStringList lines = text.split("\n");
foreach (const QString &line, lines) {
append(line);
setAlignment(Qt::AlignCenter);
}
// Clear undo stack.
setUndoRedoEnabled(false);
setUndoRedoEnabled(true);
}
void SampleEdit::showEvent (QShowEvent *e)
{
if (!m_signalsAllowed) {
return;
}
m_setMargins();
KTextEdit::showEvent(e);
}
void SampleEdit::resizeEvent (QResizeEvent *e)
{
if (!m_signalsAllowed) {
return;
}
m_setMargins();
KTextEdit::resizeEvent(e);
}
QSize SampleEdit::sizeHint () const
{
return QSize(width(), height());
}
#endif

10
kdeui/icons/kicontheme.cpp
View file

@ -454,12 +454,6 @@ QString KIconTheme::current()
if ( *_theme == QLatin1String("hicolor") ) {
*_theme = defaultThemeName();
}
/*
if (_theme->isEmpty())
{
*_theme = defaultThemeName();
}
*/
return *_theme;
}
@ -483,10 +477,10 @@ QStringList KIconTheme::list()
if (!dir.exists()) {
continue;
}
const QStringList lst = dir.entryList(QDir::Dirs);
const QStringList lst = dir.entryList(QDir::Dirs | QDir::NoDotAndDotDot);
QStringList::ConstIterator it2;
for (it2=lst.begin(); it2!=lst.end(); ++it2) {
if ((*it2 == ".") || (*it2 == "..") || (*it2).startsWith(QLatin1String("default.")) ) {
if ((*it2).startsWith(QLatin1String("default.")) ) {
continue;
}
if (!KGlobal::dirs()->exists(*it + *it2 + "/index.theme")) {

8
kdewidgets/kde.widgets
View file

@ -98,15 +98,9 @@ ToolTip=Filter proxy search line
WhatsThis=A search line widget which works on a QSortFilterProxyModel
Group=Input (KDE)
[KFontChooser]
IncludeFile=kfontdialog.h
IconSet=kfontcombo.png
ToolTip=Font Chooser (KDE)
WhatsThis=A font type, size and style selection widget complete with preview
Group=Input (KDE)
[KFontRequester]
IncludeFile=kfontrequester.h
IconSet=kfontrequester.png
ToolTip=Font Requester (KDE)
WhatsThis=A compact font selection and preview widget
Group=Input (KDE)

1
kdewidgets/pics/CMakeLists.txt
View file

@ -25,7 +25,6 @@ install(
kcalendarwidget.png
kdialog.png
keditlistbox.png
kfontcombo.png
khistorycombo.png
kintnuminput.png
krestrictedline.png

BIN
kdewidgets/pics/kfontcombo.png
View file

Binary file not shown.
Side by side

Before

Width:  |  Height:  |  Size: 1.1 KiB