src/frontends/qt4/GuiView.h

   1 // -*- C++ -*-
   2 /**
   3  * \file GuiView.h
   4  * This file is part of LyX, the document processor.
   5  * Licence details can be found in the file COPYING.
   6  *
   7  * \author Lars Gullik Bjornes
   8  * \author John Levon
   9  * \author Abdelrazak Younes
  10  * \author Peter Kümmel
  11  *
  12  * Full author contact details are available in file CREDITS.
  13  */
  14
  15 #ifndef GUI_VIEW_H
  16 #define GUI_VIEW_H
  17
  18 #include "frontends/Delegates.h"
  19 #include "frontends/LyXView.h"
  20
  21 #include "support/strfwd.h"
  22
  23 #include <QMainWindow>
  24
  25 class QCloseEvent;
  26 class QDragEnterEvent;
  27 class QDropEvent;
  28 class QMenu;
  29 class QShowEvent;
  30
  31
  32 namespace lyx {
  33
  34 class Cursor;
  35
  36 namespace frontend {
  37
  38 class Dialog;
  39 class LayoutBox;
  40 class GuiToolbar;
  41 class GuiWorkArea;
  42 class TabWorkArea;
  43 class TocModels;
  44 class ToolbarInfo;
  45
  46 /**
  47  * GuiView - Qt4 implementation of LyXView
  48  *
  49  * qt4-private implementation of the main LyX window.
  50  *
  51  * Note: a QObject emits a destroyed(QObject *) Qt signal when it
  52  * is deleted. This might be useful for closing other dialogs
  53  * depending on a given GuiView.
  54  */
  55 class GuiView : public QMainWindow, public LyXView, public GuiBufferViewDelegate,
  56         public GuiBufferDelegate
  57 {
  58         Q_OBJECT
  59 public:
  60         /// create a main window of the given dimensions
  61         GuiView(int id);
  62
  63         ~GuiView();
  64
  65         /// LyXView inherited methods.
  66         ///@{
  67         int id() const { return id_; };
  68         void setBusy(bool);
  69         BufferView * currentBufferView();
  70         BufferView const * currentBufferView() const;
  71         BufferView * documentBufferView();
  72         BufferView const * documentBufferView() const;
  73         void newDocument(std::string const & filename,
  74                 bool fromTemplate);
  75         void message(docstring const &);
  76         bool getStatus(FuncRequest const & cmd, FuncStatus & flag);
  77         bool dispatch(FuncRequest const & cmd);
  78         void restartCursor();
  79         void updateCompletion(Cursor & cur, bool start, bool keep);
  80         void setFocus();
  81         ///@}
  82
  83         /// set a buffer to the current workarea.
  84         void setBuffer(Buffer * b); ///< \c Buffer to set.
  85
  86         /// load a document into the current workarea.
  87         Buffer * loadDocument(
  88                 support::FileName const &  name, ///< File to load.
  89                 bool tolastfiles = true  ///< append to the "Open recent" menu?
  90                 );
  91
  92         /// add toolbar, if newline==true, add a toolbar break before the toolbar
  93         GuiToolbar * makeToolbar(ToolbarInfo const & tbinfo, bool newline);
  94         void updateStatusBar();
  95
  96         /// updates the possible layouts selectable
  97         void updateLayoutList();
  98         void updateToolbars();
  99         QMenu * createPopupMenu();
 100
 101         ///
 102         LayoutBox * getLayoutDialog() const;
 103
 104         /// hides the workarea and makes sure it is clean
 105         bool hideWorkArea(GuiWorkArea * wa);
 106         /// closes the workarea
 107         bool closeWorkArea(GuiWorkArea * wa);
 108         /// closes the buffer
 109         bool closeBuffer(Buffer & buf);
 110         ///
 111         void openDocument(std::string const & filename);
 112         ///
 113         void importDocument(std::string const &);
 114
 115         /// GuiBufferDelegate.
 116         ///@{
 117         void resetAutosaveTimers();
 118         void errors(std::string const &, bool from_master = false);
 119         void structureChanged();
 120         void updateTocItem(std::string const &, DocIterator const &);
 121         ///@}
 122
 123         ///
 124         TocModels & tocModels();
 125
 126         /// called on timeout
 127         void autoSave();
 128
 129         /** redraw \c inset in all the BufferViews in which it is currently
 130          *  visible. If successful return a pointer to the owning Buffer.
 131          */
 132         Buffer const * updateInset(Inset const *);
 133
 134         /// \return the \c Workarea associated to \p  Buffer
 135         /// \retval 0 if no \c WorkArea is found.
 136         GuiWorkArea * workArea(Buffer & buffer);
 137
 138         /// Add a \c WorkArea
 139         /// \return the \c Workarea associated to \p  Buffer
 140         /// \retval 0 if no \c WorkArea is found.
 141         GuiWorkArea * addWorkArea(Buffer & buffer);
 142         /// \param work_area The current \c WorkArea, or \c NULL
 143         void setCurrentWorkArea(GuiWorkArea * work_area);
 144         ///
 145         void removeWorkArea(GuiWorkArea * work_area);
 146         /// return the current WorkArea (the one that has the focus).
 147         GuiWorkArea const * currentWorkArea() const;
 148         /// return the current WorkArea (the one that has the focus).
 149         GuiWorkArea * currentWorkArea();
 150
 151         /// return the current document WorkArea (it may not have the focus).
 152         GuiWorkArea const * currentMainWorkArea() const;
 153         /// return the current document WorkArea (it may not have the focus).
 154         GuiWorkArea * currentMainWorkArea();
 155
 156 Q_SIGNALS:
 157         void closing(int);
 158
 159 public Q_SLOTS:
 160         /// idle timeout.
 161         /// clear any temporary message and replace with current status.
 162         void clearMessage();
 163
 164 private Q_SLOTS:
 165         ///
 166         void updateWindowTitle(GuiWorkArea * wa);
 167         ///
 168         void resetWindowTitleAndIconText();
 169
 170         ///
 171         void on_currentWorkAreaChanged(GuiWorkArea *);
 172         ///
 173         void on_lastWorkAreaRemoved();
 174
 175         /// slots to change the icon size
 176         void smallSizedIcons();
 177         void normalSizedIcons();
 178         void bigSizedIcons();
 179
 180 private:
 181         /// Open given child document in current buffer directory.
 182         void openChildDocument(std::string const & filename);
 183         /// Close current document buffer.
 184         bool closeBuffer();
 185         /// Close all document buffers.
 186         bool closeBufferAll();
 187         ///
 188         TabWorkArea * addTabWorkArea();
 189
 190         /// connect to signals in the given BufferView
 191         void connectBufferView(BufferView & bv);
 192         /// disconnect from signals in the given BufferView
 193         void disconnectBufferView();
 194         /// connect to signals in the given buffer
 195         void connectBuffer(Buffer & buf);
 196         /// disconnect from signals in the given buffer
 197         void disconnectBuffer();
 198         ///
 199         void dragEnterEvent(QDragEnterEvent * ev);
 200         ///
 201         void dropEvent(QDropEvent * ev);
 202         /// make sure we quit cleanly
 203         void closeEvent(QCloseEvent * e);
 204         ///
 205         void showEvent(QShowEvent *);
 206
 207         /// in order to catch Tab key press.
 208         bool event(QEvent * e);
 209         bool focusNextPrevChild(bool);
 210
 211         ///
 212         bool goToFileRow(std::string const & argument);
 213
 214         ///
 215         struct GuiViewPrivate;
 216         GuiViewPrivate & d;
 217
 218 public:
 219         ///
 220         /// dialogs for this view
 221         ///
 222
 223         ///
 224         void resetDialogs();
 225
 226         /// Hide all visible dialogs
 227         void hideAll() const;
 228
 229         /// Update all visible dialogs.
 230         /**
 231          *  Check the status of all visible dialogs and disable or reenable
 232          *  them as appropriate.
 233          *
 234          *  Disabling is needed for example when a dialog is open and the
 235          *  cursor moves to a position where the corresponding inset is not
 236          *  allowed.
 237          */
 238         void updateDialogs();
 239
 240         /** \param name == "bibtex", "citation" etc; an identifier used to
 241             launch a particular dialog.
 242             \param data is a string representation of the Inset contents.
 243             It is often little more than the output from Inset::write.
 244             It is passed to, and parsed by, the frontend dialog.
 245             Several of these dialogs do not need any data,
 246             so it defaults to string().
 247             \param inset ownership is _not_ passed to the frontend dialog.
 248             It is stored internally and used by the kernel to ascertain
 249             what to do with the FuncRequest dispatched from the frontend
 250             dialog on 'Apply'; should it be used to create a new inset at
 251             the current cursor position or modify an existing, 'open' inset?
 252         */
 253         void showDialog(std::string const & name,
 254                 std::string const & data, Inset * inset = 0);
 255
 256         /** \param name == "citation", "bibtex" etc; an identifier used
 257             to reset the contents of a particular dialog with \param data.
 258             See the comments to 'show', above.
 259         */
 260         void updateDialog(std::string const & name, std::string const & data);
 261
 262         /** All Dialogs of the given \param name will be closed if they are
 263             connected to the given \param inset.
 264         */
 265         void hideDialog(std::string const & name, Inset * inset);
 266         ///
 267         void disconnectDialog(std::string const & name);
 268
 269 private:
 270         ///
 271         void saveLayout() const;
 272         ///
 273         bool restoreLayout();
 274         ///
 275         GuiToolbar * toolbar(std::string const & name);
 276         ///
 277         void constructToolbars();
 278         ///
 279         void initToolbars();
 280         ///
 281         void lfunUiToggle(FuncRequest const & cmd);
 282         ///
 283         void toggleFullScreen();
 284         ///
 285         void insertLyXFile(docstring const & fname);
 286         ///
 287         void insertPlaintextFile(docstring const & fname,
 288                 bool asParagraph);
 289
 290         /// Save a buffer as a new file.
 291         /**
 292         Write a buffer to a new file name and rename the buffer
 293     according to the new file name.
 294
 295     This function is e.g. used by menu callbacks and
 296     LFUN_BUFFER_WRITE_AS.
 297
 298     If 'newname' is empty, the user is asked via a
 299     dialog for the buffer's new name and location.
 300
 301     If 'newname' is non-empty and has an absolute path, that is used.
 302     Otherwise the base directory of the buffer is used as the base
 303     for any relative path in 'newname'.
 304         */
 305         bool renameBuffer(Buffer & b, docstring const & newname);
 306         ///
 307         bool saveBuffer(Buffer & b);
 308         /// closes a workarea, if close_buffer is true the buffer will
 309         /// also be released, otherwise the buffer will be hidden.
 310         bool closeWorkArea(GuiWorkArea * wa, bool close_buffer);
 311         /// closes the tabworkarea and all tabs. If we are in a close event,
 312         /// all buffers will be closed, otherwise they will be hidden.
 313         bool closeTabWorkArea(TabWorkArea * twa);
 314         /// gives the user the possibility to save his work
 315         /// or to discard the changes. If hiding is true, the
 316         /// document will be reloaded.
 317         bool saveBufferIfNeeded(Buffer & buf, bool hiding);
 318         /// closes all workareas
 319         bool closeWorkAreaAll();
 320         /// write all open workareas into the session file
 321         void writeSession() const;
 322         /// is the buffer in this workarea also shown in another tab ?
 323         /// This tab can either be in the same view or in another one.
 324         bool inMultiTabs(GuiWorkArea * wa);
 325         /// is the buffer in this workarea also shown in another view ?
 326         bool inMultiViews(GuiWorkArea * wa);
 327         ///
 328         enum NextOrPrevious {
 329                 NEXTBUFFER,
 330                 PREVBUFFER
 331         };
 332         ///
 333         void gotoNextOrPreviousBuffer(NextOrPrevious np);
 334
 335         /// Is the dialog currently visible?
 336         bool isDialogVisible(std::string const & name) const;
 337         ///
 338         Dialog * findOrBuild(std::string const & name, bool hide_it);
 339         ///
 340         Dialog * build(std::string const & name);
 341         ///
 342         void reloadBuffer();
 343         ///
 344         void dispatchVC(FuncRequest const & cmd);
 345         ///
 346         void showMessage();
 347
 348         /// This view ID.
 349         int id_;
 350
 351         /// flag to avoid two concurrent close events.
 352         bool closing_;
 353 };
 354
 355 } // namespace frontend
 356 } // namespace lyx
 357
 358 #endif // GUIVIEW_H