#include "GuiImplementation.h"
#include "GuiWorkArea.h"
-#include "QKeySymbol.h"
-#include "QLMenubar.h"
-#include "QLToolbar.h"
-#include "QCommandBuffer.h"
+#include "GuiKeySymbol.h"
+#include "GuiMenubar.h"
+#include "GuiToolbar.h"
#include "qt_helpers.h"
#include "frontends/Application.h"
+#include "frontends/Dialogs.h"
#include "frontends/Gui.h"
#include "frontends/WorkArea.h"
#include "support/filetools.h"
#include "support/convert.h"
#include "support/lstrings.h"
+#include "support/os.h"
+#include "Buffer.h"
#include "BufferView.h"
#include "BufferList.h"
+#include "callback.h"
#include "debug.h"
#include "FuncRequest.h"
-#include "callback.h"
-#include "LyXRC.h"
#include "LyX.h"
-#include "Session.h"
#include "LyXFunc.h"
+#include "LyXRC.h"
#include "MenuBackend.h"
-#include "Buffer.h"
-#include "BufferList.h"
+#include "Session.h"
+#include "version.h"
#include <QAction>
#include <QApplication>
#include <QCloseEvent>
+#include <QDesktopWidget>
+#include <QDragEnterEvent>
+#include <QDropEvent>
+#include <QList>
+#include <QMimeData>
+#include <QPainter>
#include <QPixmap>
+#include <QPushButton>
+#include <QStackedWidget>
#include <QStatusBar>
-#include <QToolBar>
#include <QTabBar>
-#include <QDesktopWidget>
-#include <QVBoxLayout>
-#include <QHBoxLayout>
-#include <QPushButton>
-
+#include <QToolBar>
+#include <QTabWidget>
+#include <QUrl>
#include <boost/bind.hpp>
#include <boost/shared_ptr.hpp>
+#include <boost/current_function.hpp>
using std::endl;
using std::string;
int const statusbar_timer_value = 3000;
-class TabWidget : public QWidget
+class BackgroundWidget : public QWidget
{
- QHBoxLayout* hlayout;
public:
- QTabBar* tabbar;
- QPushButton* closeTabButton;
-
- void hideTabsIfNecessary()
+ BackgroundWidget(QString const & file, QString const & text)
{
- if (tabbar->count() > 1) {
- tabbar->show();
- closeTabButton->show();
- } else {
- tabbar->hide();
- closeTabButton->hide();
+ splash_ = new QPixmap(file);
+ if (!splash_) {
+ lyxerr << "could not load splash screen: '" << fromqstr(file) << "'" << endl;
+ return;
}
+
+ QPainter pain(splash_);
+ pain.setPen(QColor(255, 255, 0));
+ QFont font;
+ // The font used to display the version info
+ font.setStyleHint(QFont::SansSerif);
+ font.setWeight(QFont::Bold);
+ font.setPointSize(convert<int>(lyxrc.font_sizes[Font::SIZE_LARGE]));
+ pain.setFont(font);
+ pain.drawText(260, 270, text);
}
- TabWidget(QWidget* w, bool topTabBar)
+ void paintEvent(QPaintEvent *)
{
- closeTabButton = new QPushButton(this);
- FileName const file = support::libFileSearch("images", "closetab", "xpm");
- if (!file.empty()) {
- QPixmap pm(toqstr(file.absFilename()));
- closeTabButton->setIcon(QIcon(pm));
- closeTabButton->setMaximumSize(pm.size());
- closeTabButton->setFlat(true);
- } else {
- closeTabButton->setText("Close");
- }
- closeTabButton->setCursor(Qt::ArrowCursor);
- closeTabButton->setToolTip(tr("Close tab"));
- closeTabButton->setEnabled(true);
+ if (!splash_)
+ return;
- tabbar = new QTabBar;
-#if QT_VERSION >= 0x040200
- tabbar->setUsesScrollButtons(true);
-#endif
- hlayout = new QHBoxLayout;
- QVBoxLayout* vlayout = new QVBoxLayout;
- hlayout->addWidget(tabbar);
- hlayout->addWidget(closeTabButton);
- if (topTabBar) {
- vlayout->addLayout(hlayout);
- vlayout->addWidget(w);
- } else {
- tabbar->setShape(QTabBar::RoundedSouth);
- vlayout->addWidget(w);
- vlayout->addLayout(hlayout);
- }
- vlayout->setMargin(0);
- vlayout->setSpacing(0);
- hlayout->setMargin(0);
- setLayout(vlayout);
- hideTabsIfNecessary();
+ int x = (width() - splash_->width()) / 2;
+ int y = (height() - splash_->height()) / 2;
+ QPainter pain(this);
+ pain.drawPixmap(x, y, *splash_);
}
- void clearTabbar()
- {
- for (int i = tabbar->count() - 1; i >= 0; --i)
- tabbar->removeTab(i);
- }
+private:
+ QPixmap * splash_;
+};
+
+
+class TabWidget : public QTabWidget {
+public:
+ void showBar(bool show) { tabBar()->setVisible(show); }
};
+
} // namespace anon
-struct GuiView::GuiViewPrivate
+struct GuiViewBase::GuiViewPrivate
{
- vector<string> tabnames;
string cur_title;
- TabWidget* tabWidget;
-
int posx_offset;
int posy_offset;
- GuiViewPrivate() : tabWidget(0), posx_offset(0), posy_offset(0)
- {}
+ TabWidget * tab_widget_;
+ QStackedWidget * stack_widget_;
+ BackgroundWidget * bg_widget_;
+ /// view's menubar
+ GuiMenubar * menubar_;
+
+ GuiViewPrivate() : posx_offset(0), posy_offset(0) {}
unsigned int smallIconSize;
unsigned int normalIconSize;
// static needed by "New Window"
static unsigned int lastIconSize;
- QMenu* toolBarPopup(GuiView *parent)
+ QMenu * toolBarPopup(GuiViewBase * parent)
{
// FIXME: translation
- QMenu* menu = new QMenu(parent);
- QActionGroup *iconSizeGroup = new QActionGroup(parent);
+ QMenu * menu = new QMenu(parent);
+ QActionGroup * iconSizeGroup = new QActionGroup(parent);
- QAction *smallIcons = new QAction(iconSizeGroup);
+ QAction * smallIcons = new QAction(iconSizeGroup);
smallIcons->setText(qt_("Small-sized icons"));
smallIcons->setCheckable(true);
QObject::connect(smallIcons, SIGNAL(triggered()), parent, SLOT(smallSizedIcons()));
menu->addAction(smallIcons);
- QAction *normalIcons = new QAction(iconSizeGroup);
+ QAction * normalIcons = new QAction(iconSizeGroup);
normalIcons->setText(qt_("Normal-sized icons"));
normalIcons->setCheckable(true);
QObject::connect(normalIcons, SIGNAL(triggered()), parent, SLOT(normalSizedIcons()));
menu->addAction(normalIcons);
- QAction *bigIcons = new QAction(iconSizeGroup);
+ QAction * bigIcons = new QAction(iconSizeGroup);
bigIcons->setText(qt_("Big-sized icons"));
bigIcons->setCheckable(true);
QObject::connect(bigIcons, SIGNAL(triggered()), parent, SLOT(bigSizedIcons()));
return menu;
}
+
+ void initBackground()
+ {
+ bg_widget_ = 0;
+ LYXERR(Debug::GUI) << "show banner: " << lyxrc.show_banner << endl;
+ /// The text to be written on top of the pixmap
+ QString const text = lyx_version ? QString(lyx_version) : qt_("unknown version");
+ FileName const file = support::libFileSearch("images", "banner", "png");
+ if (file.empty())
+ return;
+
+ bg_widget_ = new BackgroundWidget(toqstr(file.absFilename()), text);
+ }
+
+ void setBackground()
+ {
+ if (!bg_widget_)
+ return;
+
+ stack_widget_->setCurrentWidget(bg_widget_);
+ bg_widget_->setUpdatesEnabled(true);
+ }
};
-unsigned int GuiView::GuiViewPrivate::lastIconSize = 0;
+unsigned int GuiViewBase::GuiViewPrivate::lastIconSize = 0;
-GuiView::GuiView(int id)
- : QMainWindow(), LyXView(id), commandbuffer_(0), quitting_by_menu_(false),
+GuiViewBase::GuiViewBase(int id)
+ : QMainWindow(), LyXView(id), quitting_by_menu_(false),
d(*new GuiViewPrivate)
{
// Qt bug? signal lastWindowClosed does not work
d.bigIconSize = 26; // better for some math icons
#ifndef Q_WS_MACX
- // assign an icon to main form. We do not do it under Qt/Mac,
- // since the icon is provided in the application bundle.
- FileName const iconname = libFileSearch("images", "lyx", "xpm");
+ // assign an icon to main form. We do not do it under Qt/Mac,
+ // since the icon is provided in the application bundle.
+ FileName const iconname = libFileSearch("images", "lyx", "png");
if (!iconname.empty())
setWindowIcon(QPixmap(toqstr(iconname.absFilename())));
#endif
+
+ d.tab_widget_ = new TabWidget;
+
+ QPushButton * closeTabButton = new QPushButton(this);
+ FileName const file = support::libFileSearch("images", "closetab", "png");
+ if (!file.empty()) {
+ QPixmap pm(toqstr(file.absFilename()));
+ closeTabButton->setIcon(QIcon(pm));
+ closeTabButton->setMaximumSize(pm.size());
+ closeTabButton->setFlat(true);
+ } else {
+ closeTabButton->setText("Close");
+ }
+ closeTabButton->setCursor(Qt::ArrowCursor);
+ closeTabButton->setToolTip(tr("Close tab"));
+ closeTabButton->setEnabled(true);
+
+ QObject::connect(d.tab_widget_, SIGNAL(currentChanged(int)),
+ this, SLOT(currentTabChanged(int)));
+ QObject::connect(closeTabButton, SIGNAL(clicked()),
+ this, SLOT(closeCurrentTab()));
+
+ d.tab_widget_->setCornerWidget(closeTabButton);
+#if QT_VERSION >= 0x040200
+ d.tab_widget_->setUsesScrollButtons(true);
+#endif
+
+ d.initBackground();
+ if (d.bg_widget_) {
+ LYXERR(Debug::GUI) << "stack widget!" << endl;
+ d.stack_widget_ = new QStackedWidget;
+ d.stack_widget_->addWidget(d.bg_widget_);
+ d.stack_widget_->addWidget(d.tab_widget_);
+ setCentralWidget(d.stack_widget_);
+ } else {
+ d.stack_widget_ = 0;
+ setCentralWidget(d.tab_widget_);
+ }
+
+ // For Drag&Drop.
+ setAcceptDrops(true);
}
-GuiView::~GuiView()
+GuiViewBase::~GuiViewBase()
{
- menubar_.reset();
+ delete d.menubar_;
delete &d;
}
-void GuiView::close()
+void GuiViewBase::close()
{
quitting_by_menu_ = true;
QMainWindow::close();
}
-void GuiView::setFocus()
+void GuiViewBase::setFocus()
{
- BOOST_ASSERT(work_area_);
- static_cast<GuiWorkArea *>(work_area_)->setFocus();
+ if (d.tab_widget_->count())
+ d.tab_widget_->currentWidget()->setFocus();
}
-QMenu* GuiView::createPopupMenu()
+QMenu* GuiViewBase::createPopupMenu()
{
return d.toolBarPopup(this);
}
-void GuiView::init()
+void GuiViewBase::init()
{
- menubar_.reset(new QLMenubar(this, menubackend));
- QObject::connect(menuBar(), SIGNAL(triggered(QAction *)),
- this, SLOT(updateMenu(QAction *)));
+ d.menubar_ = new GuiMenubar(this, menubackend);
- getToolbars().init();
+ toolbars_->init();
statusBar()->setSizeGripEnabled(true);
QObject::connect(&statusbar_timer_, SIGNAL(timeout()),
this, SLOT(update_view_state_qt()));
- BOOST_ASSERT(work_area_);
- if (!work_area_->bufferView().buffer() && !theBufferList().empty())
- setBuffer(theBufferList().first());
-
- // make sure the buttons are disabled if needed
- updateToolbars();
- updateLayoutChoice();
- updateMenubar();
+ if (d.stack_widget_)
+ d.stack_widget_->setCurrentWidget(d.bg_widget_);
}
-void GuiView::closeEvent(QCloseEvent * close_event)
+void GuiViewBase::closeEvent(QCloseEvent * close_event)
{
// we may have been called through the close window button
// which bypasses the LFUN machinery.
theApp()->gui().unregisterView(id());
if (!theApp()->gui().viewIds().empty()) {
- quitting = true;
// Just close the window and do nothing else if this is not the
// last window.
close_event->accept();
return;
}
- if (view()->buffer()) {
- // save cursor position for opened files to .lyx/session
- // only bottom (whole doc) level pit and pos is saved.
- LyX::ref().session().lastFilePos().save(
- FileName(buffer()->fileName()),
- boost::tie(view()->cursor().bottom().pit(),
- view()->cursor().bottom().pos()));
- }
+ quitting = true;
// this is the place where we leave the frontend.
// it is the only point at which we start quitting.
}
-void GuiView::saveGeometry()
+void GuiViewBase::dragEnterEvent(QDragEnterEvent * event)
+{
+ if (event->mimeData()->hasUrls())
+ event->accept();
+ /// \todo Ask lyx-devel is this is enough:
+ /// if (event->mimeData()->hasFormat("text/plain"))
+ /// event->acceptProposedAction();
+}
+
+
+void GuiViewBase::dropEvent(QDropEvent* event)
+{
+ QList<QUrl> files = event->mimeData()->urls();
+ if (files.isEmpty())
+ return;
+
+ LYXERR(Debug::GUI) << BOOST_CURRENT_FUNCTION
+ << " got URLs!" << endl;
+ for (int i = 0; i != files.size(); ++i) {
+ string const file = support::os::internal_path(fromqstr(
+ files.at(i).toLocalFile()));
+ if (!file.empty())
+ dispatch(FuncRequest(LFUN_FILE_OPEN, file));
+ }
+}
+
+
+void GuiViewBase::saveGeometry()
{
static bool done = false;
if (done)
// http://www.trolltech.com/developer/task-tracker/index_html?id=119684+&method=entry
// Then also the moveEvent, resizeEvent, and the
// code for floatingGeometry_ can be removed;
- // adjust GuiView::setGeometry()
+ // adjust GuiViewBase::setGeometry()
QRect normal_geometry;
int maximized;
session.sessionInfo().save("WindowPosX", convert<string>(normal_geometry.x() + d.posx_offset));
session.sessionInfo().save("WindowPosY", convert<string>(normal_geometry.y() + d.posy_offset));
}
- getToolbars().saveToolbarInfo();
+ toolbars_->saveToolbarInfo();
}
-void GuiView::setGeometry(unsigned int width,
+void GuiViewBase::setGeometry(unsigned int width,
unsigned int height,
int posx, int posy,
int maximized,
(void)geometryArg;
#endif
}
-
+
+ d.setBackground();
+
show();
// For an unknown reason, the Window title update is not effective for
}
-void GuiView::updateMenu(QAction * /*action*/)
-{
- menubar_->update();
-}
-
-
-void GuiView::setWindowTitle(docstring const & t, docstring const & it)
+void GuiViewBase::setWindowTitle(docstring const & t, docstring const & it)
{
QString title = windowTitle();
QString new_title = toqstr(t);
}
-void GuiView::addCommandBuffer(QToolBar * toolbar)
-{
- commandbuffer_ = new QCommandBuffer(this, *controlcommand_);
- focus_command_buffer.connect(boost::bind(&GuiView::focus_command_widget, this));
- toolbar->addWidget(commandbuffer_);
-}
-
-
-void GuiView::message(docstring const & str)
+void GuiViewBase::message(docstring const & str)
{
statusBar()->showMessage(toqstr(str));
statusbar_timer_.stop();
}
-void GuiView::clearMessage()
+void GuiViewBase::clearMessage()
{
update_view_state_qt();
}
-void GuiView::setIconSize(unsigned int size)
+void GuiViewBase::setIconSize(unsigned int size)
{
d.lastIconSize = size;
QMainWindow::setIconSize(QSize(size, size));
}
-void GuiView::smallSizedIcons()
+void GuiViewBase::smallSizedIcons()
{
setIconSize(d.smallIconSize);
}
-void GuiView::normalSizedIcons()
+void GuiViewBase::normalSizedIcons()
{
setIconSize(d.normalIconSize);
}
-void GuiView::bigSizedIcons()
+void GuiViewBase::bigSizedIcons()
{
setIconSize(d.bigIconSize);
}
-void GuiView::focus_command_widget()
-{
- if (commandbuffer_)
- commandbuffer_->focus_command();
-}
-
-
-void GuiView::update_view_state_qt()
+void GuiViewBase::update_view_state_qt()
{
+ if (!hasFocus())
+ return;
+ theLyXFunc().setLyXView(this);
statusBar()->showMessage(toqstr(theLyXFunc().viewStatusMessage()));
statusbar_timer_.stop();
}
-void GuiView::initTab(QWidget* workarea)
+void GuiViewBase::closeCurrentTab()
{
- // construct the TabWidget with 'false' to have the tabbar at the bottom
- d.tabWidget = new TabWidget(workarea, true);
- setCentralWidget(d.tabWidget);
- QObject::connect(d.tabWidget->tabbar, SIGNAL(currentChanged(int)),
- this, SLOT(currentTabChanged(int)));
- QObject::connect(d.tabWidget->closeTabButton, SIGNAL(clicked()),
- this, SLOT(closeCurrentTab()));
-}
-
-
-void GuiView::updateTab()
-{
- std::vector<string> const & names = theBufferList().getFileNames();
-
- string cur_title;
- if (view()->buffer()) {
- cur_title = view()->buffer()->fileName();
- }
-
- // avoid unnecessary tabbar rebuild:
- // check if something has changed
- if (d.tabnames == names && d.cur_title == cur_title)
- return;
- d.tabnames = names;
- d.cur_title = cur_title;
-
- QTabBar & tabbar = *d.tabWidget->tabbar;
-
- // update when all is done
- tabbar.blockSignals(true);
-
- // remove all tab bars
- d.tabWidget->clearTabbar();
-
- // rebuild tabbar and function map from scratch
- if (names.size() > 1) {
- for(size_t i = 0; i < names.size(); i++) {
- tabbar.addTab(toqstr(makeDisplayPath(names[i], 30)));
- // set current tab
- if (names[i] == cur_title)
- tabbar.setCurrentIndex(i);
- }
- }
- tabbar.blockSignals(false);
- d.tabWidget->hideTabsIfNecessary();
+ dispatch(FuncRequest(LFUN_BUFFER_CLOSE));
}
-void GuiView::closeCurrentTab()
+void GuiViewBase::currentTabChanged(int i)
{
- dispatch(FuncRequest(LFUN_BUFFER_CLOSE));
-}
+ disconnectBuffer();
+ disconnectBufferView();
+ GuiWorkArea * wa = dynamic_cast<GuiWorkArea *>(d.tab_widget_->widget(i));
+ BOOST_ASSERT(wa);
+ BufferView & bv = wa->bufferView();
+ connectBufferView(bv);
+ connectBuffer(bv.buffer());
+ bv.updateMetrics(false);
+ bv.cursor().fixIfBroken();
+ wa->setUpdatesEnabled(true);
+ wa->redraw();
+ wa->setFocus();
+ updateToc();
+ // Buffer-dependent dialogs should be updated or
+ // hidden. This should go here because some dialogs (eg ToC)
+ // require bv_->text.
+ getDialogs().updateBufferDependent(true);
+ updateToolbars();
+ updateLayoutChoice();
+ updateWindowTitle();
+ updateStatusBar();
-void GuiView::currentTabChanged(int i)
-{
- BOOST_ASSERT(i >= 0 && size_type(i) < d.tabnames.size());
- dispatch(FuncRequest(LFUN_BUFFER_SWITCH, d.tabnames[i]));
+ LYXERR(Debug::GUI) << "currentTabChanged " << i
+ << "File" << bv.buffer().fileName() << endl;
}
-void GuiView::updateStatusBar()
+void GuiViewBase::updateStatusBar()
{
// let the user see the explicit message
if (statusbar_timer_.isActive())
}
-void GuiView::activated(FuncRequest const & func)
+void GuiViewBase::activated(FuncRequest const & func)
{
dispatch(func);
}
-bool GuiView::hasFocus() const
+bool GuiViewBase::hasFocus() const
{
return qApp->activeWindow() == this;
}
-QRect GuiView::updateFloatingGeometry()
+QRect GuiViewBase::updateFloatingGeometry()
{
QDesktopWidget& dw = *qApp->desktop();
QRect desk = dw.availableGeometry(dw.primaryScreen());
}
-void GuiView::resizeEvent(QResizeEvent *)
+void GuiViewBase::resizeEvent(QResizeEvent *)
{
updateFloatingGeometry();
}
-void GuiView::moveEvent(QMoveEvent *)
+void GuiViewBase::moveEvent(QMoveEvent *)
{
updateFloatingGeometry();
}
-bool GuiView::event(QEvent * e)
+bool GuiViewBase::event(QEvent * e)
{
- // Useful debug code:
- /*
switch (e->type())
{
- case QEvent::WindowActivate:
- case QEvent::ActivationChange:
- case QEvent::WindowDeactivate:
- case QEvent::Paint:
- case QEvent::Enter:
- case QEvent::Leave:
- case QEvent::HoverEnter:
- case QEvent::HoverLeave:
- case QEvent::HoverMove:
- case QEvent::StatusTip:
- break;
- default:
- */
-
- if (e->type() == QEvent::ShortcutOverride) {
+ // Useful debug code:
+ //case QEvent::WindowActivate:
+ //case QEvent::ActivationChange:
+ //case QEvent::WindowDeactivate:
+ //case QEvent::Paint:
+ //case QEvent::Enter:
+ //case QEvent::Leave:
+ //case QEvent::HoverEnter:
+ //case QEvent::HoverLeave:
+ //case QEvent::HoverMove:
+ //case QEvent::StatusTip:
+ //case QEvent::DragEnter:
+ //case QEvent::DragLeave:
+ //case QEvent::Drop:
+ // break;
+
+ case QEvent::ShortcutOverride: {
QKeyEvent * ke = static_cast<QKeyEvent*>(e);
+ if (d.tab_widget_->count() == 0) {
+ theLyXFunc().setLyXView(this);
+ boost::shared_ptr<GuiKeySymbol> sym(new GuiKeySymbol);
+ sym->set(ke);
+ theLyXFunc().processKeySym(sym, q_key_state(ke->modifiers()));
+ e->accept();
+ return true;
+ }
if (ke->key() == Qt::Key_Tab || ke->key() == Qt::Key_Backtab) {
- boost::shared_ptr<QKeySymbol> sym(new QKeySymbol);
+ boost::shared_ptr<GuiKeySymbol> sym(new GuiKeySymbol);
sym->set(ke);
- BOOST_ASSERT(work_area_);
- work_area_->processKeySym(sym, key_modifier::none);
+ currentWorkArea()->processKeySym(sym, key_modifier::none);
e->accept();
return true;
}
}
- //} for the debug switch above.
-
- return QMainWindow::event(e);
+ default:
+ return QMainWindow::event(e);
+ }
}
-bool GuiView::focusNextPrevChild(bool /*next*/)
+bool GuiViewBase::focusNextPrevChild(bool /*next*/)
{
setFocus();
return true;
}
-void GuiView::show()
+void GuiViewBase::showView()
{
QMainWindow::setWindowTitle(qt_("LyX"));
QMainWindow::show();
}
-void GuiView::busy(bool yes)
+void GuiViewBase::busy(bool yes)
{
- BOOST_ASSERT(work_area_);
- static_cast<GuiWorkArea *>(work_area_)->setUpdatesEnabled(!yes);
+ if (d.tab_widget_->count()) {
+ GuiWorkArea * wa = dynamic_cast<GuiWorkArea *>(d.tab_widget_->currentWidget());
+ BOOST_ASSERT(wa);
+ wa->setUpdatesEnabled(!yes);
+ if (yes)
+ wa->stopBlinkingCursor();
+ else
+ wa->startBlinkingCursor();
+ }
- if (yes) {
- work_area_->stopBlinkingCursor();
+ if (yes)
QApplication::setOverrideCursor(Qt::WaitCursor);
- }
- else {
- work_area_->startBlinkingCursor();
+ else
QApplication::restoreOverrideCursor();
- }
}
-Toolbars::ToolbarPtr GuiView::makeToolbar(ToolbarInfo const & tbinfo, bool newline)
+Toolbars::ToolbarPtr GuiViewBase::makeToolbar(ToolbarInfo const & tbinfo, bool newline)
{
- QLToolbar * Tb = new QLToolbar(tbinfo, *this);
+ GuiToolbar * toolBar = new GuiToolbar(tbinfo, *this);
if (tbinfo.flags & ToolbarInfo::TOP) {
if (newline)
addToolBarBreak(Qt::TopToolBarArea);
- addToolBar(Qt::TopToolBarArea, Tb);
+ addToolBar(Qt::TopToolBarArea, toolBar);
}
if (tbinfo.flags & ToolbarInfo::BOTTOM) {
if (newline)
addToolBarBreak(Qt::BottomToolBarArea);
#endif
- addToolBar(Qt::BottomToolBarArea, Tb);
+ addToolBar(Qt::BottomToolBarArea, toolBar);
}
if (tbinfo.flags & ToolbarInfo::LEFT) {
if (newline)
addToolBarBreak(Qt::LeftToolBarArea);
#endif
- addToolBar(Qt::LeftToolBarArea, Tb);
+ addToolBar(Qt::LeftToolBarArea, toolBar);
}
if (tbinfo.flags & ToolbarInfo::RIGHT) {
if (newline)
addToolBarBreak(Qt::RightToolBarArea);
#endif
- addToolBar(Qt::RightToolBarArea, Tb);
+ addToolBar(Qt::RightToolBarArea, toolBar);
}
// The following does not work so I cannot restore to exact toolbar location
/*
ToolbarSection::ToolbarInfo & tbinfo = LyX::ref().session().toolbars().load(tbinfo.name);
- Tb->move(tbinfo.posx, tbinfo.posy);
+ toolBar->move(tbinfo.posx, tbinfo.posy);
*/
- return Toolbars::ToolbarPtr(Tb);
+ return Toolbars::ToolbarPtr(toolBar);
+}
+
+
+WorkArea * GuiViewBase::workArea(Buffer & buffer)
+{
+ for (int i = 0; i != d.tab_widget_->count(); ++i) {
+ GuiWorkArea * wa = dynamic_cast<GuiWorkArea *>(d.tab_widget_->widget(i));
+ BOOST_ASSERT(wa);
+ if (&wa->bufferView().buffer() == &buffer)
+ return wa;
+ }
+ return 0;
+}
+
+
+WorkArea * GuiViewBase::addWorkArea(Buffer & buffer)
+{
+ GuiWorkArea * wa = new GuiWorkArea(buffer, *this);
+ wa->setUpdatesEnabled(false);
+ d.tab_widget_->addTab(wa, toqstr(makeDisplayPath(buffer.fileName(), 30)));
+ wa->bufferView().updateMetrics(false);
+ if (d.stack_widget_)
+ d.stack_widget_->setCurrentWidget(d.tab_widget_);
+ // Hide tabbar if there's only one tab.
+ d.tab_widget_->showBar(d.tab_widget_->count() > 1);
+ return wa;
+}
+
+
+WorkArea * GuiViewBase::currentWorkArea()
+{
+ if (d.tab_widget_->count() == 0)
+ return 0;
+ BOOST_ASSERT(dynamic_cast<GuiWorkArea *>(d.tab_widget_->currentWidget()));
+ return dynamic_cast<GuiWorkArea *>(d.tab_widget_->currentWidget());
+}
+
+
+WorkArea const * GuiViewBase::currentWorkArea() const
+{
+ if (d.tab_widget_->count() == 0)
+ return 0;
+ BOOST_ASSERT(dynamic_cast<GuiWorkArea const *>(d.tab_widget_->currentWidget()));
+ return dynamic_cast<GuiWorkArea const *>(d.tab_widget_->currentWidget());
+}
+
+
+void GuiViewBase::setCurrentWorkArea(WorkArea * work_area)
+{
+ BOOST_ASSERT(work_area);
+
+ // Changing work area can result from opening a file so
+ // update the toc in any case.
+ updateToc();
+
+ GuiWorkArea * wa = dynamic_cast<GuiWorkArea *>(work_area);
+ BOOST_ASSERT(wa);
+ if (wa != d.tab_widget_->currentWidget())
+ // Switch to the work area.
+ d.tab_widget_->setCurrentWidget(wa);
+ else
+ // Make sure the work area is up to date.
+ currentTabChanged(d.tab_widget_->currentIndex());
+ wa->setFocus();
+}
+
+
+void GuiViewBase::removeWorkArea(WorkArea * work_area)
+{
+ BOOST_ASSERT(work_area);
+ if (work_area == currentWorkArea()) {
+ disconnectBuffer();
+ disconnectBufferView();
+ }
+
+ // removing a work area often results from closing a file so
+ // update the toc in any case.
+ updateToc();
+
+ GuiWorkArea * gwa = dynamic_cast<GuiWorkArea *>(work_area);
+ gwa->setUpdatesEnabled(false);
+ BOOST_ASSERT(gwa);
+ int index = d.tab_widget_->indexOf(gwa);
+ d.tab_widget_->removeTab(index);
+
+ delete gwa;
+
+ if (d.tab_widget_->count()) {
+ // make sure the next work area is enabled.
+ d.tab_widget_->currentWidget()->setUpdatesEnabled(true);
+ // Hide tabbar if there's only one tab.
+ d.tab_widget_->showBar(d.tab_widget_->count() > 1);
+ return;
+ }
+
+ getDialogs().hideBufferDependent();
+ if (d.stack_widget_) {
+ // No more work area, switch to the background widget.
+ d.setBackground();
+ }
+}
+
+
+void GuiViewBase::showMiniBuffer(bool visible)
+{
+ Toolbar * t = toolbars_->display("minibuffer", visible);
+ if (t)
+ t->focusCommandBuffer();
+}
+
+
+void GuiViewBase::openMenu(docstring const & name)
+{
+ d.menubar_->openByName(name);
}
} // namespace frontend
projects / lyx.git / blobdiff