4 * This file is part of LyX, the document processor.
5 * Licence details can be found in the file COPYING.
7 * \author Lars Gullik Bjornes
9 * \author Abdelrazak Younes
10 * \author Peter Kümmel
12 * Full author contact details are available in file CREDITS.
18 #include "frontends/Delegates.h"
20 #include "support/strfwd.h"
22 #include <QMainWindow>
28 class QDragEnterEvent;
37 namespace support { class FileName; }
51 class GuiClickableLabel;
59 * GuiView - Qt main LyX window
61 * This class represents the main LyX window and provides
62 * accessor functions to its content.
64 * Note: a QObject emits a destroyed(QObject *) Qt signal when it
65 * is deleted. This might be useful for closing other dialogs
66 * depending on a given GuiView.
68 class GuiView : public QMainWindow, public GuiBufferViewDelegate,
69 public GuiBufferDelegate
74 /// create a main window of the given dimensions
79 /// closes the view such that the view knows that is closed
80 /// programmatically and not by the user clicking the x.
81 bool closeScheduled();
83 /// Things that need to be done when the OSes session manager
84 /// requests a log out.
85 bool prepareAllBuffersForLogout();
87 int id() const { return id_; }
92 /// Signal that the any "auto" minibuffer can be closed now.
93 void resetCommandExecute();
95 /// \name Generic accessor functions
97 /// The current BufferView refers to the BufferView that has the focus,
98 /// including for example the one that is created when you use the
99 /// advanced search and replace pane.
100 /// \return the currently selected buffer view.
101 BufferView * currentBufferView();
102 BufferView const * currentBufferView() const;
104 /// The document BufferView always refers to the view's main document
105 /// BufferView. So, even if the BufferView in e.g., the advanced
106 /// search and replace pane has the focus.
107 /// \return the current document buffer view.
108 BufferView * documentBufferView();
109 BufferView const * documentBufferView() const;
111 void newDocument(std::string const & filename,
112 std::string templatefile = std::string(),
113 bool fromTemplate = false);
115 /// display a message in the view
116 /// could be called from any thread
117 void message(docstring const &) override;
119 bool getStatus(FuncRequest const & cmd, FuncStatus & flag);
120 /// dispatch command.
121 /// \return true if the \c FuncRequest has been dispatched.
122 void dispatch(FuncRequest const & cmd, DispatchResult & dr);
125 /// Update the completion popup and the inline completion state.
126 /// If \c start is true, then a new completion might be started.
127 /// If \c keep is true, an active completion will be kept active
128 /// even though the cursor moved. The update flags of \c cur might
130 void updateCompletion(Cursor & cur, bool start, bool keep);
134 bool hasFocus() const;
137 void focusInEvent(QFocusEvent * e) override;
138 /// Add a Buffer to the View
139 /// \param b Buffer to set.
140 /// \param switch_to Whether to set it to the current workarea.
141 void setBuffer(Buffer * b, bool switch_to = true);
143 /// load a document into the current workarea.
144 Buffer * loadDocument(
145 support::FileName const & name, ///< File to load.
146 bool tolastfiles = true ///< append to the "Open recent" menu?
149 /// add toolbar, if newline==true, add a toolbar break before the toolbar
150 GuiToolbar * makeToolbar(ToolbarInfo const & tbinfo, bool newline);
151 void updateStatusBar();
153 /// updates the possible layouts selectable
154 void updateLayoutList();
155 void updateToolbars();
158 LayoutBox * getLayoutDialog() const;
160 /// hides the workarea and makes sure it is clean
161 bool hideWorkArea(GuiWorkArea * wa);
162 /// closes workarea; close buffer only if no other workareas point to it
163 bool closeWorkArea(GuiWorkArea * wa);
164 /// closes the buffer
165 bool closeBuffer(Buffer & buf);
167 void openDocuments(std::string const & filename, int origin);
169 void importDocument(std::string const &);
171 /// \name GuiBufferDelegate.
173 void resetAutosaveTimers() override;
174 // shows an error list
175 // if from_master is true, show master's error list
176 void errors(std::string const &, bool from_master = false) override;
177 void structureChanged() override;
178 void updateTocItem(std::string const &, DocIterator const &) override;
182 TocModels & tocModels();
184 /// called on timeout
187 /// check for external change of any opened buffer, mainly for svn usage
188 void checkExternallyModifiedBuffers();
190 /** redraw \c inset in all the BufferViews in which it is currently
191 * visible. If successful return a pointer to the owning Buffer.
193 Buffer const * updateInset(Inset const *);
195 /// \return the \c Workarea associated to \p Buffer
196 /// \retval 0 if no \c WorkArea is found.
197 GuiWorkArea * workArea(Buffer & buffer);
198 /// \return the \c Workarea at index \c index
199 GuiWorkArea * workArea(int index);
201 /// Add a \c WorkArea
202 /// \return the \c Workarea associated to \p Buffer
203 /// \retval 0 if no \c WorkArea is found.
204 GuiWorkArea * addWorkArea(Buffer & buffer);
205 /// \param work_area The current \c WorkArea, or \c NULL
206 void setCurrentWorkArea(GuiWorkArea * work_area);
208 void removeWorkArea(GuiWorkArea * work_area);
209 /// return true if \c wa is one of the visibles workareas of this view
210 bool hasVisibleWorkArea(GuiWorkArea * wa) const;
211 /// return the current WorkArea (the one that has the focus).
212 GuiWorkArea const * currentWorkArea() const;
213 /// return the current WorkArea (the one that has the focus).
214 GuiWorkArea * currentWorkArea();
216 /// return the current document WorkArea (it may not have the focus).
217 GuiWorkArea const * currentMainWorkArea() const;
218 /// return the current document WorkArea (it may not have the focus).
219 GuiWorkArea * currentMainWorkArea();
221 /// Current ratio between physical pixels and device-independent pixels
222 double pixelRatio() const;
224 static bool isBufferBusy(Buffer const * b);
228 void triggerShowDialog(QString const & qname, QString const & qdata, Inset * inset);
229 // emitted when the work area or its buffer view changed
230 void bufferViewChanged();
231 /// emitted when zoom is modified
232 void currentZoomChanged(int);
233 /// emitted when script is killed (e.g., user cancels export)
235 /// emitted when track changes status toggled
236 void changeTrackingToggled(bool);
240 void setBusy(bool) override;
242 /// clear any temporary message and replace with current status.
244 /// show documents stats in toolbar and trigger new iteration
247 void updateWindowTitle(GuiWorkArea * wa);
249 void disableShellEscape();
253 void resetWindowTitle();
255 void flatGroupBoxes(const QObject * object, bool flag);
258 void checkCancelBackground();
262 void zoomSliderMoved(int);
264 void zoomValueChanged(int);
266 void zoomInPressed();
268 void zoomOutPressed();
270 void showZoomContextMenu();
272 void showStatusBarContextMenu();
274 void on_currentWorkAreaChanged(GuiWorkArea *);
276 void onBufferViewChanged();
278 void on_lastWorkAreaRemoved();
280 /// For completion of autosave or export threads.
281 void processingThreadStarted();
282 void processingThreadFinished();
283 void autoSaveThreadFinished();
285 /// must be called in GUI thread
286 void doShowDialog(QString const & qname, QString const & qdata,
289 /// must be called from GUI thread
290 void updateStatusBarMessage(QString const & str);
291 void clearMessageText();
294 /// Open given child document in current buffer directory.
295 void openChildDocument(std::string const & filename);
296 /// Close current document buffer.
298 /// Close all document buffers.
299 bool closeBufferAll();
301 TabWorkArea * addTabWorkArea();
304 void scheduleRedrawWorkAreas();
306 /// connect to signals in the given BufferView
307 void connectBufferView(BufferView & bv);
308 /// disconnect from signals in the given BufferView
309 void disconnectBufferView();
310 /// connect to signals in the given buffer
311 void connectBuffer(Buffer & buf);
312 /// disconnect from signals in the given buffer
313 void disconnectBuffer();
315 void dragEnterEvent(QDragEnterEvent * ev) override;
317 void dropEvent(QDropEvent * ev) override;
318 /// make sure we quit cleanly
319 void closeEvent(QCloseEvent * e) override;
321 void showEvent(QShowEvent *) override;
323 /// in order to catch Tab key press.
324 bool event(QEvent * e) override;
325 bool focusNextPrevChild(bool) override;
328 bool goToFileRow(std::string const & argument);
331 class GuiViewPrivate;
336 /// dialogs for this view
342 /// Hide all visible dialogs
343 void hideAll() const;
345 /// Update all visible dialogs.
347 * Check the status of all visible dialogs and disable or re-enable
348 * them as appropriate.
350 * Disabling is needed for example when a dialog is open and the
351 * cursor moves to a position where the corresponding inset is not
354 void updateDialogs();
356 /** Show dialog could be called from arbitrary threads.
357 \param name == "bibtex", "citation" etc; an identifier used to
358 launch a particular dialog.
359 \param data is a string representation of the Inset contents.
360 It is often little more than the output from Inset::write.
361 It is passed to, and parsed by, the frontend dialog.
362 Several of these dialogs do not need any data,
363 so it defaults to string().
364 \param inset ownership is _not_ passed to the frontend dialog.
365 It is stored internally and used by the kernel to ascertain
366 what to do with the FuncRequest dispatched from the frontend
367 dialog on 'Apply'; should it be used to create a new inset at
368 the current cursor position or modify an existing, 'open' inset?
370 void showDialog(std::string const & name,
371 std::string const & data, Inset * inset = 0) override;
373 /** \param name == "citation", "bibtex" etc; an identifier used
374 to reset the contents of a particular dialog with \param data.
375 See the comments to 'show', above.
377 void updateDialog(std::string const & name, std::string const & data) override;
379 /** All Dialogs of the given \param name will be closed if they are
380 connected to the given \param inset.
382 void hideDialog(std::string const & name, Inset * inset);
384 void disconnectDialog(std::string const & name);
386 bool develMode() const { return devel_mode_; }
388 void setCurrentZoom(int const v);
391 /// Saves the layout and geometry of the window
392 void saveLayout() const;
393 /// Saves the settings of toolbars and all dialogs
394 void saveUISettings() const;
396 bool restoreLayout();
398 GuiToolbar * toolbar(std::string const & name);
400 void constructToolbars();
404 void initToolbar(std::string const & name);
405 /// Update lock (all) toolbars position
406 void updateLockToolbars();
407 /// refill the toolbars (dark/light mode switch)
408 void refillToolbars();
410 bool lfunUiToggle(std::string const & ui_component);
412 /// kill the script and hide export-in-progress status bar icons
415 void toggleFullScreen();
416 /// \return whether we did anything
417 bool insertLyXFile(docstring const & fname, bool ignorelang = false);
419 /// Open Export As ... dialog. \p iformat is the format the
420 /// filter is initially set to.
421 bool exportBufferAs(Buffer & b, docstring const & iformat);
426 LV_WRITE_AS_TEMPLATE,
430 /// Get a path for LFUN_BUFFER_WRITE_AS_TEMPLATE
431 std::string const getTemplatesPath(Buffer & buf);
432 /// Save a buffer as a new file.
434 * Write a buffer to a new file name and rename the buffer
435 * according to the new file name.
437 * This function is e.g. used by menu callbacks and
438 * LFUN_BUFFER_WRITE_AS.
440 * If 'newname' is empty, the user is asked via a
441 * dialog for the buffer's new name and location.
443 * If 'newname' is non-empty and has an absolute path, that is used.
444 * Otherwise the base directory of the buffer is used as the base
445 * for any relative path in 'newname'.
447 * \p kind controls what is done besides the pure renaming:
448 * LV_WRITE_AS => The buffer is written without version control actions.
449 * LV_VC_RENAME => The file is renamed in version control.
450 * LV_VC_COPY => The file is copied in version control.
452 bool renameBuffer(Buffer & b, docstring const & newname,
453 RenameKind kind = LV_WRITE_AS);
455 bool saveBuffer(Buffer & b);
456 /// save and rename buffer to fn. If fn is empty, the buffer
457 /// is just saved as the filename it already has.
458 bool saveBuffer(Buffer & b, support::FileName const & fn);
459 /// closes a workarea, if close_buffer is true the buffer will
460 /// also be released, otherwise the buffer will be hidden.
461 bool closeWorkArea(GuiWorkArea * wa, bool close_buffer);
462 /// closes the tabworkarea and all tabs. If we are in a close event,
463 /// all buffers will be closed, otherwise they will be hidden.
464 bool closeTabWorkArea(TabWorkArea * twa);
465 /// gives the user the possibility to save their work
466 /// or to discard the changes. If hiding is true, the
467 /// document will be reloaded.
468 bool saveBufferIfNeeded(Buffer & buf, bool hiding);
469 /// closes all workareas
470 bool closeWorkAreaAll();
471 /// write all open workareas into the session file
472 void writeSession() const;
473 /// is the buffer in this workarea also shown in another tab ?
474 /// This tab can either be in the same view or in another one.
475 bool inMultiTabs(GuiWorkArea * wa);
476 /// is the buffer shown in some other view ?
477 bool inOtherView(Buffer & buf);
479 enum NextOrPrevious {
484 void gotoNextOrPreviousBuffer(NextOrPrevious np, bool const move);
486 void gotoNextTabWorkArea(NextOrPrevious np);
488 /// Is the dialog currently visible?
489 bool isDialogVisible(std::string const & name) const;
491 Dialog * find(std::string const & name, bool hide_it) const;
493 Dialog * findOrBuild(std::string const & name, bool hide_it);
495 Dialog * build(std::string const & name);
497 bool reloadBuffer(Buffer & buffer);
499 void dispatchVC(FuncRequest const & cmd, DispatchResult & dr);
501 void dispatchToBufferView(FuncRequest const & cmd, DispatchResult & dr);
504 /// Check whether any of the stats is enabled in status bar
505 bool statsEnabled() const;
510 /// flag to avoid two concurrent close events.
512 /// if the view is busy the cursor shouldn't blink for instance.
513 /// This counts the number of times more often we called
514 /// setBusy(true) compared to setBusy(false), so we can nest
515 /// functions that call setBusy;
518 /// Request to open the command toolbar if it is "auto"
519 bool command_execute_;
520 /// Request to give focus to minibuffer
521 bool minibuffer_focus_;
523 /// Statusbar widget that shows shell-escape status
524 QLabel * shell_escape_;
525 /// Statusbar widget that shows read-only status
527 /// Statusbar widget that shows version control status
528 QLabel * version_control_;
529 /// Statusbar widget that document count statistics
530 QLabel * stat_counts_;
531 /// Word count info feature can be disabled by context menu
532 bool word_count_enabled_;
533 /// Char count info feature can be disabled by context menu
534 bool char_count_enabled_;
535 /// Char count info feature can be disabled by context menu
536 /// This excludes blanks
537 bool char_nb_count_enabled_;
538 /// Statusbar widget that shows zoom value
539 GuiClickableLabel * zoom_value_;
541 QWidget * zoom_widget_;
542 /// The zoom slider widget
543 QSlider * zoom_slider_;
544 /// Zoom in ("+") Button
545 GuiClickableLabel * zoom_in_;
546 /// Zoom out ("-") Button
547 GuiClickableLabel * zoom_out_;
549 /// The rate from which the actual zoom value is calculated
550 /// from the default zoom pref
551 double zoom_ratio_ = 1.0;
552 /// Minimum zoom percentage
553 int const zoom_min_ = 10;
554 /// Maximum zoom percentage
555 int const zoom_max_ = 1000;
557 // movability flag of all toolbars
558 bool toolbarsMovable_;
563 // initial zoom for pinch gesture
568 class SEMenu : public QMenu
572 explicit SEMenu(QWidget * parent);
575 void showMenu(QPoint const &) { exec(QCursor::pos()); }
579 class PressableSvgWidget : public QSvgWidget
583 explicit PressableSvgWidget(const QString &file, QWidget * parent = nullptr)
584 : QSvgWidget(file, parent) {};
586 void mousePressEvent(QMouseEvent *event) override;
591 } // namespace frontend