#include <config.h>
-#include "GuiView.h"
-#include "GuiCommandBuffer.h"
#include "GuiToolbar.h"
-#include "LyXAction.h"
+
#include "Action.h"
-#include "qt_helpers.h"
+#include "GuiApplication.h"
+#include "GuiCommandBuffer.h"
+#include "GuiView.h"
+#include "IconPalette.h"
#include "InsertTableWidget.h"
+#include "qt_helpers.h"
+#include "Toolbars.h"
#include "Buffer.h"
#include "BufferParams.h"
#include "Cursor.h"
#include "FuncRequest.h"
#include "FuncStatus.h"
-#include "IconPalette.h"
#include "Layout.h"
#include "LyXFunc.h"
#include "LyXRC.h"
#include "Paragraph.h"
#include "TextClass.h"
-#include "ToolbarBackend.h"
#include "support/debug.h"
#include "support/filetools.h"
#include "support/gettext.h"
#include "support/lstrings.h"
-#include "support/lyxalgo.h" // sorted
#include <QAbstractItemDelegate>
#include <QAbstractTextDocumentLayout>
#include <QApplication>
-#include <QClearLook>
#include <QComboBox>
#include <QFontMetrics>
#include <QHeaderView>
+#include <QItemDelegate>
#include <QKeyEvent>
#include <QList>
#include <QListView>
#include <QPainter>
#include <QPixmap>
-#include <QPlastiqueStyle>
+#include <QSettings>
#include <QSortFilterProxyModel>
#include <QStandardItem>
#include <QStandardItemModel>
+#include <QString>
#include <QTextDocument>
#include <QTextFrame>
#include <QToolBar>
#include <QToolButton>
#include <QVariant>
-#include <boost/assert.hpp>
-
-#include <map>
-#include <vector>
+#include "support/lassert.h"
using namespace std;
using namespace lyx::support;
-static void initializeResources()
-{
- static bool initialized = false;
- if (!initialized) {
- Q_INIT_RESOURCE(Resources);
- initialized = true;
- }
-}
-
-
namespace lyx {
namespace frontend {
-namespace {
-
-struct PngMap {
- QString key;
- QString value;
-};
-
-
-bool operator<(PngMap const & lhs, PngMap const & rhs)
-{
- return lhs.key < rhs.key;
-}
-
-
-class CompareKey {
-public:
- CompareKey(QString const & name) : name_(name) {}
- bool operator()(PngMap const & other) const { return other.key == name_; }
-private:
- QString const name_;
-};
-
-
-PngMap sorted_png_map[] = {
- { "Bumpeq", "bumpeq2" },
- { "Cap", "cap2" },
- { "Cup", "cup2" },
- { "Delta", "delta2" },
- { "Downarrow", "downarrow2" },
- { "Gamma", "gamma2" },
- { "Lambda", "lambda2" },
- { "Leftarrow", "leftarrow2" },
- { "Leftrightarrow", "leftrightarrow2" },
- { "Longleftarrow", "longleftarrow2" },
- { "Longleftrightarrow", "longleftrightarrow2" },
- { "Longrightarrow", "longrightarrow2" },
- { "Omega", "omega2" },
- { "Phi", "phi2" },
- { "Pi", "pi2" },
- { "Psi", "psi2" },
- { "Rightarrow", "rightarrow2" },
- { "Sigma", "sigma2" },
- { "Subset", "subset2" },
- { "Supset", "supset2" },
- { "Theta", "theta2" },
- { "Uparrow", "uparrow2" },
- { "Updownarrow", "updownarrow2" },
- { "Upsilon", "upsilon2" },
- { "Vdash", "vdash3" },
- { "Xi", "xi2" },
- { "nLeftarrow", "nleftarrow2" },
- { "nLeftrightarrow", "nleftrightarrow2" },
- { "nRightarrow", "nrightarrow2" },
- { "nVDash", "nvdash3" },
- { "nvDash", "nvdash2" },
- { "textrm \\AA", "textrm_AA"},
- { "textrm \\O", "textrm_O"},
- { "vDash", "vdash2" }
-};
-
-size_t const nr_sorted_png_map = sizeof(sorted_png_map) / sizeof(PngMap);
-
-
-QString findPng(QString const & name)
-{
- PngMap const * const begin = sorted_png_map;
- PngMap const * const end = begin + nr_sorted_png_map;
- BOOST_ASSERT(sorted(begin, end));
-
- PngMap const * const it = find_if(begin, end, CompareKey(name));
-
- QString png_name;
- if (it != end) {
- png_name = it->value;
- } else {
- png_name = name;
- png_name.replace('_', "underscore");
- png_name.replace(' ', '_');
-
- // This way we can have "math-delim { }" on the toolbar.
- png_name.replace('(', "lparen");
- png_name.replace(')', "rparen");
- png_name.replace('[', "lbracket");
- png_name.replace(']', "rbracket");
- png_name.replace('{', "lbrace");
- png_name.replace('}', "rbrace");
- png_name.replace('|', "bars");
- png_name.replace(',', "thinspace");
- png_name.replace(':', "mediumspace");
- png_name.replace(';', "thickspace");
- png_name.replace('!', "negthinspace");
- }
-
- LYXERR(Debug::GUI, "findPng(" << fromqstr(name) << ")\n"
- << "Looking for math PNG called \"" << fromqstr(png_name) << '"');
- return png_name;
-}
-
-} // namespace anon
-
-
-/// return a icon for the given action
-static QIcon getIcon(FuncRequest const & f, bool unknown)
-{
- initializeResources();
- QPixmap pm;
- QString name1;
- QString name2;
- QString path;
- switch (f.action) {
- case LFUN_MATH_INSERT:
- if (!f.argument().empty()) {
- path = "math/";
- name1 = findPng(toqstr(f.argument()).mid(1));
- }
- break;
- case LFUN_MATH_DELIM:
- case LFUN_MATH_BIGDELIM:
- path = "math/";
- name1 = findPng(toqstr(f.argument()));
- break;
- case LFUN_CALL:
- path = "commands/";
- name1 = toqstr(f.argument());
- break;
- default:
- name2 = toqstr(lyxaction.getActionName(f.action));
- name1 = name2;
-
- if (!f.argument().empty()) {
- name1 = name2 + ' ' + toqstr(f.argument());
- name1.replace(' ', '_');
- }
- }
-
- string fullname = libFileSearch("images/" + path, name1, "png").absFilename();
- if (pm.load(toqstr(fullname)))
- return pm;
-
- fullname = libFileSearch("images/" + path, name2, "png").absFilename();
- if (pm.load(toqstr(fullname)))
- return pm;
-
- if (pm.load(":/images/" + path + name1 + ".png"))
- return pm;
-
- if (pm.load(":/images/" + path + name2 + ".png"))
- return pm;
-
- LYXERR(Debug::GUI, "Cannot find icon for command \""
- << lyxaction.getActionName(f.action)
- << '(' << to_utf8(f.argument()) << ")\"");
- if (unknown)
- pm.load(":/images/unknown.png");
-
- return pm;
-}
-
-
/////////////////////////////////////////////////////////////////////
//
// GuiLayoutBox
//
/////////////////////////////////////////////////////////////////////
-class LayoutItemDelegate : public QAbstractItemDelegate {
+class LayoutItemDelegate : public QItemDelegate {
public:
///
explicit LayoutItemDelegate(QObject * parent = 0)
- : QAbstractItemDelegate(parent)
+ : QItemDelegate(parent)
{}
///
void paint(QPainter * painter, QStyleOptionViewItem const & option,
QModelIndex const & index) const
{
- QComboBox * combo = static_cast<QComboBox *>(parent());
- QSortFilterProxyModel const * model
- = static_cast<QSortFilterProxyModel const *>(index.model());
- QStyleOptionMenuItem opt = getStyleOption(option, index);
-
- painter->eraseRect(opt.rect);
+ QStyleOptionViewItem opt = option;
- QString text = underlineFilter(opt.text);
- opt.text = QString();
+ // default background
+ painter->fillRect(opt.rect, opt.palette.color(QPalette::Base));
// category header?
if (lyxrc.group_layouts) {
+ QSortFilterProxyModel const * model
+ = static_cast<QSortFilterProxyModel const *>(index.model());
+
QString stdCat = category(*model->sourceModel(), 0);
QString cat = category(*index.model(), index.row());
// not the standard layout and not the same as in the previous line?
if (stdCat != cat
&& (index.row() == 0 || cat != category(*index.model(), index.row() - 1))) {
+ painter->save();
+
+ // draw unselected background
+ QStyle::State state = opt.state;
+ opt.state = opt.state & ~QStyle::State_Selected;
+ drawBackground(painter, opt, index);
+ opt.state = state;
+
// draw category header
- paintBackground(painter, opt);
- paintCategoryHeader(painter, opt,
+ drawCategoryHeader(painter, opt,
category(*index.model(), index.row()));
// move rect down below header
- opt.rect.moveTop(opt.rect.top() + headerHeight(opt));
- opt.menuRect = opt.rect;
+ opt.rect.setTop(opt.rect.top() + headerHeight(opt));
+
+ painter->restore();
}
}
- // Draw using the menu item style (this is how QComboBox does it).
- // But for the rich text drawing below we will call it with an
- // empty string, and later then draw over it the real string.
- painter->save();
- combo->style()->drawControl(QStyle::CE_MenuItem, &opt, painter, combo->view());
- painter->restore();
-
+ QItemDelegate::paint(painter, opt, index);
+ }
+
+ ///
+ void drawDisplay(QPainter * painter, QStyleOptionViewItem const & opt,
+ const QRect & /*rect*/, const QString & text ) const
+ {
+ QString utext = underlineFilter(text);
+
// Draw the rich text.
painter->save();
QColor col = opt.palette.text().color();
QTextDocument doc;
doc.setDefaultFont(opt.font);
- doc.setHtml(text);
+ doc.setHtml(utext);
QTextFrameFormat fmt = doc.rootFrame()->frameFormat();
fmt.setMargin(0);
}
///
- QSize sizeHint(QStyleOptionViewItem const & option,
+ QSize sizeHint(QStyleOptionViewItem const & opt,
QModelIndex const & index) const
{
GuiLayoutBox * combo = static_cast<GuiLayoutBox *>(parent());
QSortFilterProxyModel const * model
- = static_cast<QSortFilterProxyModel const *>(index.model());
-
- // we use a compressed menu style here
- QStyleOptionMenuItem opt = getStyleOption(option, index);
- QSize size = combo->style()->sizeFromContents(
- QStyle::CT_MenuItem, &opt, opt.rect.size(), combo);
- size.setHeight(opt.rect.height());
+ = static_cast<QSortFilterProxyModel const *>(index.model());
+ QSize size = QItemDelegate::sizeHint(opt, index);
/// QComboBox uses the first row height to estimate the
/// complete popup height during QComboBox::showPopup().
{
return model.data(model.index(row, 2), Qt::DisplayRole).toString();
}
-
- ///
- void paintBackground(QPainter * painter, QStyleOptionMenuItem const & opt) const
- {
- QComboBox * combo = static_cast<QComboBox *>(parent());
-
- // we only want to paint a background using the style, so
- // disable every thing else
- QStyleOptionMenuItem sopt = opt;
- sopt.menuRect = sopt.rect;
- sopt.state = QStyle::State_Active | QStyle::State_Enabled;
- sopt.checked = false;
- sopt.text = QString();
- painter->save();
- combo->style()->drawControl(QStyle::CE_MenuItem, &sopt,
- painter, combo->view());
- painter->restore();
- }
-
///
- int headerHeight(QStyleOptionMenuItem const & opt) const
+ int headerHeight(QStyleOptionViewItem const & opt) const
{
return opt.fontMetrics.height() * 8 / 10;
}
///
- void paintCategoryHeader(QPainter * painter, QStyleOptionMenuItem const & opt,
+ void drawCategoryHeader(QPainter * painter, QStyleOptionViewItem const & opt,
QString const & category) const
{
- painter->save();
-
// slightly blended color
QColor lcol = opt.palette.text().color();
lcol.setAlpha(127);
// draw the centered text
QFontMetrics fm(font);
- int w = opt.fontMetrics.width(category);
+ int w = fm.width(category);
int x = opt.rect.x() + (opt.rect.width() - w) / 2;
int y = opt.rect.y() + fm.ascent();
int left = x;
painter->drawLine(right + 1, ymid, opt.rect.right(), ymid);
} else
painter->drawLine(opt.rect.x(), ymid, opt.rect.right(), ymid);
-
- painter->restore();
}
p->filter();
for (int i = 0; i < f.length(); ++i) {
int p = s.indexOf(f[i], lastp + 1, Qt::CaseInsensitive);
- BOOST_ASSERT(p != -1);
+ LASSERT(p != -1, /**/);
if (lastp == p - 1 && lastp != -1) {
// remove ")" and append "x)"
r = r.left(r.length() - 4) + s[p] + "</u>";
r += s.mid(lastp + 1);
return r;
}
-
- ///
- QStyleOptionMenuItem getStyleOption(QStyleOptionViewItem const & option,
- QModelIndex const & index) const
- {
- QComboBox * combo = static_cast<QComboBox *>(parent());
-
- // create the options for a menu item
- QStyleOptionMenuItem menuOption;
- menuOption.palette = QApplication::palette("QMenu");
- menuOption.state = QStyle::State_Active | QStyle::State_Enabled;
- menuOption.font = combo->font();
- menuOption.fontMetrics = QFontMetrics(menuOption.font);
- menuOption.rect = option.rect;
- menuOption.rect.setHeight(menuOption.fontMetrics.height() + 2);
- menuOption.menuRect = menuOption.rect;
- menuOption.tabWidth = 0;
- menuOption.text = index.model()->data(index, Qt::DisplayRole).toString()
- .replace(QLatin1Char('&'), QLatin1String("&&"));
- menuOption.menuItemType = QStyleOptionMenuItem::Normal;
- if (option.state & QStyle::State_Selected)
- menuOption.state |= QStyle::State_Selected;
- menuOption.checkType = QStyleOptionMenuItem::NotCheckable;
- menuOption.checked = false;
- return menuOption;
- }
};
};
-GuiLayoutBox::GuiLayoutBox(GuiView & owner)
- : owner_(owner), lastSel_(-1), layoutItemDelegate_(new LayoutItemDelegate(this)),
+GuiLayoutBox::GuiLayoutBox(GuiToolbar * bar, GuiView & owner)
+ : owner_(owner), bar_(bar), lastSel_(-1),
+ layoutItemDelegate_(new LayoutItemDelegate(this)),
visibleCategories_(0), inShowPopup_(false)
{
setSizeAdjustPolicy(QComboBox::AdjustToContents);
view()->setItemDelegateForColumn(0, layoutItemDelegate_);
QObject::connect(this, SIGNAL(activated(int)),
- this, SLOT(selected(int)));
+ this, SLOT(selected(int)));
+ QObject::connect(bar_, SIGNAL(iconSizeChanged(QSize)),
+ this, SLOT(setIconSize(QSize)));
+
owner_.setLayoutDialog(this);
updateContents(true);
}
void GuiLayoutBox::setFilter(QString const & s)
{
- if (!s.isEmpty())
- owner_.message(_("Filtering layouts with \"" + fromqstr(s) + "\". "
- "Press ESC to remove filter."));
- else
- owner_.message(_("Enter characters to filter the layout list."));
-
bool enabled = view()->updatesEnabled();
view()->setUpdatesEnabled(false);
// We do not call our implementation of showPopup because that
// would reset the filter again. This is only needed if the user clicks
// on the QComboBox.
- BOOST_ASSERT(!inShowPopup_);
+ LASSERT(!inShowPopup_, /**/);
inShowPopup_ = true;
QComboBox::showPopup();
inShowPopup_ = false;
// The item delegate hack is off again. So trigger a relayout of the popup.
filterModel_->triggerLayoutChange();
+
+ if (!s.isEmpty())
+ owner_.message(_("Filtering layouts with \"" + fromqstr(s) + "\". "
+ "Press ESC to remove filter."));
+ else
+ owner_.message(_("Enter characters to filter the layout list."));
}
view()->setUpdatesEnabled(enabled);
// call QComboBox::showPopup. But set the inShowPopup_ flag to switch on
// the hack in the item delegate to make space for the headers.
- BOOST_ASSERT(!inShowPopup_);
+ LASSERT(!inShowPopup_, /**/);
inShowPopup_ = true;
QComboBox::showPopup();
inShowPopup_ = false;
return QComboBox::eventFilter(o, e);
}
+
+void GuiLayoutBox::setIconSize(QSize size)
+{
+#ifdef Q_WS_MACX
+ bool small = size.height() < 20;
+ setAttribute(Qt::WA_MacSmallSize, small);
+ setAttribute(Qt::WA_MacNormalSize, !small);
+#else
+ (void)size; // suppress warning
+#endif
+}
+
void GuiLayoutBox::set(docstring const & layout)
{
if (!text_class_)
return;
- QString const & name = toqstr((*text_class_)[layout].name());
+ Layout const & lay = (*text_class_)[layout];
+ QString const & name = toqstr(lay.name() + (lay.isUnknown() ? " (unknown)" : ""));
if (name == currentText())
return;
QList<QStandardItem *> r = model_->findItems(name, Qt::MatchExactly, 1);
if (r.empty()) {
- lyxerr << "Trying to select non existent layout type "
- << fromqstr(name) << endl;
+ LYXERR0("Trying to select non existent layout type " << name);
return;
}
if (i < end) {
// find alphabetic position
while (i != end
- && model_->item(i, 0)->text().compare(titem) < 0
+ && model_->item(i, 0)->text().localeAwareCompare(titem) < 0
&& (!sortedByCat || model_->item(i, 2)->text() == qcat))
++i;
}
// or we've moved from one inset to another
DocumentClass const * text_class = &buffer->params().documentClass();
Inset const * inset =
- owner_.view()->cursor().innerParagraph().inInset();
+ owner_.view()->cursor().innerParagraph().inInset();
if (!reset && text_class_ == text_class && inset_ == inset) {
set(owner_.view()->cursor().innerParagraph().layout().name());
return;
model_->clear();
DocumentClass::const_iterator lit = text_class_->begin();
DocumentClass::const_iterator len = text_class_->end();
+
for (; lit != len; ++lit) {
docstring const & name = lit->name();
+ bool const useEmpty = inset_->forcePlainLayout() || inset_->usePlainLayout();
// if this inset requires the empty layout, we skip the default
// layout
- if (name == text_class_->defaultLayoutName() && inset &&
- (inset->forceEmptyLayout() || inset->useEmptyLayout()))
+ if (name == text_class_->defaultLayoutName() && inset_ && useEmpty)
continue;
// if it doesn't require the empty layout, we skip it
- if (name == text_class_->emptyLayoutName() && inset &&
- !inset->forceEmptyLayout() && !inset->useEmptyLayout())
+ if (name == text_class_->emptyLayoutName() && inset_ && !useEmpty)
continue;
- addItemSort(name, lit->category(), lyxrc.sort_layouts, lyxrc.group_layouts);
+ addItemSort(name + (lit->isUnknown() ? " (unknown)" : ""),
+ lit->category(), lyxrc.sort_layouts, lyxrc.group_layouts);
}
set(owner_.view()->cursor().innerParagraph().layout().name());
{
// get selection
QModelIndex mindex = filterModel_->mapToSource(filterModel_->index(index, 1));
- docstring const layoutName =
- qstring_to_ucs4(model_->itemFromIndex(mindex)->text());
+ docstring const layoutName = rtrim(
+ qstring_to_ucs4(model_->itemFromIndex(mindex)->text()), " (unknown)");
owner_.setFocus();
resetFilter();
return;
}
- lyxerr << "ERROR (layoutSelected): layout not found!" << endl;
+ LYXERR0("ERROR (layoutSelected): layout not found!");
}
GuiToolbar::GuiToolbar(ToolbarInfo const & tbinfo, GuiView & owner)
- : QToolBar(qt_(tbinfo.gui_name), &owner), owner_(owner),
- layout_(0), command_buffer_(0)
+ : QToolBar(qt_(tbinfo.gui_name), &owner), visibility_(0),
+ allowauto_(false), owner_(owner), layout_(0), command_buffer_(0),
+ tbinfo_(tbinfo), filled_(false)
{
- // give visual separation between adjacent toolbars
- addSeparator();
+ setIconSize(owner.iconSize());
+ connect(&owner, SIGNAL(iconSizeChanged(QSize)), this,
+ SLOT(setIconSize(QSize)));
- // TODO: save toolbar position
+ // Toolbar dragging is allowed.
setMovable(true);
+ // This is used by QMainWindow::restoreState for proper main window state
+ // restauration.
+ setObjectName(toqstr(tbinfo.name));
+ restoreSession();
+}
- ToolbarInfo::item_iterator it = tbinfo.items.begin();
- ToolbarInfo::item_iterator end = tbinfo.items.end();
+
+void GuiToolbar::fill()
+{
+ if (filled_)
+ return;
+ ToolbarInfo::item_iterator it = tbinfo_.items.begin();
+ ToolbarInfo::item_iterator end = tbinfo_.items.end();
for (; it != end; ++it)
- add(*it);
+ add(*it);
+ filled_ = true;
+}
+
+
+void GuiToolbar::showEvent(QShowEvent * ev)
+{
+ fill();
+ ev->accept();
+}
+
+
+void GuiToolbar::setVisibility(int visibility)
+{
+ visibility_ = visibility;
+ allowauto_ = visibility_ >= Toolbars::MATH;
}
Action * GuiToolbar::addItem(ToolbarItem const & item)
{
- Action * act = new Action(owner_,
- getIcon(item.func_, false),
- toqstr(item.label_), item.func_, toqstr(item.label_));
+ Action * act = new Action(&owner_, getIcon(item.func_, false),
+ toqstr(item.label_), item.func_, toqstr(item.label_), this);
actions_.append(act);
return act;
}
connect(bar_, SIGNAL(iconSizeChanged(QSize)),
this, SLOT(setIconSize(QSize)));
setCheckable(true);
- ToolbarInfo const * tbinfo =
- toolbarbackend.getDefinedToolbarInfo(tbitem_.name_);
+ ToolbarInfo const * tbinfo = guiApp->toolbars().info(tbitem_.name_);
if (tbinfo)
// use the icon of first action for the toolbar button
setIcon(getIcon(tbinfo->items.begin()->func_, true));
initialized_ = true;
- ToolbarInfo const * tbinfo =
- toolbarbackend.getDefinedToolbarInfo(tbitem_.name_);
+ ToolbarInfo const * tbinfo = guiApp->toolbars().info(tbitem_.name_);
if (!tbinfo) {
- lyxerr << "Unknown toolbar " << tbitem_.name_ << endl;
+ LYXERR0("Unknown toolbar " << tbitem_.name_);
return;
}
IconPalette * panel = new IconPalette(this);
m->setWindowTitle(label);
m->setTearOffEnabled(true);
connect(bar_, SIGNAL(updated()), m, SLOT(updateParent()));
- ToolbarInfo const * tbinfo =
- toolbarbackend.getDefinedToolbarInfo(tbitem_.name_);
+ ToolbarInfo const * tbinfo = guiApp->toolbars().info(tbitem_.name_);
if (!tbinfo) {
- lyxerr << "Unknown toolbar " << tbitem_.name_ << endl;
+ LYXERR0("Unknown toolbar " << tbitem_.name_);
return;
}
ToolbarInfo::item_iterator it = tbinfo->items.begin();
addSeparator();
break;
case ToolbarItem::LAYOUTS:
- layout_ = new GuiLayoutBox(owner_);
+ layout_ = new GuiLayoutBox(this, owner_);
addWidget(layout_);
break;
case ToolbarItem::MINIBUFFER:
}
-void GuiToolbar::saveInfo(ToolbarSection::ToolbarInfo & tbinfo)
+void GuiToolbar::update(bool in_math, bool in_table, bool in_review,
+ bool in_mathmacrotemplate)
{
- // if tbinfo.state == auto *do not* set on/off
- if (tbinfo.state != ToolbarSection::ToolbarInfo::AUTO) {
- if (GuiToolbar::isVisible())
- tbinfo.state = ToolbarSection::ToolbarInfo::ON;
- else
- tbinfo.state = ToolbarSection::ToolbarInfo::OFF;
+ if (visibility_ & Toolbars::AUTO) {
+ bool show_it = in_math && (visibility_ & Toolbars::MATH)
+ || in_table && (visibility_ & Toolbars::TABLE)
+ || in_review && (visibility_ & Toolbars::REVIEW)
+ || in_mathmacrotemplate && (visibility_ & Toolbars::MATHMACROTEMPLATE);
+ setVisible(show_it);
}
- //
- // no need to save it here.
- Qt::ToolBarArea loc = owner_.toolBarArea(this);
-
- if (loc == Qt::TopToolBarArea)
- tbinfo.location = ToolbarSection::ToolbarInfo::TOP;
- else if (loc == Qt::BottomToolBarArea)
- tbinfo.location = ToolbarSection::ToolbarInfo::BOTTOM;
- else if (loc == Qt::RightToolBarArea)
- tbinfo.location = ToolbarSection::ToolbarInfo::RIGHT;
- else if (loc == Qt::LeftToolBarArea)
- tbinfo.location = ToolbarSection::ToolbarInfo::LEFT;
- else
- tbinfo.location = ToolbarSection::ToolbarInfo::NOTSET;
-
- // save toolbar position. They are not used to restore toolbar position
- // now because move(x,y) does not work for toolbar.
- tbinfo.posx = pos().x();
- tbinfo.posy = pos().y();
-}
-
-void GuiToolbar::updateContents()
-{
// update visible toolbars only
if (!isVisible())
return;
+
// This is a speed bottleneck because this is called on every keypress
// and update calls getStatus, which copies the cursor at least two times
for (int i = 0; i < actions_.size(); ++i)
}
+QString GuiToolbar::sessionKey() const
+{
+ return "view-" + QString::number(owner_.id()) + "/" + objectName();
+}
+
+
+void GuiToolbar::saveSession() const
+{
+ QSettings settings;
+ settings.setValue(sessionKey() + "/visibility", visibility_);
+}
+
+
+void GuiToolbar::restoreSession()
+{
+ QSettings settings;
+ setVisibility(settings.value(sessionKey() + "/visibility").toInt());
+}
+
+
+void GuiToolbar::toggle()
+{
+ docstring state;
+ if (allowauto_) {
+ if (!(visibility_ & Toolbars::AUTO)) {
+ visibility_ |= Toolbars::AUTO;
+ hide();
+ state = _("auto");
+ } else {
+ visibility_ &= ~Toolbars::AUTO;
+ if (isVisible()) {
+ hide();
+ state = _("off");
+ } else {
+ show();
+ state = _("on");
+ }
+ }
+ } else {
+ if (isVisible()) {
+ hide();
+ state = _("off");
+ } else {
+ show();
+ state = _("on");
+ }
+ }
+
+ owner_.message(bformat(_("Toolbar \"%1$s\" state set to %2$s"),
+ qstring_to_ucs4(windowTitle()), state));
+}
+
} // namespace frontend
} // namespace lyx