src/frontends/qt4/GuiToolbar.cpp

   1 /**
   2  * \file qt4/GuiToolbar.cpp
   3  * This file is part of LyX, the document processor.
   4  * Licence details can be found in the file COPYING.
   5  *
   6  * \author Lars Gullik Bjønnes
   7  * \author John Levon
   8  * \author Jean-Marc Lasgouttes
   9  * \author Angus Leeming
  10  * \author Stefan Schimanski
  11  * \author Abdelrazak Younes
  12  *
  13  * Full author contact details are available in file CREDITS.
  14  */
  15
  16 #include <config.h>
  17
  18 #include "GuiToolbar.h"
  19
  20 #include "Action.h"
  21 #include "GuiApplication.h"
  22 #include "GuiCommandBuffer.h"
  23 #include "GuiView.h"
  24 #include "IconPalette.h"
  25 #include "InsertTableWidget.h"
  26 #include "qt_helpers.h"
  27 #include "Toolbars.h"
  28
  29 #include "Buffer.h"
  30 #include "BufferParams.h"
  31 #include "BufferView.h"
  32 #include "Cursor.h"
  33 #include "FuncRequest.h"
  34 #include "FuncStatus.h"
  35 #include "Layout.h"
  36 #include "LyXFunc.h"
  37 #include "LyXRC.h"
  38 #include "Paragraph.h"
  39 #include "TextClass.h"
  40
  41 #include "support/debug.h"
  42 #include "support/filetools.h"
  43 #include "support/gettext.h"
  44 #include "support/lstrings.h"
  45
  46 #include <QAbstractItemDelegate>
  47 #include <QAbstractTextDocumentLayout>
  48 #include <QApplication>
  49 #include <QComboBox>
  50 #include <QFontMetrics>
  51 #include <QHeaderView>
  52 #include <QItemDelegate>
  53 #include <QKeyEvent>
  54 #include <QList>
  55 #include <QListView>
  56 #include <QPainter>
  57 #include <QPixmap>
  58 #include <QSettings>
  59 #include <QSortFilterProxyModel>
  60 #include <QStandardItem>
  61 #include <QStandardItemModel>
  62 #include <QString>
  63 #include <QTextDocument>
  64 #include <QTextFrame>
  65 #include <QToolBar>
  66 #include <QToolButton>
  67 #include <QVariant>
  68
  69 #include "support/lassert.h"
  70
  71 using namespace std;
  72 using namespace lyx::support;
  73
  74 namespace lyx {
  75 namespace frontend {
  76
  77 /////////////////////////////////////////////////////////////////////
  78 //
  79 // GuiLayoutBox
  80 //
  81 /////////////////////////////////////////////////////////////////////
  82
  83 class LayoutItemDelegate : public QItemDelegate {
  84 public:
  85         ///
  86         explicit LayoutItemDelegate(QObject * parent = 0)
  87                 : QItemDelegate(parent)
  88         {}
  89
  90         ///
  91         void paint(QPainter * painter, QStyleOptionViewItem const & option,
  92                 QModelIndex const & index) const
  93         {
  94                 QStyleOptionViewItem opt = option;
  95
  96                 // default background
  97                 painter->fillRect(opt.rect, opt.palette.color(QPalette::Base));
  98
  99                 // category header?
 100                 if (lyxrc.group_layouts) {
 101                         QSortFilterProxyModel const * model
 102                         = static_cast<QSortFilterProxyModel const *>(index.model());
 103
 104                         QString stdCat = category(*model->sourceModel(), 0);
 105                         QString cat = category(*index.model(), index.row());
 106
 107                         // not the standard layout and not the same as in the previous line?
 108                         if (stdCat != cat
 109                             && (index.row() == 0 || cat != category(*index.model(), index.row() - 1))) {
 110                                 painter->save();
 111
 112                                 // draw unselected background
 113                                 QStyle::State state = opt.state;
 114                                 opt.state = opt.state & ~QStyle::State_Selected;
 115                                 drawBackground(painter, opt, index);
 116                                 opt.state = state;
 117
 118                                 // draw category header
 119                                 drawCategoryHeader(painter, opt,
 120                                         category(*index.model(), index.row()));
 121
 122                                 // move rect down below header
 123                                 opt.rect.setTop(opt.rect.top() + headerHeight(opt));
 124
 125                                 painter->restore();
 126                         }
 127                 }
 128
 129                 QItemDelegate::paint(painter, opt, index);
 130         }
 131
 132         ///
 133         void drawDisplay(QPainter * painter, QStyleOptionViewItem const & opt,
 134                          const QRect & /*rect*/, const QString & text ) const
 135         {
 136                 QString utext = underlineFilter(text);
 137
 138                 // Draw the rich text.
 139                 painter->save();
 140                 QColor col = opt.palette.text().color();
 141                 if (opt.state & QStyle::State_Selected)
 142                         col = opt.palette.highlightedText().color();
 143                 QAbstractTextDocumentLayout::PaintContext context;
 144                 context.palette.setColor(QPalette::Text, col);
 145
 146                 QTextDocument doc;
 147                 doc.setDefaultFont(opt.font);
 148                 doc.setHtml(utext);
 149
 150                 QTextFrameFormat fmt = doc.rootFrame()->frameFormat();
 151                 fmt.setMargin(0);
 152                 doc.rootFrame()->setFrameFormat(fmt);
 153
 154                 painter->translate(opt.rect.x() + 5,
 155                         opt.rect.y() + (opt.rect.height() - opt.fontMetrics.height()) / 2);
 156                 doc.documentLayout()->draw(painter, context);
 157                 painter->restore();
 158         }
 159
 160         ///
 161         QSize sizeHint(QStyleOptionViewItem const & opt,
 162                 QModelIndex const & index) const
 163         {
 164                 GuiLayoutBox * combo = static_cast<GuiLayoutBox *>(parent());
 165                 QSortFilterProxyModel const * model
 166                 = static_cast<QSortFilterProxyModel const *>(index.model());
 167                 QSize size = QItemDelegate::sizeHint(opt, index);
 168
 169                 /// QComboBox uses the first row height to estimate the
 170                 /// complete popup height during QComboBox::showPopup().
 171                 /// To avoid scrolling we have to sneak in space for the headers.
 172                 /// So we tweak this value accordingly. It's not nice, but the
 173                 /// only possible way it seems.
 174                 if (lyxrc.group_layouts && index.row() == 0 && combo->inShowPopup_) {
 175                         int itemHeight = size.height();
 176
 177                         // we have to show \c cats many headers:
 178                         unsigned cats = combo->visibleCategories_;
 179
 180                         // and we have \c n items to distribute the needed space over
 181                         unsigned n = combo->model()->rowCount();
 182
 183                         // so the needed average height (rounded upwards) is:
 184                         size.setHeight((headerHeight(opt) * cats + itemHeight * n + n - 1) / n);
 185                         return size;
 186                 }
 187
 188                 // Add space for the category headers here?
 189                 // Not for the standard layout though.
 190                 QString stdCat = category(*model->sourceModel(), 0);
 191                 QString cat = category(*index.model(), index.row());
 192                 if (lyxrc.group_layouts && stdCat != cat
 193                     && (index.row() == 0 || cat != category(*index.model(), index.row() - 1))) {
 194                         size.setHeight(size.height() + headerHeight(opt));
 195                 }
 196
 197                 return size;
 198         }
 199
 200 private:
 201         ///
 202         QString category(QAbstractItemModel const & model, int row) const
 203         {
 204                 return model.data(model.index(row, 2), Qt::DisplayRole).toString();
 205         }
 206
 207         ///
 208         int headerHeight(QStyleOptionViewItem const & opt) const
 209         {
 210                 return opt.fontMetrics.height() * 8 / 10;
 211         }
 212         ///
 213         void drawCategoryHeader(QPainter * painter, QStyleOptionViewItem const & opt,
 214                 QString const & category) const
 215         {
 216                 // slightly blended color
 217                 QColor lcol = opt.palette.text().color();
 218                 lcol.setAlpha(127);
 219                 painter->setPen(lcol);
 220
 221                 // set 80% scaled, bold font
 222                 QFont font = opt.font;
 223                 font.setBold(true);
 224                 font.setWeight(QFont::Black);
 225                 font.setPointSize(opt.font.pointSize() * 8 / 10);
 226                 painter->setFont(font);
 227
 228                 // draw the centered text
 229                 QFontMetrics fm(font);
 230                 int w = fm.width(category);
 231                 int x = opt.rect.x() + (opt.rect.width() - w) / 2;
 232                 int y = opt.rect.y() + fm.ascent();
 233                 int left = x;
 234                 int right = x + w;
 235                 painter->drawText(x, y, category);
 236
 237                 // the vertical position of the line: middle of lower case chars
 238                 int ymid = y - 1 - fm.xHeight() / 2; // -1 for the baseline
 239
 240                 // draw the horizontal line
 241                 if (!category.isEmpty()) {
 242                         painter->drawLine(opt.rect.x(), ymid, left - 1, ymid);
 243                         painter->drawLine(right + 1, ymid, opt.rect.right(), ymid);
 244                 } else
 245                         painter->drawLine(opt.rect.x(), ymid, opt.rect.right(), ymid);
 246         }
 247
 248
 249         ///
 250         QString underlineFilter(QString const & s) const
 251         {
 252                 // get filter
 253                 GuiLayoutBox * p = static_cast<GuiLayoutBox *>(parent());
 254                 QString const & f = p->filter();
 255                 if (f.isEmpty())
 256                         return s;
 257
 258                 // step through data item and put "(x)" for every matching character
 259                 QString r;
 260                 int lastp = -1;
 261                 p->filter();
 262                 for (int i = 0; i < f.length(); ++i) {
 263                         int p = s.indexOf(f[i], lastp + 1, Qt::CaseInsensitive);
 264                         LASSERT(p != -1, /**/);
 265                         if (lastp == p - 1 && lastp != -1) {
 266                                 // remove ")" and append "x)"
 267                                 r = r.left(r.length() - 4) + s[p] + "</u>";
 268                         } else {
 269                                 // append "(x)"
 270                                 r += s.mid(lastp + 1, p - lastp - 1);
 271                                 r += QString("<u>") + s[p] + "</u>";
 272                         }
 273                         lastp = p;
 274                 }
 275                 r += s.mid(lastp + 1);
 276                 return r;
 277         }
 278 };
 279
 280
 281 class GuiLayoutFilterModel : public QSortFilterProxyModel {
 282 public:
 283         ///
 284         GuiLayoutFilterModel(QObject * parent = 0)
 285                 : QSortFilterProxyModel(parent)
 286         {}
 287
 288         ///
 289         void triggerLayoutChange()
 290         {
 291                 layoutAboutToBeChanged();
 292                 layoutChanged();
 293         }
 294 };
 295
 296
 297 GuiLayoutBox::GuiLayoutBox(GuiToolbar * bar, GuiView & owner)
 298         : owner_(owner), bar_(bar), lastSel_(-1),
 299           layoutItemDelegate_(new LayoutItemDelegate(this)),
 300           visibleCategories_(0), inShowPopup_(false)
 301 {
 302         setSizeAdjustPolicy(QComboBox::AdjustToContents);
 303         setFocusPolicy(Qt::ClickFocus);
 304         setMinimumWidth(sizeHint().width());
 305         setMaxVisibleItems(100);
 306
 307         // set the layout model with two columns
 308         // 1st: translated layout names
 309         // 2nd: raw layout names
 310         model_ = new QStandardItemModel(0, 2, this);
 311         filterModel_ = new GuiLayoutFilterModel(this);
 312         filterModel_->setSourceModel(model_);
 313         setModel(filterModel_);
 314
 315         // for the filtering we have to intercept characters
 316         view()->installEventFilter(this);
 317         view()->setItemDelegateForColumn(0, layoutItemDelegate_);
 318
 319         QObject::connect(this, SIGNAL(activated(int)),
 320                 this, SLOT(selected(int)));
 321         QObject::connect(bar_, SIGNAL(iconSizeChanged(QSize)),
 322                 this, SLOT(setIconSize(QSize)));
 323
 324         owner_.setLayoutDialog(this);
 325         updateContents(true);
 326 }
 327
 328
 329 void GuiLayoutBox::setFilter(QString const & s)
 330 {
 331         bool enabled = view()->updatesEnabled();
 332         view()->setUpdatesEnabled(false);
 333
 334         // remember old selection
 335         int sel = currentIndex();
 336         if (sel != -1)
 337                 lastSel_ = filterModel_->mapToSource(filterModel_->index(sel, 0)).row();
 338
 339         filter_ = s;
 340         filterModel_->setFilterRegExp(charFilterRegExp(filter_));
 341         countCategories();
 342
 343         // restore old selection
 344         if (lastSel_ != -1) {
 345                 QModelIndex i = filterModel_->mapFromSource(model_->index(lastSel_, 0));
 346                 if (i.isValid())
 347                         setCurrentIndex(i.row());
 348         }
 349
 350         // Workaround to resize to content size
 351         // FIXME: There must be a better way. The QComboBox::AdjustToContents)
 352         //        does not help.
 353         if (view()->isVisible()) {
 354                 // call QComboBox::showPopup. But set the inShowPopup_ flag to switch on
 355                 // the hack in the item delegate to make space for the headers.
 356                 // We do not call our implementation of showPopup because that
 357                 // would reset the filter again. This is only needed if the user clicks
 358                 // on the QComboBox.
 359                 LASSERT(!inShowPopup_, /**/);
 360                 inShowPopup_ = true;
 361                 QComboBox::showPopup();
 362                 inShowPopup_ = false;
 363
 364                 // The item delegate hack is off again. So trigger a relayout of the popup.
 365                 filterModel_->triggerLayoutChange();
 366
 367                 if (!s.isEmpty())
 368                         owner_.message(_("Filtering layouts with \"" + fromqstr(s) + "\". "
 369                                          "Press ESC to remove filter."));
 370                 else
 371                         owner_.message(_("Enter characters to filter the layout list."));
 372         }
 373
 374         view()->setUpdatesEnabled(enabled);
 375 }
 376
 377
 378 void GuiLayoutBox::countCategories()
 379 {
 380         int n = filterModel_->rowCount();
 381         visibleCategories_ = 0;
 382         if (n == 0 || !lyxrc.group_layouts)
 383                 return;
 384
 385         // skip the "Standard" category
 386         QString prevCat = model_->index(0, 2).data().toString();
 387
 388         // count categories
 389         for (int i = 0; i < n; ++i) {
 390                 QString cat = filterModel_->index(i, 2).data().toString();
 391                 if (cat != prevCat)
 392                         ++visibleCategories_;
 393                 prevCat = cat;
 394         }
 395 }
 396
 397
 398 QString GuiLayoutBox::charFilterRegExp(QString const & filter)
 399 {
 400         QString re;
 401         for (int i = 0; i < filter.length(); ++i) {
 402                 QChar c = filter[i];
 403                 if (c.isLower())
 404                         re += ".*[" + QRegExp::escape(c) + QRegExp::escape(c.toUpper()) + "]";
 405                 else
 406                         re += ".*" + QRegExp::escape(c);
 407         }
 408         return re;
 409 }
 410
 411
 412 void GuiLayoutBox::resetFilter()
 413 {
 414         setFilter(QString());
 415 }
 416
 417
 418 void GuiLayoutBox::showPopup()
 419 {
 420         owner_.message(_("Enter characters to filter the layout list."));
 421
 422         bool enabled = view()->updatesEnabled();
 423         view()->setUpdatesEnabled(false);
 424
 425         resetFilter();
 426
 427         // call QComboBox::showPopup. But set the inShowPopup_ flag to switch on
 428         // the hack in the item delegate to make space for the headers.
 429         LASSERT(!inShowPopup_, /**/);
 430         inShowPopup_ = true;
 431         QComboBox::showPopup();
 432         inShowPopup_ = false;
 433
 434         // The item delegate hack is off again. So trigger a relayout of the popup.
 435         filterModel_->triggerLayoutChange();
 436
 437         view()->setUpdatesEnabled(enabled);
 438 }
 439
 440
 441 bool GuiLayoutBox::eventFilter(QObject * o, QEvent * e)
 442 {
 443         if (e->type() != QEvent::KeyPress)
 444                 return QComboBox::eventFilter(o, e);
 445
 446         QKeyEvent * ke = static_cast<QKeyEvent*>(e);
 447         bool modified = (ke->modifiers() == Qt::ControlModifier)
 448                 || (ke->modifiers() == Qt::AltModifier)
 449                 || (ke->modifiers() == Qt::MetaModifier);
 450
 451         switch (ke->key()) {
 452         case Qt::Key_Escape:
 453                 if (!modified && !filter_.isEmpty()) {
 454                         resetFilter();
 455                         return true;
 456                 }
 457                 break;
 458         case Qt::Key_Backspace:
 459                 if (!modified) {
 460                         // cut off one character
 461                         setFilter(filter_.left(filter_.length() - 1));
 462                 }
 463                 break;
 464         default:
 465                 if (modified || ke->text().isEmpty())
 466                         break;
 467                 // find chars for the filter string
 468                 QString s;
 469                 for (int i = 0; i < ke->text().length(); ++i) {
 470                         QChar c = ke->text()[i];
 471                         if (c.isLetterOrNumber()
 472                             || c.isSymbol()
 473                             || c.isPunct()
 474                             || c.category() == QChar::Separator_Space) {
 475                                 s += c;
 476                         }
 477                 }
 478                 if (!s.isEmpty()) {
 479                         // append new chars to the filter string
 480                         setFilter(filter_ + s);
 481                         return true;
 482                 }
 483                 break;
 484         }
 485
 486         return QComboBox::eventFilter(o, e);
 487 }
 488
 489
 490 void GuiLayoutBox::setIconSize(QSize size)
 491 {
 492 #ifdef Q_WS_MACX
 493         bool small = size.height() < 20;
 494         setAttribute(Qt::WA_MacSmallSize, small);
 495         setAttribute(Qt::WA_MacNormalSize, !small);
 496 #else
 497         (void)size; // suppress warning
 498 #endif
 499 }
 500
 501
 502 void GuiLayoutBox::set(docstring const & layout)
 503 {
 504         resetFilter();
 505
 506         if (!text_class_)
 507                 return;
 508
 509         Layout const & lay = (*text_class_)[layout];
 510         QString const newLayout = toqstr(lay.name());
 511
 512         int const curItem = currentIndex();
 513         QModelIndex const mindex =
 514                 filterModel_->mapToSource(filterModel_->index(curItem, 1));
 515         QString const & currentLayout = model_->itemFromIndex(mindex)->text();
 516         if (newLayout == currentLayout) {
 517                 LYXERR(Debug::GUI, "Already had " << newLayout << " selected.");
 518                 return;
 519         }
 520
 521         QList<QStandardItem *> r = model_->findItems(newLayout, Qt::MatchExactly, 1);
 522         if (r.empty()) {
 523                 LYXERR0("Trying to select non existent layout type " << newLayout);
 524                 return;
 525         }
 526
 527         setCurrentIndex(filterModel_->mapFromSource(r.first()->index()).row());
 528 }
 529
 530
 531 void GuiLayoutBox::addItemSort(docstring const & item, docstring const & category,
 532         bool sorted, bool sortedByCat, bool unknown)
 533 {
 534         QString qitem = toqstr(item);
 535         // FIXME This is wrong for RTL, I'd suppose.
 536         QString titem = toqstr(translateIfPossible(item) +
 537                                (unknown ? _(" (unknown)") : from_ascii("")));
 538         QString qcat = toqstr(translateIfPossible(category));
 539
 540         QList<QStandardItem *> row;
 541         row.append(new QStandardItem(titem));
 542         row.append(new QStandardItem(qitem));
 543         row.append(new QStandardItem(qcat));
 544
 545         // the first entry is easy
 546         int const end = model_->rowCount();
 547         if (end == 0) {
 548                 model_->appendRow(row);
 549                 return;
 550         }
 551
 552         // find category
 553         int i = 0;
 554         if (sortedByCat) {
 555                 while (i < end && model_->item(i, 2)->text() != qcat)
 556                         ++i;
 557         }
 558
 559         // skip the Standard layout
 560         if (i == 0)
 561                 ++i;
 562
 563         // the simple unsorted case
 564         if (!sorted) {
 565                 if (sortedByCat) {
 566                         // jump to the end of the category group
 567                         while (i < end && model_->item(i, 2)->text() == qcat)
 568                                 ++i;
 569                         model_->insertRow(i, row);
 570                 } else
 571                         model_->appendRow(row);
 572                 return;
 573         }
 574
 575         // find row to insert the item, after the separator if it exists
 576         if (i < end) {
 577                 // find alphabetic position
 578                 while (i != end
 579                        && model_->item(i, 0)->text().localeAwareCompare(titem) < 0
 580                        && (!sortedByCat || model_->item(i, 2)->text() == qcat))
 581                         ++i;
 582         }
 583
 584         model_->insertRow(i, row);
 585 }
 586
 587
 588 void GuiLayoutBox::updateContents(bool reset)
 589 {
 590         resetFilter();
 591
 592         Buffer const * buffer = owner_.buffer();
 593         if (!buffer) {
 594                 model_->clear();
 595                 setEnabled(false);
 596                 text_class_ = 0;
 597                 inset_ = 0;
 598                 return;
 599         }
 600
 601         // we'll only update the layout list if the text class has changed
 602         // or we've moved from one inset to another
 603         DocumentClass const * text_class = &buffer->params().documentClass();
 604         Inset const * inset =
 605                 owner_.view()->cursor().innerParagraph().inInset();
 606         if (!reset && text_class_ == text_class && inset_ == inset) {
 607                 set(owner_.view()->cursor().innerParagraph().layout().name());
 608                 return;
 609         }
 610
 611         inset_ = inset;
 612         text_class_ = text_class;
 613
 614         model_->clear();
 615         DocumentClass::const_iterator lit = text_class_->begin();
 616         DocumentClass::const_iterator len = text_class_->end();
 617
 618         for (; lit != len; ++lit) {
 619                 docstring const & name = lit->name();
 620                 bool const useEmpty = inset_->forcePlainLayout() || inset_->usePlainLayout();
 621                 // if this inset requires the empty layout, we skip the default
 622                 // layout
 623                 if (name == text_class_->defaultLayoutName() && inset_ && useEmpty)
 624                         continue;
 625                 // if it doesn't require the empty layout, we skip it
 626                 if (name == text_class_->emptyLayoutName() && inset_ && !useEmpty)
 627                         continue;
 628                 addItemSort(name, lit->category(), lyxrc.sort_layouts,
 629                                 lyxrc.group_layouts, lit->isUnknown());
 630         }
 631
 632         set(owner_.view()->cursor().innerParagraph().layout().name());
 633         countCategories();
 634
 635         // needed to recalculate size hint
 636         hide();
 637         setMinimumWidth(sizeHint().width());
 638         setEnabled(!buffer->isReadonly() &&
 639                 lyx::getStatus(FuncRequest(LFUN_LAYOUT)).enabled());
 640         show();
 641 }
 642
 643
 644 void GuiLayoutBox::selected(int index)
 645 {
 646         // get selection
 647         QModelIndex mindex = filterModel_->mapToSource(filterModel_->index(index, 1));
 648         docstring layoutName = qstring_to_ucs4(model_->itemFromIndex(mindex)->text());
 649         owner_.setFocus();
 650
 651         if (!text_class_) {
 652                 updateContents(false);
 653                 resetFilter();
 654                 return;
 655         }
 656
 657         // find corresponding text class
 658         if (text_class_->hasLayout(layoutName)) {
 659                 FuncRequest const func(LFUN_LAYOUT, layoutName, FuncRequest::TOOLBAR);
 660                 theLyXFunc().setLyXView(&owner_);
 661                 lyx::dispatch(func);
 662                 updateContents(false);
 663                 resetFilter();
 664                 return;
 665         }
 666         LYXERR0("ERROR (layoutSelected): layout " << layoutName << " not found!");
 667 }
 668
 669
 670
 671 /////////////////////////////////////////////////////////////////////
 672 //
 673 // GuiToolbar
 674 //
 675 /////////////////////////////////////////////////////////////////////
 676
 677
 678 GuiToolbar::GuiToolbar(ToolbarInfo const & tbinfo, GuiView & owner)
 679         : QToolBar(qt_(tbinfo.gui_name), &owner), visibility_(0),
 680           allowauto_(false), owner_(owner), layout_(0), command_buffer_(0),
 681           tbinfo_(tbinfo), filled_(false)
 682 {
 683         setIconSize(owner.iconSize());
 684         connect(&owner, SIGNAL(iconSizeChanged(QSize)), this,
 685                 SLOT(setIconSize(QSize)));
 686
 687         // Toolbar dragging is allowed.
 688         setMovable(true);
 689         // This is used by QMainWindow::restoreState for proper main window state
 690         // restauration.
 691         setObjectName(toqstr(tbinfo.name));
 692         restoreSession();
 693 }
 694
 695
 696 void GuiToolbar::fill()
 697 {
 698         if (filled_)
 699                 return;
 700         ToolbarInfo::item_iterator it = tbinfo_.items.begin();
 701         ToolbarInfo::item_iterator end = tbinfo_.items.end();
 702         for (; it != end; ++it)
 703                 add(*it);
 704         filled_ = true;
 705 }
 706
 707
 708 void GuiToolbar::showEvent(QShowEvent * ev)
 709 {
 710         fill();
 711         ev->accept();
 712 }
 713
 714
 715 void GuiToolbar::setVisibility(int visibility)
 716 {
 717         visibility_ = visibility;
 718         allowauto_ = visibility_ >= Toolbars::MATH;
 719 }
 720
 721
 722 Action * GuiToolbar::addItem(ToolbarItem const & item)
 723 {
 724         Action * act = new Action(&owner_, getIcon(item.func_, false),
 725                 toqstr(item.label_), item.func_, toqstr(item.label_), this);
 726         actions_.append(act);
 727         return act;
 728 }
 729
 730 namespace {
 731
 732 class PaletteButton : public QToolButton
 733 {
 734 private:
 735         GuiToolbar * bar_;
 736         ToolbarItem const & tbitem_;
 737         bool initialized_;
 738 public:
 739         PaletteButton(GuiToolbar * bar, ToolbarItem const & item)
 740                 : QToolButton(bar), bar_(bar), tbitem_(item), initialized_(false)
 741         {
 742                 QString const label = qt_(to_ascii(tbitem_.label_));
 743                 setToolTip(label);
 744                 setStatusTip(label);
 745                 setText(label);
 746                 connect(bar_, SIGNAL(iconSizeChanged(QSize)),
 747                         this, SLOT(setIconSize(QSize)));
 748                 setCheckable(true);
 749                 ToolbarInfo const * tbinfo = guiApp->toolbars().info(tbitem_.name_);
 750                 if (tbinfo)
 751                         // use the icon of first action for the toolbar button
 752                         setIcon(getIcon(tbinfo->items.begin()->func_, true));
 753         }
 754
 755         void mousePressEvent(QMouseEvent * e)
 756         {
 757                 if (initialized_) {
 758                         QToolButton::mousePressEvent(e);
 759                         return;
 760                 }
 761
 762                 initialized_ = true;
 763
 764                 ToolbarInfo const * tbinfo = guiApp->toolbars().info(tbitem_.name_);
 765                 if (!tbinfo) {
 766                         LYXERR0("Unknown toolbar " << tbitem_.name_);
 767                         return;
 768                 }
 769                 IconPalette * panel = new IconPalette(this);
 770                 QString const label = qt_(to_ascii(tbitem_.label_));
 771                 panel->setWindowTitle(label);
 772                 connect(this, SIGNAL(clicked(bool)), panel, SLOT(setVisible(bool)));
 773                 connect(panel, SIGNAL(visible(bool)), this, SLOT(setChecked(bool)));
 774                 ToolbarInfo::item_iterator it = tbinfo->items.begin();
 775                 ToolbarInfo::item_iterator const end = tbinfo->items.end();
 776                 for (; it != end; ++it)
 777                         if (!getStatus(it->func_).unknown())
 778                                 panel->addButton(bar_->addItem(*it));
 779
 780                 QToolButton::mousePressEvent(e);
 781         }
 782 };
 783
 784 class MenuButton : public QToolButton
 785 {
 786 private:
 787         GuiToolbar * bar_;
 788         ToolbarItem const & tbitem_;
 789         bool initialized_;
 790 public:
 791         MenuButton(GuiToolbar * bar, ToolbarItem const & item)
 792                 : QToolButton(bar), bar_(bar), tbitem_(item), initialized_(false)
 793         {
 794                 setPopupMode(QToolButton::InstantPopup);
 795                 QString const label = qt_(to_ascii(tbitem_.label_));
 796                 setToolTip(label);
 797                 setStatusTip(label);
 798                 setText(label);
 799                 setIcon(QPixmap(":images/math/" + toqstr(tbitem_.name_) + ".png"));
 800                 connect(bar, SIGNAL(iconSizeChanged(QSize)),
 801                         this, SLOT(setIconSize(QSize)));
 802         }
 803
 804         void mousePressEvent(QMouseEvent * e)
 805         {
 806                 if (initialized_) {
 807                         QToolButton::mousePressEvent(e);
 808                         return;
 809                 }
 810
 811                 initialized_ = true;
 812
 813                 QString const label = qt_(to_ascii(tbitem_.label_));
 814                 ButtonMenu * m = new ButtonMenu(label, this);
 815                 m->setWindowTitle(label);
 816                 m->setTearOffEnabled(true);
 817                 connect(bar_, SIGNAL(updated()), m, SLOT(updateParent()));
 818                 ToolbarInfo const * tbinfo = guiApp->toolbars().info(tbitem_.name_);
 819                 if (!tbinfo) {
 820                         LYXERR0("Unknown toolbar " << tbitem_.name_);
 821                         return;
 822                 }
 823                 ToolbarInfo::item_iterator it = tbinfo->items.begin();
 824                 ToolbarInfo::item_iterator const end = tbinfo->items.end();
 825                 for (; it != end; ++it)
 826                         if (!getStatus(it->func_).unknown())
 827                                 m->add(bar_->addItem(*it));
 828                 setMenu(m);
 829
 830                 QToolButton::mousePressEvent(e);
 831         }
 832 };
 833
 834 }
 835
 836
 837 void GuiToolbar::add(ToolbarItem const & item)
 838 {
 839         switch (item.type_) {
 840         case ToolbarItem::SEPARATOR:
 841                 addSeparator();
 842                 break;
 843         case ToolbarItem::LAYOUTS:
 844                 layout_ = new GuiLayoutBox(this, owner_);
 845                 addWidget(layout_);
 846                 break;
 847         case ToolbarItem::MINIBUFFER:
 848                 command_buffer_ = new GuiCommandBuffer(&owner_);
 849                 addWidget(command_buffer_);
 850                 /// \todo find a Qt4 equivalent to setHorizontalStretchable(true);
 851                 //setHorizontalStretchable(true);
 852                 break;
 853         case ToolbarItem::TABLEINSERT: {
 854                 QToolButton * tb = new QToolButton;
 855                 tb->setCheckable(true);
 856                 tb->setIcon(getIcon(FuncRequest(LFUN_TABULAR_INSERT), true));
 857                 QString const label = qt_(to_ascii(item.label_));
 858                 tb->setToolTip(label);
 859                 tb->setStatusTip(label);
 860                 tb->setText(label);
 861                 InsertTableWidget * iv = new InsertTableWidget(owner_, tb);
 862                 connect(tb, SIGNAL(clicked(bool)), iv, SLOT(show(bool)));
 863                 connect(iv, SIGNAL(visible(bool)), tb, SLOT(setChecked(bool)));
 864                 connect(this, SIGNAL(updated()), iv, SLOT(updateParent()));
 865                 addWidget(tb);
 866                 break;
 867                 }
 868         case ToolbarItem::ICONPALETTE:
 869                 addWidget(new PaletteButton(this, item));
 870                 break;
 871
 872         case ToolbarItem::POPUPMENU: {
 873                 addWidget(new MenuButton(this, item));
 874                 break;
 875                 }
 876         case ToolbarItem::COMMAND: {
 877                 if (!getStatus(item.func_).unknown())
 878                         addAction(addItem(item));
 879                 break;
 880                 }
 881         default:
 882                 break;
 883         }
 884 }
 885
 886
 887 void GuiToolbar::update(bool in_math, bool in_table, bool in_review,
 888         bool in_mathmacrotemplate)
 889 {
 890         if (visibility_ & Toolbars::AUTO) {
 891                 bool show_it = in_math && (visibility_ & Toolbars::MATH)
 892                         || in_table && (visibility_ & Toolbars::TABLE)
 893                         || in_review && (visibility_ & Toolbars::REVIEW)
 894                         || in_mathmacrotemplate && (visibility_ & Toolbars::MATHMACROTEMPLATE);
 895                 setVisible(show_it);
 896         }
 897
 898         // update visible toolbars only
 899         if (!isVisible())
 900                 return;
 901
 902         // This is a speed bottleneck because this is called on every keypress
 903         // and update calls getStatus, which copies the cursor at least two times
 904         for (int i = 0; i < actions_.size(); ++i)
 905                 actions_[i]->update();
 906
 907         if (layout_)
 908                 layout_->setEnabled(lyx::getStatus(FuncRequest(LFUN_LAYOUT)).enabled());
 909
 910         // emit signal
 911         updated();
 912 }
 913
 914
 915 QString GuiToolbar::sessionKey() const
 916 {
 917         return "view-" + QString::number(owner_.id()) + "/" + objectName();
 918 }
 919
 920
 921 void GuiToolbar::saveSession() const
 922 {
 923         QSettings settings;
 924         settings.setValue(sessionKey() + "/visibility", visibility_);
 925 }
 926
 927
 928 void GuiToolbar::restoreSession()
 929 {
 930         QSettings settings;
 931         setVisibility(settings.value(sessionKey() + "/visibility").toInt());
 932 }
 933
 934
 935 void GuiToolbar::toggle()
 936 {
 937         docstring state;
 938         if (allowauto_) {
 939                 if (!(visibility_ & Toolbars::AUTO)) {
 940                         visibility_ |= Toolbars::AUTO;
 941                         hide();
 942                         state = _("auto");
 943                 } else {
 944                         visibility_ &= ~Toolbars::AUTO;
 945                         if (isVisible()) {
 946                                 hide();
 947                                 state = _("off");
 948                         } else {
 949                                 show();
 950                                 state = _("on");
 951                         }
 952                 }
 953         } else {
 954                 if (isVisible()) {
 955                         hide();
 956                         state = _("off");
 957                 } else {
 958                         show();
 959                         state = _("on");
 960                 }
 961         }
 962
 963         owner_.message(bformat(_("Toolbar \"%1$s\" state set to %2$s"),
 964                 qstring_to_ucs4(windowTitle()), state));
 965 }
 966
 967 } // namespace frontend
 968 } // namespace lyx
 969
 970 #include "GuiToolbar_moc.cpp"