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