| /**************************************************************************** |
| ** |
| ** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). |
| ** All rights reserved. |
| ** Contact: Nokia Corporation (qt-info@nokia.com) |
| ** |
| ** This file is part of the QtGui module of the Qt Toolkit. |
| ** |
| ** $QT_BEGIN_LICENSE:LGPL$ |
| ** GNU Lesser General Public License Usage |
| ** This file may be used under the terms of the GNU Lesser General Public |
| ** License version 2.1 as published by the Free Software Foundation and |
| ** appearing in the file LICENSE.LGPL included in the packaging of this |
| ** file. Please review the following information to ensure the GNU Lesser |
| ** General Public License version 2.1 requirements will be met: |
| ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. |
| ** |
| ** In addition, as a special exception, Nokia gives you certain additional |
| ** rights. These rights are described in the Nokia Qt LGPL Exception |
| ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. |
| ** |
| ** GNU General Public License Usage |
| ** Alternatively, this file may be used under the terms of the GNU General |
| ** Public License version 3.0 as published by the Free Software Foundation |
| ** and appearing in the file LICENSE.GPL included in the packaging of this |
| ** file. Please review the following information to ensure the GNU General |
| ** Public License version 3.0 requirements will be met: |
| ** http://www.gnu.org/copyleft/gpl.html. |
| ** |
| ** Other Usage |
| ** Alternatively, this file may be used in accordance with the terms and |
| ** conditions contained in a signed written agreement between you and Nokia. |
| ** |
| ** |
| ** |
| ** |
| ** |
| ** $QT_END_LICENSE$ |
| ** |
| ****************************************************************************/ |
| |
| #include "qwindowdefs.h" |
| |
| #ifndef QT_NO_FONTDIALOG |
| |
| #include "qfontdialog.h" |
| #include "qfontdialog_p.h" |
| |
| #include <qapplication.h> |
| #include <qcheckbox.h> |
| #include <qcombobox.h> |
| #include <qevent.h> |
| #include <qfontdatabase.h> |
| #include <qgroupbox.h> |
| #include <qlabel.h> |
| #include <qlayout.h> |
| #include <qlineedit.h> |
| #include <qpushbutton.h> |
| #include <qstyle.h> |
| #include <qdialogbuttonbox.h> |
| #include <qheaderview.h> |
| #include <qlistview.h> |
| #include <qstringlistmodel.h> |
| #include <qvalidator.h> |
| #include <private/qdialog_p.h> |
| #include <private/qfont_p.h> |
| |
| #if defined(Q_WS_S60) |
| #include <QtGui/qdesktopwidget.h> |
| #endif |
| |
| QT_BEGIN_NAMESPACE |
| |
| class QFontListView : public QListView |
| { |
| Q_OBJECT |
| public: |
| QFontListView(QWidget *parent); |
| inline QStringListModel *model() const { |
| return static_cast<QStringListModel *>(QListView::model()); |
| } |
| inline void setCurrentItem(int item) { |
| QListView::setCurrentIndex(static_cast<QAbstractListModel*>(model())->index(item)); |
| } |
| inline int currentItem() const { |
| return QListView::currentIndex().row(); |
| } |
| inline int count() const { |
| return model()->rowCount(); |
| } |
| inline QString currentText() const { |
| int row = QListView::currentIndex().row(); |
| return row < 0 ? QString() : model()->stringList().at(row); |
| } |
| void currentChanged(const QModelIndex ¤t, const QModelIndex &previous) { |
| QListView::currentChanged(current, previous); |
| if (current.isValid()) |
| emit highlighted(current.row()); |
| } |
| QString text(int i) const { |
| return model()->stringList().at(i); |
| } |
| signals: |
| void highlighted(int); |
| }; |
| |
| QFontListView::QFontListView(QWidget *parent) |
| : QListView(parent) |
| { |
| setModel(new QStringListModel(parent)); |
| setEditTriggers(NoEditTriggers); |
| } |
| |
| static const Qt::WindowFlags DefaultWindowFlags = |
| Qt::Dialog | Qt::WindowSystemMenuHint; |
| |
| /*! |
| \class QFontDialog |
| \ingroup standard-dialogs |
| |
| \brief The QFontDialog class provides a dialog widget for selecting a font. |
| |
| A font dialog is created through one of the static getFont() |
| functions. |
| |
| Examples: |
| |
| \snippet doc/src/snippets/code/src_gui_dialogs_qfontdialog.cpp 0 |
| |
| The dialog can also be used to set a widget's font directly: |
| \snippet doc/src/snippets/code/src_gui_dialogs_qfontdialog.cpp 1 |
| If the user clicks OK the font they chose will be used for myWidget, |
| and if they click Cancel the original font is used. |
| |
| \image plastique-fontdialog.png A font dialog in the Plastique widget style. |
| |
| \sa QFont, QFontInfo, QFontMetrics, QColorDialog, QFileDialog, QPrintDialog, |
| {Standard Dialogs Example} |
| */ |
| |
| /*! |
| \since 4.5 |
| |
| Constructs a standard font dialog. |
| |
| Use setCurrentFont() to set the initial font attributes. |
| |
| The \a parent parameter is passed to the QDialog constructor. |
| |
| \sa getFont() |
| */ |
| QFontDialog::QFontDialog(QWidget *parent) |
| : QDialog(*new QFontDialogPrivate, parent, DefaultWindowFlags) |
| { |
| Q_D(QFontDialog); |
| d->init(); |
| } |
| |
| /*! |
| \since 4.5 |
| |
| Constructs a standard font dialog with the given \a parent and specified |
| \a initial font. |
| */ |
| QFontDialog::QFontDialog(const QFont &initial, QWidget *parent) |
| : QDialog(*new QFontDialogPrivate, parent, DefaultWindowFlags) |
| { |
| Q_D(QFontDialog); |
| d->init(); |
| setCurrentFont(initial); |
| } |
| |
| void QFontDialogPrivate::init() |
| { |
| Q_Q(QFontDialog); |
| |
| #ifdef Q_WS_MAC |
| nativeDialogInUse = false; |
| delegate = 0; |
| #endif |
| |
| q->setSizeGripEnabled(true); |
| q->setWindowTitle(QFontDialog::tr("Select Font")); |
| |
| // grid |
| familyEdit = new QLineEdit(q); |
| familyEdit->setReadOnly(true); |
| familyList = new QFontListView(q); |
| familyEdit->setFocusProxy(familyList); |
| |
| familyAccel = new QLabel(q); |
| #ifndef QT_NO_SHORTCUT |
| familyAccel->setBuddy(familyList); |
| #endif |
| familyAccel->setIndent(2); |
| |
| styleEdit = new QLineEdit(q); |
| styleEdit->setReadOnly(true); |
| styleList = new QFontListView(q); |
| styleEdit->setFocusProxy(styleList); |
| |
| styleAccel = new QLabel(q); |
| #ifndef QT_NO_SHORTCUT |
| styleAccel->setBuddy(styleList); |
| #endif |
| styleAccel->setIndent(2); |
| |
| sizeEdit = new QLineEdit(q); |
| sizeEdit->setFocusPolicy(Qt::ClickFocus); |
| QIntValidator *validator = new QIntValidator(1, 512, q); |
| sizeEdit->setValidator(validator); |
| sizeList = new QFontListView(q); |
| |
| sizeAccel = new QLabel(q); |
| #ifndef QT_NO_SHORTCUT |
| sizeAccel->setBuddy(sizeEdit); |
| #endif |
| sizeAccel->setIndent(2); |
| |
| // effects box |
| effects = new QGroupBox(q); |
| QVBoxLayout *vbox = new QVBoxLayout(effects); |
| strikeout = new QCheckBox(effects); |
| vbox->addWidget(strikeout); |
| underline = new QCheckBox(effects); |
| vbox->addWidget(underline); |
| |
| sample = new QGroupBox(q); |
| QHBoxLayout *hbox = new QHBoxLayout(sample); |
| sampleEdit = new QLineEdit(sample); |
| sampleEdit->setSizePolicy(QSizePolicy(QSizePolicy::Ignored, QSizePolicy::Ignored)); |
| sampleEdit->setAlignment(Qt::AlignCenter); |
| // Note that the sample text is *not* translated with tr(), as the |
| // characters used depend on the charset encoding. |
| sampleEdit->setText(QLatin1String("AaBbYyZz")); |
| hbox->addWidget(sampleEdit); |
| |
| writingSystemCombo = new QComboBox(q); |
| |
| writingSystemAccel = new QLabel(q); |
| #ifndef QT_NO_SHORTCUT |
| writingSystemAccel->setBuddy(writingSystemCombo); |
| #endif |
| writingSystemAccel->setIndent(2); |
| |
| size = 0; |
| smoothScalable = false; |
| |
| QObject::connect(writingSystemCombo, SIGNAL(activated(int)), q, SLOT(_q_writingSystemHighlighted(int))); |
| QObject::connect(familyList, SIGNAL(highlighted(int)), q, SLOT(_q_familyHighlighted(int))); |
| QObject::connect(styleList, SIGNAL(highlighted(int)), q, SLOT(_q_styleHighlighted(int))); |
| QObject::connect(sizeList, SIGNAL(highlighted(int)), q, SLOT(_q_sizeHighlighted(int))); |
| QObject::connect(sizeEdit, SIGNAL(textChanged(QString)), q, SLOT(_q_sizeChanged(QString))); |
| |
| QObject::connect(strikeout, SIGNAL(clicked()), q, SLOT(_q_updateSample())); |
| QObject::connect(underline, SIGNAL(clicked()), q, SLOT(_q_updateSample())); |
| |
| for (int i = 0; i < QFontDatabase::WritingSystemsCount; ++i) { |
| QFontDatabase::WritingSystem ws = QFontDatabase::WritingSystem(i); |
| QString writingSystemName = QFontDatabase::writingSystemName(ws); |
| if (writingSystemName.isEmpty()) |
| break; |
| writingSystemCombo->addItem(writingSystemName); |
| } |
| |
| updateFamilies(); |
| if (familyList->count() != 0) |
| familyList->setCurrentItem(0); |
| |
| // grid layout |
| QGridLayout *mainGrid = new QGridLayout(q); |
| |
| int spacing = mainGrid->spacing(); |
| if (spacing >= 0) { // uniform spacing |
| mainGrid->setSpacing(0); |
| |
| mainGrid->setColumnMinimumWidth(1, spacing); |
| mainGrid->setColumnMinimumWidth(3, spacing); |
| |
| int margin = 0; |
| mainGrid->getContentsMargins(0, 0, 0, &margin); |
| |
| mainGrid->setRowMinimumHeight(3, margin); |
| mainGrid->setRowMinimumHeight(6, 2); |
| mainGrid->setRowMinimumHeight(8, margin); |
| } |
| |
| mainGrid->addWidget(familyAccel, 0, 0); |
| mainGrid->addWidget(familyEdit, 1, 0); |
| mainGrid->addWidget(familyList, 2, 0); |
| |
| mainGrid->addWidget(styleAccel, 0, 2); |
| mainGrid->addWidget(styleEdit, 1, 2); |
| mainGrid->addWidget(styleList, 2, 2); |
| |
| mainGrid->addWidget(sizeAccel, 0, 4); |
| mainGrid->addWidget(sizeEdit, 1, 4); |
| mainGrid->addWidget(sizeList, 2, 4); |
| |
| mainGrid->setColumnStretch(0, 38); |
| mainGrid->setColumnStretch(2, 24); |
| mainGrid->setColumnStretch(4, 10); |
| |
| mainGrid->addWidget(effects, 4, 0); |
| |
| mainGrid->addWidget(sample, 4, 2, 4, 3); |
| |
| mainGrid->addWidget(writingSystemAccel, 5, 0); |
| mainGrid->addWidget(writingSystemCombo, 7, 0); |
| |
| buttonBox = new QDialogButtonBox(q); |
| mainGrid->addWidget(buttonBox, 9, 0, 1, 5); |
| |
| QPushButton *button |
| = static_cast<QPushButton *>(buttonBox->addButton(QDialogButtonBox::Ok)); |
| QObject::connect(buttonBox, SIGNAL(accepted()), q, SLOT(accept())); |
| button->setDefault(true); |
| |
| buttonBox->addButton(QDialogButtonBox::Cancel); |
| QObject::connect(buttonBox, SIGNAL(rejected()), q, SLOT(reject())); |
| |
| #if defined(Q_WS_WINCE) |
| q->resize(180, 120); |
| #elif defined(Q_WS_S60) |
| q->resize(QApplication::desktop()->availableGeometry(QCursor::pos()).size()); |
| #else |
| q->resize(500, 360); |
| #endif // Q_WS_WINCE |
| |
| sizeEdit->installEventFilter(q); |
| familyList->installEventFilter(q); |
| styleList->installEventFilter(q); |
| sizeList->installEventFilter(q); |
| |
| familyList->setFocus(); |
| retranslateStrings(); |
| } |
| |
| /*! |
| \internal |
| Destroys the font dialog and frees up its storage. |
| */ |
| |
| QFontDialog::~QFontDialog() |
| { |
| #ifdef Q_WS_MAC |
| Q_D(QFontDialog); |
| if (d->delegate) { |
| d->closeCocoaFontPanel(); |
| return; |
| } |
| #endif |
| } |
| |
| /*! |
| Executes a modal font dialog and returns a font. |
| |
| If the user clicks \gui OK, the selected font is returned. If the user |
| clicks \gui Cancel, the \a initial font is returned. |
| |
| The dialog is constructed with the given \a parent and the options specified |
| in \a options. \a title is shown as the window title of the dialog and \a |
| initial is the initially selected font. If the \a ok parameter is not-null, |
| the value it refers to is set to true if the user clicks \gui OK, and set to |
| false if the user clicks \gui Cancel. |
| |
| Examples: |
| \snippet doc/src/snippets/code/src_gui_dialogs_qfontdialog.cpp 2 |
| |
| The dialog can also be used to set a widget's font directly: |
| \snippet doc/src/snippets/code/src_gui_dialogs_qfontdialog.cpp 3 |
| In this example, if the user clicks OK the font they chose will be |
| used, and if they click Cancel the original font is used. |
| |
| \warning Do not delete \a parent during the execution of the dialog. |
| If you want to do this, you should create the dialog |
| yourself using one of the QFontDialog constructors. |
| */ |
| QFont QFontDialog::getFont(bool *ok, const QFont &initial, QWidget *parent, const QString &title, |
| FontDialogOptions options) |
| { |
| return QFontDialogPrivate::getFont(ok, initial, parent, title, options); |
| } |
| |
| /*! |
| \overload |
| \since 4.5 |
| */ |
| QFont QFontDialog::getFont(bool *ok, const QFont &initial, QWidget *parent, const QString &title) |
| { |
| return QFontDialogPrivate::getFont(ok, initial, parent, title, 0); |
| } |
| |
| /*! |
| \overload |
| */ |
| QFont QFontDialog::getFont(bool *ok, const QFont &initial, QWidget *parent) |
| { |
| return QFontDialogPrivate::getFont(ok, initial, parent, QString(), 0); |
| } |
| |
| /*! |
| \overload |
| |
| Executes a modal font dialog and returns a font. |
| |
| If the user clicks \gui OK, the selected font is returned. If the user |
| clicks \gui Cancel, the Qt default font is returned. |
| |
| The dialog is constructed with the given \a parent. |
| If the \a ok parameter is not-null, the value it refers to is set |
| to true if the user clicks \gui OK, and false if the user clicks |
| \gui Cancel. |
| |
| Example: |
| \snippet doc/src/snippets/code/src_gui_dialogs_qfontdialog.cpp 4 |
| |
| \warning Do not delete \a parent during the execution of the dialog. |
| If you want to do this, you should create the dialog |
| yourself using one of the QFontDialog constructors. |
| */ |
| QFont QFontDialog::getFont(bool *ok, QWidget *parent) |
| { |
| QFont initial; |
| return QFontDialogPrivate::getFont(ok, initial, parent, QString(), 0); |
| } |
| |
| QFont QFontDialogPrivate::getFont(bool *ok, const QFont &initial, QWidget *parent, |
| const QString &title, QFontDialog::FontDialogOptions options) |
| { |
| QFontDialog dlg(parent); |
| dlg.setOptions(options); |
| dlg.setCurrentFont(initial); |
| if (!title.isEmpty()) |
| dlg.setWindowTitle(title); |
| |
| int ret = (dlg.exec() || (options & QFontDialog::NoButtons)); |
| if (ok) |
| *ok = !!ret; |
| if (ret) { |
| return dlg.selectedFont(); |
| } else { |
| return initial; |
| } |
| } |
| |
| /*! |
| \internal |
| An event filter to make the Up, Down, PageUp and PageDown keys work |
| correctly in the line edits. The source of the event is the object |
| \a o and the event is \a e. |
| */ |
| |
| bool QFontDialog::eventFilter(QObject *o , QEvent *e) |
| { |
| Q_D(QFontDialog); |
| if (e->type() == QEvent::KeyPress) { |
| QKeyEvent *k = (QKeyEvent *)e; |
| if (o == d->sizeEdit && |
| (k->key() == Qt::Key_Up || |
| k->key() == Qt::Key_Down || |
| k->key() == Qt::Key_PageUp || |
| k->key() == Qt::Key_PageDown)) { |
| |
| int ci = d->sizeList->currentItem(); |
| (void)QApplication::sendEvent(d->sizeList, k); |
| |
| if (ci != d->sizeList->currentItem() |
| && style()->styleHint(QStyle::SH_FontDialog_SelectAssociatedText, 0, this)) |
| d->sizeEdit->selectAll(); |
| return true; |
| } else if ((o == d->familyList || o == d->styleList) && |
| (k->key() == Qt::Key_Return || k->key() == Qt::Key_Enter)) { |
| k->accept(); |
| accept(); |
| return true; |
| } |
| } else if (e->type() == QEvent::FocusIn |
| && style()->styleHint(QStyle::SH_FontDialog_SelectAssociatedText, 0, this)) { |
| if (o == d->familyList) |
| d->familyEdit->selectAll(); |
| else if (o == d->styleList) |
| d->styleEdit->selectAll(); |
| else if (o == d->sizeList) |
| d->sizeEdit->selectAll(); |
| } else if (e->type() == QEvent::MouseButtonPress && o == d->sizeList) { |
| d->sizeEdit->setFocus(); |
| } |
| return QDialog::eventFilter(o, e); |
| } |
| |
| /* |
| Updates the contents of the "font family" list box. This |
| function can be reimplemented if you have special requirements. |
| */ |
| |
| void QFontDialogPrivate::updateFamilies() |
| { |
| Q_Q(QFontDialog); |
| |
| enum match_t { MATCH_NONE = 0, MATCH_LAST_RESORT = 1, MATCH_APP = 2, MATCH_FAMILY = 3 }; |
| |
| QStringList familyNames = fdb.families(writingSystem); |
| |
| familyList->model()->setStringList(familyNames); |
| |
| QString foundryName1, familyName1, foundryName2, familyName2; |
| int bestFamilyMatch = -1; |
| match_t bestFamilyType = MATCH_NONE; |
| |
| QFont f; |
| |
| // ##### do the right thing for a list of family names in the font. |
| QFontDatabase::parseFontName(family, foundryName1, familyName1); |
| |
| QStringList::const_iterator it = familyNames.constBegin(); |
| int i = 0; |
| for(; it != familyNames.constEnd(); ++it, ++i) { |
| QFontDatabase::parseFontName(*it, foundryName2, familyName2); |
| |
| //try to match... |
| if (familyName1 == familyName2) { |
| bestFamilyType = MATCH_FAMILY; |
| if (foundryName1 == foundryName2) { |
| bestFamilyMatch = i; |
| break; |
| } |
| if (bestFamilyMatch < MATCH_FAMILY) |
| bestFamilyMatch = i; |
| } |
| |
| //and try some fall backs |
| match_t type = MATCH_NONE; |
| if (bestFamilyType <= MATCH_NONE && familyName2 == f.lastResortFamily()) |
| type = MATCH_LAST_RESORT; |
| if (bestFamilyType <= MATCH_LAST_RESORT && familyName2 == f.family()) |
| type = MATCH_APP; |
| // ### add fallback for writingSystem |
| if (type != MATCH_NONE) { |
| bestFamilyType = type; |
| bestFamilyMatch = i; |
| } |
| } |
| |
| if (i != -1 && bestFamilyType != MATCH_NONE) |
| familyList->setCurrentItem(bestFamilyMatch); |
| else |
| familyList->setCurrentItem(0); |
| familyEdit->setText(familyList->currentText()); |
| if (q->style()->styleHint(QStyle::SH_FontDialog_SelectAssociatedText, 0, q) |
| && familyList->hasFocus()) |
| familyEdit->selectAll(); |
| |
| updateStyles(); |
| } |
| |
| /* |
| Updates the contents of the "font style" list box. This |
| function can be reimplemented if you have special requirements. |
| */ |
| void QFontDialogPrivate::updateStyles() |
| { |
| Q_Q(QFontDialog); |
| QStringList styles = fdb.styles(familyList->currentText()); |
| styleList->model()->setStringList(styles); |
| |
| if (styles.isEmpty()) { |
| styleEdit->clear(); |
| smoothScalable = false; |
| } else { |
| if (!style.isEmpty()) { |
| bool found = false; |
| bool first = true; |
| QString cstyle = style; |
| |
| redo: |
| for (int i = 0; i < (int)styleList->count(); i++) { |
| if (cstyle == styleList->text(i)) { |
| styleList->setCurrentItem(i); |
| found = true; |
| break; |
| } |
| } |
| if (!found && first) { |
| if (cstyle.contains(QLatin1String("Italic"))) { |
| cstyle.replace(QLatin1String("Italic"), QLatin1String("Oblique")); |
| first = false; |
| goto redo; |
| } else if (cstyle.contains(QLatin1String("Oblique"))) { |
| cstyle.replace(QLatin1String("Oblique"), QLatin1String("Italic")); |
| first = false; |
| goto redo; |
| } |
| } |
| if (!found) |
| styleList->setCurrentItem(0); |
| } else { |
| styleList->setCurrentItem(0); |
| } |
| |
| styleEdit->setText(styleList->currentText()); |
| if (q->style()->styleHint(QStyle::SH_FontDialog_SelectAssociatedText, 0, q) |
| && styleList->hasFocus()) |
| styleEdit->selectAll(); |
| |
| smoothScalable = fdb.isSmoothlyScalable(familyList->currentText(), styleList->currentText()); |
| } |
| |
| updateSizes(); |
| } |
| |
| /*! |
| \internal |
| Updates the contents of the "font size" list box. This |
| function can be reimplemented if you have special requirements. |
| */ |
| |
| void QFontDialogPrivate::updateSizes() |
| { |
| Q_Q(QFontDialog); |
| |
| if (!familyList->currentText().isEmpty()) { |
| QList<int> sizes = fdb.pointSizes(familyList->currentText(), styleList->currentText()); |
| |
| int i = 0; |
| int current = -1; |
| QStringList str_sizes; |
| for(QList<int>::const_iterator it = sizes.constBegin(); it != sizes.constEnd(); ++it) { |
| str_sizes.append(QString::number(*it)); |
| if (current == -1 && *it >= size) |
| current = i; |
| ++i; |
| } |
| sizeList->model()->setStringList(str_sizes); |
| if (current == -1) { |
| // we request a size bigger than the ones in the list, select the biggest one |
| current = sizeList->count() - 1; |
| } |
| sizeList->setCurrentItem(current); |
| |
| sizeEdit->blockSignals(true); |
| sizeEdit->setText((smoothScalable ? QString::number(size) : sizeList->currentText())); |
| if (q->style()->styleHint(QStyle::SH_FontDialog_SelectAssociatedText, 0, q) |
| && sizeList->hasFocus()) |
| sizeEdit->selectAll(); |
| sizeEdit->blockSignals(false); |
| } else { |
| sizeEdit->clear(); |
| } |
| |
| _q_updateSample(); |
| } |
| |
| void QFontDialogPrivate::_q_updateSample() |
| { |
| // compute new font |
| int pSize = sizeEdit->text().toInt(); |
| QFont newFont(fdb.font(familyList->currentText(), style, pSize)); |
| newFont.setStrikeOut(strikeout->isChecked()); |
| newFont.setUnderline(underline->isChecked()); |
| |
| if (familyList->currentText().isEmpty()) |
| sampleEdit->clear(); |
| |
| updateSampleFont(newFont); |
| } |
| |
| void QFontDialogPrivate::updateSampleFont(const QFont &newFont) |
| { |
| Q_Q(QFontDialog); |
| if (newFont != sampleEdit->font()) { |
| sampleEdit->setFont(newFont); |
| emit q->currentFontChanged(newFont); |
| } |
| } |
| |
| /*! |
| \internal |
| */ |
| void QFontDialogPrivate::_q_writingSystemHighlighted(int index) |
| { |
| writingSystem = QFontDatabase::WritingSystem(index); |
| sampleEdit->setText(fdb.writingSystemSample(writingSystem)); |
| updateFamilies(); |
| } |
| |
| /*! |
| \internal |
| */ |
| void QFontDialogPrivate::_q_familyHighlighted(int i) |
| { |
| Q_Q(QFontDialog); |
| family = familyList->text(i); |
| familyEdit->setText(family); |
| if (q->style()->styleHint(QStyle::SH_FontDialog_SelectAssociatedText, 0, q) |
| && familyList->hasFocus()) |
| familyEdit->selectAll(); |
| |
| updateStyles(); |
| } |
| |
| |
| /*! |
| \internal |
| */ |
| |
| void QFontDialogPrivate::_q_styleHighlighted(int index) |
| { |
| Q_Q(QFontDialog); |
| QString s = styleList->text(index); |
| styleEdit->setText(s); |
| if (q->style()->styleHint(QStyle::SH_FontDialog_SelectAssociatedText, 0, q) |
| && styleList->hasFocus()) |
| styleEdit->selectAll(); |
| |
| style = s; |
| |
| updateSizes(); |
| } |
| |
| |
| /*! |
| \internal |
| */ |
| |
| void QFontDialogPrivate::_q_sizeHighlighted(int index) |
| { |
| Q_Q(QFontDialog); |
| QString s = sizeList->text(index); |
| sizeEdit->setText(s); |
| if (q->style()->styleHint(QStyle::SH_FontDialog_SelectAssociatedText, 0, q) |
| && sizeEdit->hasFocus()) |
| sizeEdit->selectAll(); |
| |
| size = s.toInt(); |
| _q_updateSample(); |
| } |
| |
| /*! |
| \internal |
| This slot is called if the user changes the font size. |
| The size is passed in the \a s argument as a \e string. |
| */ |
| |
| void QFontDialogPrivate::_q_sizeChanged(const QString &s) |
| { |
| // no need to check if the conversion is valid, since we have an QIntValidator in the size edit |
| int size = s.toInt(); |
| if (this->size == size) |
| return; |
| |
| this->size = size; |
| if (sizeList->count() != 0) { |
| int i; |
| for (i = 0; i < sizeList->count() - 1; i++) { |
| if (sizeList->text(i).toInt() >= this->size) |
| break; |
| } |
| sizeList->blockSignals(true); |
| sizeList->setCurrentItem(i); |
| sizeList->blockSignals(false); |
| } |
| _q_updateSample(); |
| } |
| |
| void QFontDialogPrivate::retranslateStrings() |
| { |
| familyAccel->setText(QFontDialog::tr("&Font")); |
| styleAccel->setText(QFontDialog::tr("Font st&yle")); |
| sizeAccel->setText(QFontDialog::tr("&Size")); |
| #ifndef Q_WS_S60 |
| // Removed the title due to lack of screen estate in small S60 screen. |
| // The effects are descriptive without a title (strikeout, underline). |
| effects->setTitle(QFontDialog::tr("Effects")); |
| #endif |
| strikeout->setText(QFontDialog::tr("Stri&keout")); |
| underline->setText(QFontDialog::tr("&Underline")); |
| sample->setTitle(QFontDialog::tr("Sample")); |
| writingSystemAccel->setText(QFontDialog::tr("Wr&iting System")); |
| } |
| |
| /*! |
| \reimp |
| */ |
| void QFontDialog::changeEvent(QEvent *e) |
| { |
| Q_D(QFontDialog); |
| if (e->type() == QEvent::LanguageChange) { |
| d->retranslateStrings(); |
| } |
| QDialog::changeEvent(e); |
| } |
| |
| /*! |
| \since 4.5 |
| |
| \property QFontDialog::currentFont |
| \brief the current font of the dialog. |
| */ |
| |
| /*! |
| \since 4.5 |
| |
| Sets the font highlighted in the QFontDialog to the given \a font. |
| |
| \sa selectedFont() |
| */ |
| void QFontDialog::setCurrentFont(const QFont &font) |
| { |
| Q_D(QFontDialog); |
| d->family = font.family(); |
| d->style = d->fdb.styleString(font); |
| d->size = font.pointSize(); |
| if (d->size == -1) { |
| QFontInfo fi(font); |
| d->size = fi.pointSize(); |
| } |
| d->strikeout->setChecked(font.strikeOut()); |
| d->underline->setChecked(font.underline()); |
| d->updateFamilies(); |
| |
| #ifdef Q_WS_MAC |
| if (d->delegate) |
| QFontDialogPrivate::setFont(d->delegate, font); |
| #endif |
| } |
| |
| /*! |
| \since 4.5 |
| |
| Returns the current font. |
| |
| \sa selectedFont() |
| */ |
| QFont QFontDialog::currentFont() const |
| { |
| Q_D(const QFontDialog); |
| return d->sampleEdit->font(); |
| } |
| |
| /*! |
| Returns the font that the user selected by clicking the \gui{OK} |
| or equivalent button. |
| |
| \note This font is not always the same as the font held by the |
| \l currentFont property since the user can choose different fonts |
| before finally selecting the one to use. |
| */ |
| QFont QFontDialog::selectedFont() const |
| { |
| Q_D(const QFontDialog); |
| return d->selectedFont; |
| } |
| |
| /*! |
| \enum QFontDialog::FontDialogOption |
| \since 4.5 |
| |
| This enum specifies various options that affect the look and feel |
| of a font dialog. |
| |
| \value NoButtons Don't display \gui{OK} and \gui{Cancel} buttons. (Useful for "live dialogs".) |
| \value DontUseNativeDialog Use Qt's standard font dialog on the Mac instead of Apple's |
| native font panel. (Currently, the native dialog is never used, |
| but this is likely to change in future Qt releases.) |
| |
| \sa options, setOption(), testOption() |
| */ |
| |
| /*! |
| Sets the given \a option to be enabled if \a on is true; |
| otherwise, clears the given \a option. |
| |
| \sa options, testOption() |
| */ |
| void QFontDialog::setOption(FontDialogOption option, bool on) |
| { |
| Q_D(QFontDialog); |
| if (!(d->opts & option) != !on) |
| setOptions(d->opts ^ option); |
| } |
| |
| /*! |
| Returns true if the given \a option is enabled; otherwise, returns |
| false. |
| |
| \sa options, setOption() |
| */ |
| bool QFontDialog::testOption(FontDialogOption option) const |
| { |
| Q_D(const QFontDialog); |
| return (d->opts & option) != 0; |
| } |
| |
| /*! |
| \property QFontDialog::options |
| \brief the various options that affect the look and feel of the dialog |
| \since 4.5 |
| |
| By default, all options are disabled. |
| |
| Options should be set before showing the dialog. Setting them while the |
| dialog is visible is not guaranteed to have an immediate effect on the |
| dialog (depending on the option and on the platform). |
| |
| \sa setOption(), testOption() |
| */ |
| void QFontDialog::setOptions(FontDialogOptions options) |
| { |
| Q_D(QFontDialog); |
| |
| FontDialogOptions changed = (options ^ d->opts); |
| if (!changed) |
| return; |
| |
| d->opts = options; |
| d->buttonBox->setVisible(!(options & NoButtons)); |
| } |
| |
| QFontDialog::FontDialogOptions QFontDialog::options() const |
| { |
| Q_D(const QFontDialog); |
| return d->opts; |
| } |
| |
| #ifdef Q_WS_MAC |
| // can only have one Cocoa font panel active |
| bool QFontDialogPrivate::sharedFontPanelAvailable = true; |
| #endif |
| |
| /*! |
| \since 4.5 |
| \overload |
| |
| Opens the dialog and connects its fontSelected() signal to the slot specified |
| by \a receiver and \a member. |
| |
| The signal will be disconnected from the slot when the dialog is closed. |
| */ |
| void QFontDialog::open(QObject *receiver, const char *member) |
| { |
| Q_D(QFontDialog); |
| connect(this, SIGNAL(fontSelected(QFont)), receiver, member); |
| d->receiverToDisconnectOnClose = receiver; |
| d->memberToDisconnectOnClose = member; |
| QDialog::open(); |
| } |
| |
| /*! |
| \since 4.5 |
| |
| \fn void QFontDialog::currentFontChanged(const QFont &font) |
| |
| This signal is emitted when the current font is changed. The new font is |
| specified in \a font. |
| |
| The signal is emitted while a user is selecting a font. Ultimately, the |
| chosen font may differ from the font currently selected. |
| |
| \sa currentFont, fontSelected(), selectedFont() |
| */ |
| |
| /*! |
| \since 4.5 |
| |
| \fn void QFontDialog::fontSelected(const QFont &font) |
| |
| This signal is emitted when a font has been selected. The selected font is |
| specified in \a font. |
| |
| The signal is only emitted when a user has chosen the final font to be |
| used. It is not emitted while the user is changing the current font in the |
| font dialog. |
| |
| \sa selectedFont(), currentFontChanged(), currentFont |
| */ |
| |
| /*! |
| \reimp |
| */ |
| void QFontDialog::setVisible(bool visible) |
| { |
| if (testAttribute(Qt::WA_WState_ExplicitShowHide) && testAttribute(Qt::WA_WState_Hidden) != visible) |
| return; |
| #ifdef Q_WS_MAC |
| Q_D(QFontDialog); |
| if (d->canBeNativeDialog()){ |
| if (d->setVisible_sys(visible)){ |
| d->nativeDialogInUse = true; |
| // Set WA_DontShowOnScreen so that QDialog::setVisible(visible) below |
| // updates the state correctly, but skips showing the non-native version: |
| setAttribute(Qt::WA_DontShowOnScreen, true); |
| } else { |
| d->nativeDialogInUse = false; |
| setAttribute(Qt::WA_DontShowOnScreen, false); |
| } |
| } |
| #endif // Q_WS_MAC |
| QDialog::setVisible(visible); |
| } |
| |
| /*! |
| Closes the dialog and sets its result code to \a result. If this dialog |
| is shown with exec(), done() causes the local event loop to finish, |
| and exec() to return \a result. |
| |
| \sa QDialog::done() |
| */ |
| void QFontDialog::done(int result) |
| { |
| Q_D(QFontDialog); |
| QDialog::done(result); |
| if (result == Accepted) { |
| // We check if this is the same font we had before, if so we emit currentFontChanged |
| QFont selectedFont = currentFont(); |
| if(selectedFont != d->selectedFont) |
| emit(currentFontChanged(selectedFont)); |
| d->selectedFont = selectedFont; |
| emit fontSelected(d->selectedFont); |
| } else |
| d->selectedFont = QFont(); |
| if (d->receiverToDisconnectOnClose) { |
| disconnect(this, SIGNAL(fontSelected(QFont)), |
| d->receiverToDisconnectOnClose, d->memberToDisconnectOnClose); |
| d->receiverToDisconnectOnClose = 0; |
| } |
| d->memberToDisconnectOnClose.clear(); |
| } |
| |
| #ifdef Q_WS_MAC |
| bool QFontDialogPrivate::canBeNativeDialog() |
| { |
| Q_Q(QFontDialog); |
| if (nativeDialogInUse) |
| return true; |
| if (q->testAttribute(Qt::WA_DontShowOnScreen)) |
| return false; |
| if (opts & QFontDialog::DontUseNativeDialog) |
| return false; |
| |
| QLatin1String staticName(QFontDialog::staticMetaObject.className()); |
| QLatin1String dynamicName(q->metaObject()->className()); |
| return (staticName == dynamicName); |
| } |
| #endif // Q_WS_MAC |
| |
| /*! |
| \fn QFont QFontDialog::getFont(bool *ok, const QFont &initial, QWidget* parent, const char* name) |
| \since 4.5 |
| |
| Call getFont(\a ok, \a initial, \a parent) instead. |
| |
| \warning Do not delete \a parent during the execution of the dialog. |
| If you want to do this, you should create the dialog |
| yourself using one of the QFontDialog constructors. |
| |
| The \a name parameter is ignored. |
| */ |
| |
| /*! |
| \fn QFont QFontDialog::getFont(bool *ok, QWidget* parent, const char* name) |
| |
| Call getFont(\a ok, \a parent) instead. |
| |
| \warning Do not delete \a parent during the execution of the dialog. |
| If you want to do this, you should create the dialog |
| yourself using one of the QFontDialog constructors. |
| |
| The \a name parameter is ignored. |
| */ |
| |
| QT_END_NAMESPACE |
| |
| #include "qfontdialog.moc" |
| #include "moc_qfontdialog.cpp" |
| |
| #endif // QT_NO_FONTDIALOG |