src/gui/dialogs/qfontdialog.cpp

   1 /****************************************************************************
   2 **
   3 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
   4 ** All rights reserved.
   5 ** Contact: Nokia Corporation (qt-info@nokia.com)
   6 **
   7 ** This file is part of the QtGui module of the Qt Toolkit.
   8 **
   9 ** $QT_BEGIN_LICENSE:LGPL$
  10 ** No Commercial Usage
  11 ** This file contains pre-release code and may not be distributed.
  12 ** You may use this file in accordance with the terms and conditions
  13 ** contained in the Technology Preview License Agreement accompanying
  14 ** this package.
  15 **
  16 ** GNU Lesser General Public License Usage
  17 ** Alternatively, this file may be used under the terms of the GNU Lesser
  18 ** General Public License version 2.1 as published by the Free Software
  19 ** Foundation and appearing in the file LICENSE.LGPL included in the
  20 ** packaging of this file.  Please review the following information to
  21 ** ensure the GNU Lesser General Public License version 2.1 requirements
  22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
  23 **
  24 ** In addition, as a special exception, Nokia gives you certain additional
  25 ** rights.  These rights are described in the Nokia Qt LGPL Exception
  26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
  27 **
  28 ** If you have questions regarding the use of this file, please contact
  29 ** Nokia at qt-info@nokia.com.
  30 **
  31 **
  32 **
  33 **
  34 **
  35 **
  36 **
  37 **
  38 ** $QT_END_LICENSE$
  39 **
  40 ****************************************************************************/
  41
  42 #include "qwindowdefs.h"
  43
  44 #ifndef QT_NO_FONTDIALOG
  45
  46 #include "qfontdialog.h"
  47 #include "qfontdialog_p.h"
  48
  49 #include <qapplication.h>
  50 #include <qcheckbox.h>
  51 #include <qcombobox.h>
  52 #include <qevent.h>
  53 #include <qfontdatabase.h>
  54 #include <qgroupbox.h>
  55 #include <qlabel.h>
  56 #include <qlayout.h>
  57 #include <qlineedit.h>
  58 #include <qpushbutton.h>
  59 #include <qstyle.h>
  60 #include <qdialogbuttonbox.h>
  61 #include <qheaderview.h>
  62 #include <qlistview.h>
  63 #include <qstringlistmodel.h>
  64 #include <qvalidator.h>
  65 #include <private/qdialog_p.h>
  66 #include <private/qfont_p.h>
  67
  68 #if defined(Q_WS_S60)
  69 #include <QtGui/qdesktopwidget.h>
  70 #endif
  71
  72 QT_BEGIN_NAMESPACE
  73
  74 class QFontListView : public QListView
  75 {
  76     Q_OBJECT
  77 public:
  78     QFontListView(QWidget *parent);
  79     inline QStringListModel *model() const {
  80         return static_cast<QStringListModel *>(QListView::model());
  81     }
  82     inline void setCurrentItem(int item) {
  83         QListView::setCurrentIndex(static_cast<QAbstractListModel*>(model())->index(item));
  84     }
  85     inline int currentItem() const {
  86         return QListView::currentIndex().row();
  87     }
  88     inline int count() const {
  89         return model()->rowCount();
  90     }
  91     inline QString currentText() const {
  92         int row = QListView::currentIndex().row();
  93         return row < 0 ? QString() : model()->stringList().at(row);
  94     }
  95     void currentChanged(const QModelIndex &current, const QModelIndex &previous) {
  96         QListView::currentChanged(current, previous);
  97         if (current.isValid())
  98             emit highlighted(current.row());
  99     }
 100     QString text(int i) const {
 101         return model()->stringList().at(i);
 102     }
 103 signals:
 104     void highlighted(int);
 105 };
 106
 107 QFontListView::QFontListView(QWidget *parent)
 108     : QListView(parent)
 109 {
 110     setModel(new QStringListModel(parent));
 111     setEditTriggers(NoEditTriggers);
 112 }
 113
 114 static const Qt::WindowFlags DefaultWindowFlags =
 115         Qt::Dialog | Qt::WindowSystemMenuHint;
 116
 117 /*!
 118   \class QFontDialog
 119   \ingroup standard-dialogs
 120
 121   \brief The QFontDialog class provides a dialog widget for selecting a font.
 122
 123     A font dialog is created through one of the static getFont()
 124     functions.
 125
 126   Examples:
 127
 128   \snippet doc/src/snippets/code/src_gui_dialogs_qfontdialog.cpp 0
 129
 130     The dialog can also be used to set a widget's font directly:
 131   \snippet doc/src/snippets/code/src_gui_dialogs_qfontdialog.cpp 1
 132   If the user clicks OK the font they chose will be used for myWidget,
 133   and if they click Cancel the original font is used.
 134
 135   \image plastique-fontdialog.png A font dialog in the Plastique widget style.
 136
 137   \sa QFont, QFontInfo, QFontMetrics, QColorDialog, QFileDialog, QPrintDialog,
 138       {Standard Dialogs Example}
 139 */
 140
 141 /*!
 142     \since 4.5
 143
 144     Constructs a standard font dialog.
 145
 146     Use setCurrentFont() to set the initial font attributes.
 147
 148     The \a parent parameter is passed to the QDialog constructor.
 149
 150     \sa getFont()
 151 */
 152 QFontDialog::QFontDialog(QWidget *parent)
 153     : QDialog(*new QFontDialogPrivate, parent, DefaultWindowFlags)
 154 {
 155     Q_D(QFontDialog);
 156     d->init();
 157 }
 158
 159 /*!
 160     \since 4.5
 161
 162     Constructs a standard font dialog with the given \a parent and specified
 163     \a initial color.
 164 */
 165 QFontDialog::QFontDialog(const QFont &initial, QWidget *parent)
 166     : QDialog(*new QFontDialogPrivate, parent, DefaultWindowFlags)
 167 {
 168     Q_D(QFontDialog);
 169     d->init();
 170     setCurrentFont(initial);
 171 }
 172
 173 void QFontDialogPrivate::init()
 174 {
 175     Q_Q(QFontDialog);
 176
 177     q->setSizeGripEnabled(true);
 178     q->setWindowTitle(QFontDialog::tr("Select Font"));
 179
 180     // grid
 181     familyEdit = new QLineEdit(q);
 182     familyEdit->setReadOnly(true);
 183     familyList = new QFontListView(q);
 184     familyEdit->setFocusProxy(familyList);
 185
 186     familyAccel = new QLabel(q);
 187 #ifndef QT_NO_SHORTCUT
 188     familyAccel->setBuddy(familyList);
 189 #endif
 190     familyAccel->setIndent(2);
 191
 192     styleEdit = new QLineEdit(q);
 193     styleEdit->setReadOnly(true);
 194     styleList = new QFontListView(q);
 195     styleEdit->setFocusProxy(styleList);
 196
 197     styleAccel = new QLabel(q);
 198 #ifndef QT_NO_SHORTCUT
 199     styleAccel->setBuddy(styleList);
 200 #endif
 201     styleAccel->setIndent(2);
 202
 203     sizeEdit = new QLineEdit(q);
 204     sizeEdit->setFocusPolicy(Qt::ClickFocus);
 205     QIntValidator *validator = new QIntValidator(1, 512, q);
 206     sizeEdit->setValidator(validator);
 207     sizeList = new QFontListView(q);
 208
 209     sizeAccel = new QLabel(q);
 210 #ifndef QT_NO_SHORTCUT
 211     sizeAccel->setBuddy(sizeEdit);
 212 #endif
 213     sizeAccel->setIndent(2);
 214
 215     // effects box
 216     effects = new QGroupBox(q);
 217     QVBoxLayout *vbox = new QVBoxLayout(effects);
 218     strikeout = new QCheckBox(effects);
 219     vbox->addWidget(strikeout);
 220     underline = new QCheckBox(effects);
 221     vbox->addWidget(underline);
 222
 223     sample = new QGroupBox(q);
 224     QHBoxLayout *hbox = new QHBoxLayout(sample);
 225     sampleEdit = new QLineEdit(sample);
 226     sampleEdit->setSizePolicy(QSizePolicy(QSizePolicy::Ignored, QSizePolicy::Ignored));
 227     sampleEdit->setAlignment(Qt::AlignCenter);
 228     // Note that the sample text is *not* translated with tr(), as the
 229     // characters used depend on the charset encoding.
 230     sampleEdit->setText(QLatin1String("AaBbYyZz"));
 231     hbox->addWidget(sampleEdit);
 232
 233     writingSystemCombo = new QComboBox(q);
 234
 235     writingSystemAccel = new QLabel(q);
 236 #ifndef QT_NO_SHORTCUT
 237     writingSystemAccel->setBuddy(writingSystemCombo);
 238 #endif
 239     writingSystemAccel->setIndent(2);
 240
 241     size = 0;
 242     smoothScalable = false;
 243
 244     QObject::connect(writingSystemCombo, SIGNAL(activated(int)), q, SLOT(_q_writingSystemHighlighted(int)));
 245     QObject::connect(familyList, SIGNAL(highlighted(int)), q, SLOT(_q_familyHighlighted(int)));
 246     QObject::connect(styleList, SIGNAL(highlighted(int)), q, SLOT(_q_styleHighlighted(int)));
 247     QObject::connect(sizeList, SIGNAL(highlighted(int)), q, SLOT(_q_sizeHighlighted(int)));
 248     QObject::connect(sizeEdit, SIGNAL(textChanged(QString)), q, SLOT(_q_sizeChanged(QString)));
 249
 250     QObject::connect(strikeout, SIGNAL(clicked()), q, SLOT(_q_updateSample()));
 251     QObject::connect(underline, SIGNAL(clicked()), q, SLOT(_q_updateSample()));
 252
 253     for (int i = 0; i < QFontDatabase::WritingSystemsCount; ++i) {
 254         QFontDatabase::WritingSystem ws = QFontDatabase::WritingSystem(i);
 255         QString writingSystemName = QFontDatabase::writingSystemName(ws);
 256         if (writingSystemName.isEmpty())
 257             break;
 258         writingSystemCombo->addItem(writingSystemName);
 259     }
 260
 261     updateFamilies();
 262     if (familyList->count() != 0)
 263         familyList->setCurrentItem(0);
 264
 265     // grid layout
 266     QGridLayout *mainGrid = new QGridLayout(q);
 267
 268     int spacing = mainGrid->spacing();
 269     if (spacing >= 0) {     // uniform spacing
 270        mainGrid->setSpacing(0);
 271
 272        mainGrid->setColumnMinimumWidth(1, spacing);
 273        mainGrid->setColumnMinimumWidth(3, spacing);
 274
 275        int margin = 0;
 276        mainGrid->getContentsMargins(0, 0, 0, &margin);
 277
 278        mainGrid->setRowMinimumHeight(3, margin);
 279        mainGrid->setRowMinimumHeight(6, 2);
 280        mainGrid->setRowMinimumHeight(8, margin);
 281     }
 282
 283     mainGrid->addWidget(familyAccel, 0, 0);
 284     mainGrid->addWidget(familyEdit, 1, 0);
 285     mainGrid->addWidget(familyList, 2, 0);
 286
 287     mainGrid->addWidget(styleAccel, 0, 2);
 288     mainGrid->addWidget(styleEdit, 1, 2);
 289     mainGrid->addWidget(styleList, 2, 2);
 290
 291     mainGrid->addWidget(sizeAccel, 0, 4);
 292     mainGrid->addWidget(sizeEdit, 1, 4);
 293     mainGrid->addWidget(sizeList, 2, 4);
 294
 295     mainGrid->setColumnStretch(0, 38);
 296     mainGrid->setColumnStretch(2, 24);
 297     mainGrid->setColumnStretch(4, 10);
 298
 299     mainGrid->addWidget(effects, 4, 0);
 300
 301     mainGrid->addWidget(sample, 4, 2, 4, 3);
 302
 303     mainGrid->addWidget(writingSystemAccel, 5, 0);
 304     mainGrid->addWidget(writingSystemCombo, 7, 0);
 305
 306     buttonBox = new QDialogButtonBox(q);
 307     mainGrid->addWidget(buttonBox, 9, 0, 1, 5);
 308
 309     QPushButton *button
 310             = static_cast<QPushButton *>(buttonBox->addButton(QDialogButtonBox::Ok));
 311     QObject::connect(buttonBox, SIGNAL(accepted()), q, SLOT(accept()));
 312     button->setDefault(true);
 313
 314     buttonBox->addButton(QDialogButtonBox::Cancel);
 315     QObject::connect(buttonBox, SIGNAL(rejected()), q, SLOT(reject()));
 316
 317 #if defined(Q_WS_WINCE)
 318     q->resize(180, 120);
 319 #elif defined(Q_WS_S60)
 320     q->resize(QApplication::desktop()->availableGeometry(QCursor::pos()).size());
 321 #else
 322     q->resize(500, 360);
 323 #endif // Q_WS_WINCE
 324
 325     sizeEdit->installEventFilter(q);
 326     familyList->installEventFilter(q);
 327     styleList->installEventFilter(q);
 328     sizeList->installEventFilter(q);
 329
 330     familyList->setFocus();
 331     retranslateStrings();
 332
 333 #ifdef Q_WS_MAC
 334     delegate = 0;
 335 #endif
 336 }
 337
 338 /*!
 339   \internal
 340  Destroys the font dialog and frees up its storage.
 341 */
 342
 343 QFontDialog::~QFontDialog()
 344 {
 345 #ifdef Q_WS_MAC
 346     Q_D(QFontDialog);
 347     if (d->delegate) {
 348         QFontDialogPrivate::closeCocoaFontPanel(d->delegate);
 349         QFontDialogPrivate::sharedFontPanelAvailable = true;
 350         return;
 351     }
 352 #endif
 353 }
 354
 355 /*!
 356   Executes a modal font dialog and returns a font.
 357
 358   If the user clicks \gui OK, the selected font is returned. If the user
 359   clicks \gui Cancel, the \a initial font is returned.
 360
 361   The dialog is constructed with the given \a parent and the options specified
 362   in \a options. \a title is shown as the window title of the dialog and  \a
 363   initial is the initially selected font. If the \a ok parameter is not-null,
 364   the value it refers to is set to true if the user clicks \gui OK, and set to
 365   false if the user clicks \gui Cancel.
 366
 367   Examples:
 368   \snippet doc/src/snippets/code/src_gui_dialogs_qfontdialog.cpp 2
 369
 370     The dialog can also be used to set a widget's font directly:
 371   \snippet doc/src/snippets/code/src_gui_dialogs_qfontdialog.cpp 3
 372   In this example, if the user clicks OK the font they chose will be
 373   used, and if they click Cancel the original font is used.
 374
 375   \warning Do not delete \a parent during the execution of the dialog.
 376            If you want to do this, you should create the dialog
 377            yourself using one of the QFontDialog constructors.
 378 */
 379 QFont QFontDialog::getFont(bool *ok, const QFont &initial, QWidget *parent, const QString &title,
 380                            FontDialogOptions options)
 381 {
 382     return QFontDialogPrivate::getFont(ok, initial, parent, title, options);
 383 }
 384
 385 /*!
 386     \overload
 387     \since 4.5
 388 */
 389 QFont QFontDialog::getFont(bool *ok, const QFont &initial, QWidget *parent, const QString &title)
 390 {
 391     return QFontDialogPrivate::getFont(ok, initial, parent, title, 0);
 392 }
 393
 394 /*!
 395     \overload
 396 */
 397 QFont QFontDialog::getFont(bool *ok, const QFont &initial, QWidget *parent)
 398 {
 399     return QFontDialogPrivate::getFont(ok, initial, parent, QString(), 0);
 400 }
 401
 402 /*!
 403     \overload
 404
 405   Executes a modal font dialog and returns a font.
 406
 407   If the user clicks \gui OK, the selected font is returned. If the user
 408   clicks \gui Cancel, the Qt default font is returned.
 409
 410   The dialog is constructed with the given \a parent.
 411   If the \a ok parameter is not-null, the value it refers to is set
 412   to true if the user clicks \gui OK, and false if the user clicks
 413   \gui Cancel.
 414
 415   Example:
 416   \snippet doc/src/snippets/code/src_gui_dialogs_qfontdialog.cpp 4
 417
 418   \warning Do not delete \a parent during the execution of the dialog.
 419            If you want to do this, you should create the dialog
 420            yourself using one of the QFontDialog constructors.
 421 */
 422 QFont QFontDialog::getFont(bool *ok, QWidget *parent)
 423 {
 424     QFont initial;
 425     return QFontDialogPrivate::getFont(ok, initial, parent, QString(), 0);
 426 }
 427
 428 QFont QFontDialogPrivate::getFont(bool *ok, const QFont &initial, QWidget *parent,
 429                                   const QString &title, QFontDialog::FontDialogOptions options)
 430 {
 431 #ifdef Q_WS_MAC
 432     if (!(options & QFontDialog::DontUseNativeDialog)
 433             && QFontDialogPrivate::sharedFontPanelAvailable) {
 434         return QFontDialogPrivate::execCocoaFontPanel(ok, initial, parent,
 435                        title.isEmpty() ? QFontDialog::tr("Select Font") : title, options);
 436     }
 437 #endif
 438
 439     QFontDialog dlg(parent);
 440     dlg.setOptions(options);
 441     dlg.setCurrentFont(initial);
 442     if (!title.isEmpty())
 443         dlg.setWindowTitle(title);
 444
 445     int ret = (dlg.exec() || (options & QFontDialog::NoButtons));
 446     if (ok)
 447         *ok = !!ret;
 448     if (ret) {
 449         return dlg.selectedFont();
 450     } else {
 451         return initial;
 452     }
 453 }
 454
 455 /*!
 456     \internal
 457     An event filter to make the Up, Down, PageUp and PageDown keys work
 458     correctly in the line edits. The source of the event is the object
 459     \a o and the event is \a e.
 460 */
 461
 462 bool QFontDialog::eventFilter(QObject *o , QEvent *e)
 463 {
 464     Q_D(QFontDialog);
 465     if (e->type() == QEvent::KeyPress) {
 466         QKeyEvent *k = (QKeyEvent *)e;
 467         if (o == d->sizeEdit &&
 468         (k->key() == Qt::Key_Up ||
 469              k->key() == Qt::Key_Down ||
 470          k->key() == Qt::Key_PageUp ||
 471          k->key() == Qt::Key_PageDown)) {
 472
 473             int ci = d->sizeList->currentItem();
 474             (void)QApplication::sendEvent(d->sizeList, k);
 475
 476             if (ci != d->sizeList->currentItem()
 477                     && style()->styleHint(QStyle::SH_FontDialog_SelectAssociatedText, 0, this))
 478                 d->sizeEdit->selectAll();
 479             return true;
 480         } else if ((o == d->familyList || o == d->styleList) &&
 481                     (k->key() == Qt::Key_Return || k->key() == Qt::Key_Enter)) {
 482             k->accept();
 483         accept();
 484             return true;
 485         }
 486     } else if (e->type() == QEvent::FocusIn
 487                && style()->styleHint(QStyle::SH_FontDialog_SelectAssociatedText, 0, this)) {
 488         if (o == d->familyList)
 489             d->familyEdit->selectAll();
 490         else if (o == d->styleList)
 491             d->styleEdit->selectAll();
 492         else if (o == d->sizeList)
 493             d->sizeEdit->selectAll();
 494     } else if (e->type() == QEvent::MouseButtonPress && o == d->sizeList) {
 495             d->sizeEdit->setFocus();
 496     }
 497     return QDialog::eventFilter(o, e);
 498 }
 499
 500 /*
 501     Updates the contents of the "font family" list box. This
 502     function can be reimplemented if you have special requirements.
 503 */
 504
 505 void QFontDialogPrivate::updateFamilies()
 506 {
 507     Q_Q(QFontDialog);
 508
 509     enum match_t { MATCH_NONE = 0, MATCH_LAST_RESORT = 1, MATCH_APP = 2, MATCH_FAMILY = 3 };
 510
 511     QStringList familyNames = fdb.families(writingSystem);
 512
 513     familyList->model()->setStringList(familyNames);
 514
 515     QString foundryName1, familyName1, foundryName2, familyName2;
 516     int bestFamilyMatch = -1;
 517     match_t bestFamilyType = MATCH_NONE;
 518
 519     QFont f;
 520
 521     // ##### do the right thing for a list of family names in the font.
 522     QFontDatabase::parseFontName(family, foundryName1, familyName1);
 523
 524     QStringList::const_iterator it = familyNames.constBegin();
 525     int i = 0;
 526     for(; it != familyNames.constEnd(); ++it, ++i) {
 527         QFontDatabase::parseFontName(*it, foundryName2, familyName2);
 528
 529         //try to match...
 530         if (familyName1 == familyName2) {
 531             bestFamilyType = MATCH_FAMILY;
 532             if (foundryName1 == foundryName2) {
 533                 bestFamilyMatch = i;
 534                 break;
 535             }
 536             if (bestFamilyMatch < MATCH_FAMILY)
 537                 bestFamilyMatch = i;
 538         }
 539
 540         //and try some fall backs
 541         match_t type = MATCH_NONE;
 542         if (bestFamilyType <= MATCH_NONE && familyName2 == f.lastResortFamily())
 543             type = MATCH_LAST_RESORT;
 544         if (bestFamilyType <= MATCH_LAST_RESORT && familyName2 == f.family())
 545             type = MATCH_APP;
 546         // ### add fallback for writingSystem
 547         if (type != MATCH_NONE) {
 548             bestFamilyType = type;
 549             bestFamilyMatch = i;
 550         }
 551     }
 552
 553     if (i != -1 && bestFamilyType != MATCH_NONE)
 554         familyList->setCurrentItem(bestFamilyMatch);
 555     else
 556         familyList->setCurrentItem(0);
 557     familyEdit->setText(familyList->currentText());
 558     if (q->style()->styleHint(QStyle::SH_FontDialog_SelectAssociatedText, 0, q)
 559             && familyList->hasFocus())
 560         familyEdit->selectAll();
 561
 562     updateStyles();
 563 }
 564
 565 /*
 566     Updates the contents of the "font style" list box. This
 567     function can be reimplemented if you have special requirements.
 568 */
 569 void QFontDialogPrivate::updateStyles()
 570 {
 571     Q_Q(QFontDialog);
 572     QStringList styles = fdb.styles(familyList->currentText());
 573     styleList->model()->setStringList(styles);
 574
 575     if (styles.isEmpty()) {
 576         styleEdit->clear();
 577         smoothScalable = false;
 578     } else {
 579         if (!style.isEmpty()) {
 580             bool found = false;
 581             bool first = true;
 582             QString cstyle = style;
 583
 584         redo:
 585             for (int i = 0; i < (int)styleList->count(); i++) {
 586                 if (cstyle == styleList->text(i)) {
 587                      styleList->setCurrentItem(i);
 588                      found = true;
 589                      break;
 590                  }
 591             }
 592             if (!found && first) {
 593                 if (cstyle.contains(QLatin1String("Italic"))) {
 594                     cstyle.replace(QLatin1String("Italic"), QLatin1String("Oblique"));
 595                     first = false;
 596                     goto redo;
 597                 } else if (cstyle.contains(QLatin1String("Oblique"))) {
 598                     cstyle.replace(QLatin1String("Oblique"), QLatin1String("Italic"));
 599                     first = false;
 600                     goto redo;
 601                 }
 602             }
 603             if (!found)
 604                 styleList->setCurrentItem(0);
 605         } else {
 606             styleList->setCurrentItem(0);
 607         }
 608
 609         styleEdit->setText(styleList->currentText());
 610         if (q->style()->styleHint(QStyle::SH_FontDialog_SelectAssociatedText, 0, q)
 611                 && styleList->hasFocus())
 612             styleEdit->selectAll();
 613
 614         smoothScalable = fdb.isSmoothlyScalable(familyList->currentText(), styleList->currentText());
 615     }
 616
 617     updateSizes();
 618 }
 619
 620 /*!
 621     \internal
 622     Updates the contents of the "font size" list box. This
 623   function can be reimplemented if you have special requirements.
 624 */
 625
 626 void QFontDialogPrivate::updateSizes()
 627 {
 628     Q_Q(QFontDialog);
 629
 630     if (!familyList->currentText().isEmpty()) {
 631         QList<int> sizes = fdb.pointSizes(familyList->currentText(), styleList->currentText());
 632
 633         int i = 0;
 634         int current = -1;
 635         QStringList str_sizes;
 636         for(QList<int>::const_iterator it = sizes.constBegin(); it != sizes.constEnd(); ++it) {
 637             str_sizes.append(QString::number(*it));
 638             if (current == -1 && *it >= size)
 639                 current = i;
 640             ++i;
 641         }
 642         sizeList->model()->setStringList(str_sizes);
 643         if (current == -1) {
 644             // we request a size bigger than the ones in the list, select the biggest one
 645             current = sizeList->count() - 1;
 646         }
 647         sizeList->setCurrentItem(current);
 648
 649         sizeEdit->blockSignals(true);
 650         sizeEdit->setText((smoothScalable ? QString::number(size) : sizeList->currentText()));
 651         if (q->style()->styleHint(QStyle::SH_FontDialog_SelectAssociatedText, 0, q)
 652                 && sizeList->hasFocus())
 653             sizeEdit->selectAll();
 654         sizeEdit->blockSignals(false);
 655     } else {
 656         sizeEdit->clear();
 657     }
 658
 659     _q_updateSample();
 660 }
 661
 662 void QFontDialogPrivate::_q_updateSample()
 663 {
 664     // compute new font
 665     int pSize = sizeEdit->text().toInt();
 666     QFont newFont(fdb.font(familyList->currentText(), style, pSize));
 667     newFont.setStrikeOut(strikeout->isChecked());
 668     newFont.setUnderline(underline->isChecked());
 669
 670     if (familyList->currentText().isEmpty())
 671         sampleEdit->clear();
 672
 673     updateSampleFont(newFont);
 674 }
 675
 676 void QFontDialogPrivate::updateSampleFont(const QFont &newFont)
 677 {
 678     Q_Q(QFontDialog);
 679     if (newFont != sampleEdit->font()) {
 680         sampleEdit->setFont(newFont);
 681         emit q->currentFontChanged(newFont);
 682     }
 683 }
 684
 685 /*!
 686     \internal
 687 */
 688 void QFontDialogPrivate::_q_writingSystemHighlighted(int index)
 689 {
 690     writingSystem = QFontDatabase::WritingSystem(index);
 691     sampleEdit->setText(fdb.writingSystemSample(writingSystem));
 692     updateFamilies();
 693 }
 694
 695 /*!
 696     \internal
 697 */
 698 void QFontDialogPrivate::_q_familyHighlighted(int i)
 699 {
 700     Q_Q(QFontDialog);
 701     family = familyList->text(i);
 702     familyEdit->setText(family);
 703     if (q->style()->styleHint(QStyle::SH_FontDialog_SelectAssociatedText, 0, q)
 704             && familyList->hasFocus())
 705         familyEdit->selectAll();
 706
 707     updateStyles();
 708 }
 709
 710
 711 /*!
 712     \internal
 713 */
 714
 715 void QFontDialogPrivate::_q_styleHighlighted(int index)
 716 {
 717     Q_Q(QFontDialog);
 718     QString s = styleList->text(index);
 719     styleEdit->setText(s);
 720     if (q->style()->styleHint(QStyle::SH_FontDialog_SelectAssociatedText, 0, q)
 721             && styleList->hasFocus())
 722         styleEdit->selectAll();
 723
 724     style = s;
 725
 726     updateSizes();
 727 }
 728
 729
 730 /*!
 731     \internal
 732 */
 733
 734 void QFontDialogPrivate::_q_sizeHighlighted(int index)
 735 {
 736     Q_Q(QFontDialog);
 737     QString s = sizeList->text(index);
 738     sizeEdit->setText(s);
 739     if (q->style()->styleHint(QStyle::SH_FontDialog_SelectAssociatedText, 0, q)
 740             && sizeEdit->hasFocus())
 741         sizeEdit->selectAll();
 742
 743     size = s.toInt();
 744     _q_updateSample();
 745 }
 746
 747 /*!
 748     \internal
 749     This slot is called if the user changes the font size.
 750     The size is passed in the \a s argument as a \e string.
 751 */
 752
 753 void QFontDialogPrivate::_q_sizeChanged(const QString &s)
 754 {
 755     // no need to check if the conversion is valid, since we have an QIntValidator in the size edit
 756     int size = s.toInt();
 757     if (this->size == size)
 758         return;
 759
 760     this->size = size;
 761     if (sizeList->count() != 0) {
 762         int i;
 763         for (i = 0; i < sizeList->count() - 1; i++) {
 764             if (sizeList->text(i).toInt() >= this->size)
 765                 break;
 766         }
 767         sizeList->blockSignals(true);
 768         sizeList->setCurrentItem(i);
 769         sizeList->blockSignals(false);
 770     }
 771     _q_updateSample();
 772 }
 773
 774 void QFontDialogPrivate::retranslateStrings()
 775 {
 776     familyAccel->setText(QFontDialog::tr("&Font"));
 777     styleAccel->setText(QFontDialog::tr("Font st&yle"));
 778     sizeAccel->setText(QFontDialog::tr("&Size"));
 779 #ifndef Q_WS_S60
 780     // Removed the title due to lack of screen estate in small S60 screen.
 781     // The effects are descriptive without a title (strikeout, underline).
 782     effects->setTitle(QFontDialog::tr("Effects"));
 783 #endif
 784     strikeout->setText(QFontDialog::tr("Stri&keout"));
 785     underline->setText(QFontDialog::tr("&Underline"));
 786     sample->setTitle(QFontDialog::tr("Sample"));
 787     writingSystemAccel->setText(QFontDialog::tr("Wr&iting System"));
 788 }
 789
 790 /*!
 791     \reimp
 792 */
 793 void QFontDialog::changeEvent(QEvent *e)
 794 {
 795     Q_D(QFontDialog);
 796     if (e->type() == QEvent::LanguageChange) {
 797         d->retranslateStrings();
 798     }
 799     QDialog::changeEvent(e);
 800 }
 801
 802 /*!
 803     \since 4.5
 804
 805     \property QFontDialog::currentFont
 806     \brief the current font of the dialog.
 807 */
 808
 809 /*!
 810     \since 4.5
 811
 812     Sets the font highlighted in the QFontDialog to the given \a font.
 813
 814     \sa selectedFont()
 815 */
 816 void QFontDialog::setCurrentFont(const QFont &font)
 817 {
 818     Q_D(QFontDialog);
 819     d->family = font.family();
 820     d->style = d->fdb.styleString(font);
 821     d->size = font.pointSize();
 822     if (d->size == -1) {
 823         QFontInfo fi(font);
 824         d->size = fi.pointSize();
 825     }
 826     d->strikeout->setChecked(font.strikeOut());
 827     d->underline->setChecked(font.underline());
 828     d->updateFamilies();
 829
 830 #ifdef Q_WS_MAC
 831     if (d->delegate)
 832         QFontDialogPrivate::setFont(d->delegate, font);
 833 #endif
 834 }
 835
 836 /*!
 837     \since 4.5
 838
 839     Returns the current font.
 840
 841     \sa selectedFont()
 842 */
 843 QFont QFontDialog::currentFont() const
 844 {
 845     Q_D(const QFontDialog);
 846     return d->sampleEdit->font();
 847 }
 848
 849 /*!
 850     Returns the font that the user selected by clicking the \gui{OK}
 851     or equivalent button.
 852
 853     \note This font is not always the same as the font held by the
 854     \l currentFont property since the user can choose different fonts
 855     before finally selecting the one to use.
 856 */
 857 QFont QFontDialog::selectedFont() const
 858 {
 859     Q_D(const QFontDialog);
 860     return d->selectedFont;
 861 }
 862
 863 /*!
 864     \enum QFontDialog::FontDialogOption
 865     \since 4.5
 866
 867     This enum specifies various options that affect the look and feel
 868     of a font dialog.
 869
 870     \value NoButtons Don't display \gui{OK} and \gui{Cancel} buttons. (Useful for "live dialogs".)
 871     \value DontUseNativeDialog Use Qt's standard font dialog on the Mac instead of Apple's
 872                                native font panel. (Currently, the native dialog is never used,
 873                                but this is likely to change in future Qt releases.)
 874
 875     \sa options, setOption(), testOption()
 876 */
 877
 878 /*!
 879     Sets the given \a option to be enabled if \a on is true;
 880     otherwise, clears the given \a option.
 881
 882     \sa options, testOption()
 883 */
 884 void QFontDialog::setOption(FontDialogOption option, bool on)
 885 {
 886     Q_D(QFontDialog);
 887     if (!(d->opts & option) != !on)
 888         setOptions(d->opts ^ option);
 889 }
 890
 891 /*!
 892     Returns true if the given \a option is enabled; otherwise, returns
 893     false.
 894
 895     \sa options, setOption()
 896 */
 897 bool QFontDialog::testOption(FontDialogOption option) const
 898 {
 899     Q_D(const QFontDialog);
 900     return (d->opts & option) != 0;
 901 }
 902
 903 /*!
 904     \property QFontDialog::options
 905     \brief the various options that affect the look and feel of the dialog
 906     \since 4.5
 907
 908     By default, all options are disabled.
 909
 910     Options should be set before showing the dialog. Setting them while the
 911     dialog is visible is not guaranteed to have an immediate effect on the
 912     dialog (depending on the option and on the platform).
 913
 914     \sa setOption(), testOption()
 915 */
 916 void QFontDialog::setOptions(FontDialogOptions options)
 917 {
 918     Q_D(QFontDialog);
 919
 920     FontDialogOptions changed = (options ^ d->opts);
 921     if (!changed)
 922         return;
 923
 924     d->opts = options;
 925     d->buttonBox->setVisible(!(options & NoButtons));
 926 }
 927
 928 QFontDialog::FontDialogOptions QFontDialog::options() const
 929 {
 930     Q_D(const QFontDialog);
 931     return d->opts;
 932 }
 933
 934 #ifdef Q_WS_MAC
 935 // can only have one Cocoa font panel active
 936 bool QFontDialogPrivate::sharedFontPanelAvailable = true;
 937 #endif
 938
 939 /*!
 940     \since 4.5
 941     \overload
 942
 943     Opens the dialog and connects its fontSelected() signal to the slot specified
 944     by \a receiver and \a member.
 945
 946     The signal will be disconnected from the slot when the dialog is closed.
 947 */
 948 void QFontDialog::open(QObject *receiver, const char *member)
 949 {
 950     Q_D(QFontDialog);
 951     connect(this, SIGNAL(fontSelected(QFont)), receiver, member);
 952     d->receiverToDisconnectOnClose = receiver;
 953     d->memberToDisconnectOnClose = member;
 954     QDialog::open();
 955 }
 956
 957 /*!
 958     \since 4.5
 959
 960     \fn void QFontDialog::currentFontChanged(const QFont &font)
 961
 962     This signal is emitted when the current font is changed. The new font is
 963     specified in \a font.
 964
 965     The signal is emitted while a user is selecting a font. Ultimately, the
 966     chosen font may differ from the font currently selected.
 967
 968     \sa currentFont, fontSelected(), selectedFont()
 969 */
 970
 971 /*!
 972     \since 4.5
 973
 974     \fn void QFontDialog::fontSelected(const QFont &font)
 975
 976     This signal is emitted when a font has been selected. The selected font is
 977     specified in \a font.
 978
 979     The signal is only emitted when a user has chosen the final font to be
 980     used. It is not emitted while the user is changing the current font in the
 981     font dialog.
 982
 983     \sa selectedFont(), currentFontChanged(), currentFont
 984 */
 985
 986 /*!
 987     \reimp
 988 */
 989 void QFontDialog::setVisible(bool visible)
 990 {
 991     Q_D(QFontDialog);
 992     if (visible)
 993         d->selectedFont = QFont();
 994
 995 #if defined(Q_WS_MAC)
 996     bool isCurrentlyVisible = (isVisible() || d->delegate);
 997
 998     if (!visible == !isCurrentlyVisible)
 999         return;
1000
1001     if (visible) {
1002         if (!(d->opts & DontUseNativeDialog) && QFontDialogPrivate::sharedFontPanelAvailable) {
1003             d->delegate = QFontDialogPrivate::openCocoaFontPanel(
1004                               currentFont(), parentWidget(), windowTitle(), options(), d);
1005             QFontDialogPrivate::sharedFontPanelAvailable = false;
1006             return;
1007         }
1008
1009         setWindowFlags(windowModality() == Qt::WindowModal ? Qt::Sheet : DefaultWindowFlags);
1010     } else {
1011         if (d->delegate) {
1012             QFontDialogPrivate::closeCocoaFontPanel(d->delegate);
1013             d->delegate = 0;
1014             QFontDialogPrivate::sharedFontPanelAvailable = true;
1015             return;
1016         }
1017     }
1018 #endif
1019
1020     QDialog::setVisible(visible);
1021 }
1022
1023 /*!
1024   Closes the dialog and sets its result code to \a result. If this dialog
1025   is shown with exec(), done() causes the local event loop to finish,
1026   and exec() to return \a result.
1027
1028   \sa QDialog::done()
1029 */
1030 void QFontDialog::done(int result)
1031 {
1032     Q_D(QFontDialog);
1033     QDialog::done(result);
1034     if (result == Accepted) {
1035         d->selectedFont = currentFont();
1036         emit fontSelected(d->selectedFont);
1037     } else {
1038         d->selectedFont = QFont();
1039     }
1040     if (d->receiverToDisconnectOnClose) {
1041         disconnect(this, SIGNAL(fontSelected(QFont)),
1042                    d->receiverToDisconnectOnClose, d->memberToDisconnectOnClose);
1043         d->receiverToDisconnectOnClose = 0;
1044     }
1045     d->memberToDisconnectOnClose.clear();
1046 }
1047
1048 /*!
1049     \fn QFont QFontDialog::getFont(bool *ok, const QFont &initial, QWidget* parent, const char* name)
1050     \since 4.5
1051
1052     Call getFont(\a ok, \a initial, \a parent) instead.
1053
1054     \warning Do not delete \a parent during the execution of the dialog.
1055              If you want to do this, you should create the dialog
1056              yourself using one of the QFontDialog constructors.
1057
1058     The \a name parameter is ignored.
1059 */
1060
1061 /*!
1062     \fn QFont QFontDialog::getFont(bool *ok, QWidget* parent, const char* name)
1063
1064     Call getFont(\a ok, \a parent) instead.
1065
1066   \warning Do not delete \a parent during the execution of the dialog.
1067            If you want to do this, you should create the dialog
1068            yourself using one of the QFontDialog constructors.
1069
1070     The \a name parameter is ignored.
1071 */
1072
1073 QT_END_NAMESPACE
1074
1075 #include "qfontdialog.moc"
1076 #include "moc_qfontdialog.cpp"
1077
1078 #endif // QT_NO_FONTDIALOG