X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FBufferView.h;h=bfd523aa5705c353b301aede43566fba8adba3de;hb=26ba2a65838731ce639a09539f617cb0f0be3b22;hp=2481c286ba771d2696d41cb0f361e33def8e83f7;hpb=1b5f5e58ed43aeca64ad11af6a493a49699d1b2e;p=lyx.git diff --git a/src/BufferView.h b/src/BufferView.h index 2481c286ba..bfd523aa57 100644 --- a/src/BufferView.h +++ b/src/BufferView.h @@ -5,9 +5,9 @@ * Licence details can be found in the file COPYING. * * \author Alfredo Braustein - * \author Lars Gullik Bjønnes + * \author Lars Gullik Bjønnes * \author John Levon - * \author Jürgen Vigna + * \author Jürgen Vigna * * Full author contact details are available in file CREDITS. */ @@ -15,272 +15,464 @@ #ifndef BUFFER_VIEW_H #define BUFFER_VIEW_H -#include "cursor.h" -#include "metricsinfo.h" +#include "CoordCache.h" +#include "DocumentClassPtr.h" +#include "TexRow.h" +#include "update_flags.h" +#include "support/strfwd.h" #include "support/types.h" -#include -#include +namespace lyx { -#include +namespace support { class FileName; } + +namespace frontend { struct CaretGeometry; } +namespace frontend { class Painter; } +namespace frontend { class GuiBufferViewDelegate; } class Buffer; class Change; +class Cursor; +class CursorSlice; +class Dimension; +class DispatchResult; class DocIterator; class FuncRequest; class FuncStatus; class Intl; -class Language; -class LCursor; -class LyXText; -class ParIterator; -class ViewMetricsInfo; - -namespace Update { - enum flags { - FitCursor = 1, - Force = 2, - SinglePar = 4, - MultiParSel = 8 - }; - -inline flags operator|(flags const f, flags const g) -{ - return static_cast(int(f) | int(g)); -} - -inline flags operator&(flags const f, flags const g) -{ - return static_cast(int(f) & int(g)); -} +class Inset; +class InsetMathNest; +class Length; +class MathData; +class MathRow; +class ParagraphMetrics; +class Point; +class Text; +class TextMetrics; + +enum CursorStatus { + CUR_INSIDE, + CUR_ABOVE, + CUR_BELOW +}; -} // namespace +/// How to show cursor +enum ScrollType { + // Make sure row if visible (do nothing if it is visible already) + SCROLL_VISIBLE, + // Force cursor to be on top of screen + SCROLL_TOP, + // Force cursor to be at center of screen + SCROLL_CENTER +}; -/// Scrollbar Parameters +/// Scrollbar Parameters. struct ScrollbarParameters { - void reset(int h = 0, int p = 0, int l = 0) - { - height = h; - position = p; - lineScrollHeight = l; - } - - /// The total document height in pixels - int height; - /// The current position in the document, in pixels - int position; - /// the line-scroll amount, in pixels - int lineScrollHeight; + // These parameters are normalized against the screen geometry and pixel + // coordinates. Position 0 corresponds to the top the the screen. + ScrollbarParameters() + : min(0), max(0), single_step(1), page_step(1) + {} + /// Minimum scrollbar position in pixels. + int min; + /// Maximum scrollbar position in pixels. + int max; + /// Line-scroll amount in pixels. + int single_step; + /// Page-scroll amount in pixels. + int page_step; }; +/// Screen view of a Buffer. /** - * A buffer view encapsulates a view onto a particular + * A BufferView encapsulates a view onto a particular * buffer, and allows access to operate upon it. A view * is a sliding window of the entire document rendering. + * It is the official interface between the LyX core and + * the frontend WorkArea. * - * Eventually we will allow several views onto a single - * buffer, but not yet. + * \sa WorkArea + * \sa Buffer + * \sa CoordCache */ -class BufferView : boost::noncopyable { +class BufferView { public: - BufferView(); - + /// + explicit BufferView(Buffer & buffer); + /// ~BufferView(); - /// set the buffer we are viewing - void setBuffer(Buffer * b); - /// return the buffer being viewed - Buffer * buffer() const; - - /// resize event has happened - void resize(); + /// return the buffer being viewed. + Buffer & buffer(); + Buffer const & buffer() const; - /// reload the contained buffer - void reload(); - /// load a buffer into the view - bool loadLyXFile(std::string const & name, bool tolastfiles = true); + /// Copy cursor and vertical offset information from \c bv + void copySettingsFrom(BufferView const & bv); - /** perform pending painting updates. \c fitcursor means first - * to do a fitcursor, and to force an update if screen - * position changes. \c forceupdate means to force an update - * in any case. - * \return true if a full updateMetrics() is needed. + /// + void setFullScreen(bool full_screen) { full_screen_ = full_screen; } + + /// default value for the margins + int defaultMargin() const; + /// right margin + int rightMargin() const; + /// left margin + int leftMargin() const; + /// top margin + int topMargin() const; + /// bottom margin + int bottomMargin() const; + + docstring const & searchRequestCache() const; + void setSearchRequestCache(docstring const & text); + + /// return the on-screen size of this length + /* + * This is a wrapper around Length::inPixels that uses the + * bufferview width as width and the EM value of the default + * document font. */ - bool update(Update::flags flags = Update::FitCursor | Update::Force); - - /// move the screen to fit the cursor. Only to be called with - /// good y coordinates (after a bv::metrics) - bool fitCursor(); - /// reset the scrollbar to reflect current view position - void updateScrollbar(); - /// return the Scrollbar Parameters - ScrollbarParameters const & scrollbarParameters() const; - - /// Save the current position as bookmark i - void savePosition(unsigned int i); - /// Restore the position from bookmark i - void restorePosition(unsigned int i); - /// does the given bookmark have a saved position ? - bool isSavedPosition(unsigned int i); - /// save bookmarks to .lyx/session - void saveSavedPositions(); - - /// return the current change at the cursor - Change const getCurrentChange() const; + int inPixels(Length const & len) const; - /// return the lyxtext we are using - LyXText * getLyXText(); + /** Return the number of pixels equivalent to \c pix pixels at + * 100dpi and 100% zoom. + */ + int zoomedPixels(int pix) const; - /// return the lyxtext we are using - LyXText const * getLyXText() const; + /// \return true if the BufferView is at the top of the document. + bool isTopScreen() const; - /// move cursor to the named label - void gotoLabel(std::string const & label); + /// \return true if the BufferView is at the bottom of the document. + bool isBottomScreen() const; - /// set the cursor based on the given TeX source row - void setCursorFromRow(int row); + /// Add \p flags to current update flags and trigger an update. + /* If this method is invoked several times before the update + * actually takes place, the effect is cumulative. + * \c Update::FitCursor means first to do a FitCursor, and to + * force an update if screen position changes. + * \c Update::Force means to force an update in any case. + */ + void processUpdateFlags(Update::flags flags); + + /// return true if one shall move the screen to fit the cursor. + /// Only to be called with good y coordinates (after a bv::metrics) + bool needsFitCursor() const; + + // Returns the amount of horizontal scrolling applied to the + // top-level row where the cursor lies + int horizScrollOffset() const; + // Returns the amount of horizontal scrolling applied to the + // row of text starting at (pit, pos) + int horizScrollOffset(Text const * text, + pit_type pit, pos_type pos) const; + + /// reset the scrollbar parameters to reflect current view position. + void updateScrollbarParameters(); + /// return the Scrollbar Parameters. + ScrollbarParameters const & scrollbarParameters() const; + /// \return Tool tip for the given position. + docstring toolTip(int x, int y) const; + /// \return the context menu for the given position. + std::string contextMenu(int x, int y) const; + /// \return the math inset with a context menu for the given position + Inset const * mathContextMenu(InsetMathNest const * inset, + CoordCache::Insets const & inset_cache, int x, int y) const; + /// \return the clickable math inset for the given position + Inset const * clickableMathInset(InsetMathNest const * inset, + CoordCache::Insets const & inset_cache, int x, int y) const; + + /// Save the current position as bookmark. + /// if idx == 0, save to temp_bookmark + void saveBookmark(unsigned int idx); + /// goto a specified position, try top_id first, and then bottom_pit. + /// \return true if success + bool moveToPosition( + pit_type bottom_pit, ///< Paragraph pit, used when par_id is zero or invalid. + pos_type bottom_pos, ///< Paragraph pit, used when par_id is zero or invalid. + int top_id, ///< Paragraph ID, \sa Paragraph + pos_type top_pos ///< Position in the \c Paragraph + ); + /// return the current change at the cursor. + Change const getCurrentChange() const; - /// center the document view around the cursor - void center(); - /// scroll document by the given number of lines of default height - void scroll(int lines); - /// Scroll the view by a number of pixels - void scrollDocView(int pixels); + /// move cursor to the named label. + void gotoLabel(docstring const & label); + + /// set the cursor based on the given TeX source row. + bool setCursorFromRow(int row); + /// set the cursor based on the given start and end TextEntries. + bool setCursorFromEntries(TexRow::TextEntry start, TexRow::TextEntry end); + + /// set cursor to the given inset. Return true if found. + bool setCursorFromInset(Inset const *); + /// Recenters the BufferView such that the passed cursor + /// is in the center. + void recenter(); + /// Ensure that the BufferView cursor is visible. + /// This method will automatically scroll and update the BufferView + /// (metrics+drawing) if needed. + void showCursor(); + + /// Ensure the passed cursor \p dit is visible. + /// This method will automatically scroll and update the BufferView + /// (metrics+drawing) if needed. + /// \param how Use this scroll strategy + /// \param force If true, update screen after scrolling + void showCursor(DocIterator const & dit, ScrollType how, bool update); + /// Scroll to the cursor. + /// \param how Use this scroll strategy + /// \return true if screen was scrolled + bool scrollToCursor(DocIterator const & dit, ScrollType how); + /// scroll down document by the given number of pixels. + int scrollDown(int pixels); + /// scroll up document by the given number of pixels. + int scrollUp(int pixels); + /// scroll document by the given number of pixels. + int scroll(int pixels); + /// Scroll the view by a number of pixels. + void scrollDocView(int pixels, bool update); /// Set the cursor position based on the scrollbar one. void setCursorFromScrollbar(); - /// return the pixel width of the document view + /// return the pixel width of the document view. int workWidth() const; - /// return the pixel height of the document view + /// return the pixel height of the document view. int workHeight() const; - /// switch between primary and secondary keymaps for RTL entry - void switchKeyMap(); - - /// return true for events that will handle - FuncStatus getStatus(FuncRequest const & cmd); - /// execute the given function - bool dispatch(FuncRequest const & argument); - - /// - lyx::docstring const requestSelection(); - /// + /// return the inline completion postfix. + docstring const & inlineCompletion() const; + /// return the number of unique characters in the inline completion. + size_t inlineCompletionUniqueChars() const; + /// return the position in the buffer of the inline completion postfix. + DocIterator const & inlineCompletionPos() const; + /// make sure inline completion position is OK + void resetInlineCompletionPos(); + /// set the inline completion postfix and its position in the buffer. + /// Updates the updateFlags in \c cur. + void setInlineCompletion(Cursor const & cur, DocIterator const & pos, + docstring const & completion, size_t uniqueChars = 0); + + /// translate and insert a character, using the correct keymap. + void translateAndInsert(char_type c, Text * t, Cursor & cur); + + /// \return true if we've made a decision + bool getStatus(FuncRequest const & cmd, FuncStatus & flag); + /// execute the given function. + void dispatch(FuncRequest const & cmd, DispatchResult & dr); + + /// request an X11 selection. + /// \return the selected string. + docstring requestSelection(); + /// clear the X11 selection. void clearSelection(); - /// - void workAreaResize(int width, int height); - - /// a function should be executed from the workarea - bool workAreaDispatch(FuncRequest const & ev); + /// resize the BufferView. + /// \sa WorkArea + void resize(int width, int height); - /// access to anchor - lyx::pit_type anchor_ref() const; + /// dispatch method helper for \c WorkArea + /// \sa WorkArea + void mouseEventDispatch(FuncRequest const & ev); - /// access to full cursor - LCursor & cursor(); - /// access to full cursor - LCursor const & cursor() const; - /// sets cursor and open all relevant collapsable insets. + /// + CursorStatus cursorStatus(DocIterator const & dit) const; + /// access to full cursor. + Cursor & cursor(); + /// access to full cursor. + Cursor const & cursor() const; + /// sets cursor. + /// This will also open all relevant collapsible insets. void setCursor(DocIterator const &); - /// sets cursor; this is used when handling LFUN_MOUSE_PRESS. - void mouseSetCursor(LCursor & cur); - - /* Sets the selection. When \c backwards == false, set anchor + /// set the selection up to dit. + void setCursorSelectionTo(DocIterator const & dit); + /// Check deleteEmptyParagraphMechanism and update metrics if needed. + /// \retval true if an update was needed. + bool checkDepm(Cursor & cur, Cursor & old); + /// sets cursor. + /// This is used when handling LFUN_MOUSE_PRESS. + bool mouseSetCursor(Cursor & cur, bool select = false); + + /// sets the selection. + /* When \c backwards == false, set anchor * to \c cur and cursor to \c cur + \c length. When \c * backwards == true, set anchor to \c cur and cursor to \c * cur + \c length. */ void putSelectionAt(DocIterator const & cur, int length, bool backwards); + /// set a selection between \p from and \p to + void setSelection(DocIterator const & from, + DocIterator const & to); + + /// selects the item at cursor if its paragraph is empty. + bool selectIfEmpty(DocIterator & cur); + + /// Ditch all metrics information and rebuild it. Set the update + /// flags and the draw strategy flags accordingly. + void updateMetrics(); + + // this is the "nodraw" drawing stage: only set the positions of the + // insets in metrics cache. + void updatePosCache(); + + /// + TextMetrics const & textMetrics(Text const * t) const; + TextMetrics & textMetrics(Text const * t); + /// + ParagraphMetrics const & parMetrics(Text const *, pit_type) const; + + /// + CoordCache & coordCache(); + /// + CoordCache const & coordCache() const; + + /// + bool hasMathRow(MathData const * cell) const; /// - ViewMetricsInfo const & viewMetricsInfo(); + MathRow const & mathRow(MathData const * cell) const; /// - void updateMetrics(bool singlepar = false); + void setMathRow(MathData const * cell, MathRow const & mrow); - /// get this view's keyboard map handler - Intl & getIntl() { return *intl_.get(); } /// - Intl const & getIntl() const { return *intl_.get(); } + Point getPos(DocIterator const & dit) const; + /// is the paragraph of the cursor visible ? + bool paragraphVisible(DocIterator const & dit) const; + /// is the caret currently visible in the view + bool caretInView() const; + /// get the position and height of the caret + void caretPosAndDim(Point & p, Dimension & dim) const; + /// compute the shape of the caret + void buildCaretGeometry(bool complet); + /// the shape of the caret + frontend::CaretGeometry const & caretGeometry() const; + + /// Returns true when metrics have been computed at least once + bool ready() const { return width_ > 0 && height_ > 0; } + /// Returns true when the BufferView is not ready for drawing + bool busy() const; + /// + void draw(frontend::Painter & pain, bool paint_caret); + /// get this view's keyboard map handler. + Intl & getIntl(); + /// + Intl const & getIntl() const; + + // + // Messages to the GUI + // /// This signal is emitted when some message shows up. - boost::signal message; + void message(docstring const & msg); /// This signal is emitted when some dialog needs to be shown. - boost::signal showDialog; + void showDialog(std::string const & name); /// This signal is emitted when some dialog needs to be shown with - /// some data - boost::signal showDialogWithData; - - /// This signal is emitted when some inset dialogs needs to be shown. - boost::signal showInsetDialog; + /// some data. + void showDialog(std::string const & name, std::string const & data, + Inset * inset = nullptr); /// This signal is emitted when some dialogs needs to be updated. - boost::signal updateDialog; - - /// This signal is emitted when the layout at the cursor is changed. - boost::signal layoutChanged; + void updateDialog(std::string const & name, std::string const & data); -private: /// - bool multiParSel(); + void setGuiDelegate(frontend::GuiBufferViewDelegate *); + /// - int width_; + docstring contentsOfPlaintextFile(support::FileName const & f); + // Insert plain text file (if filename is empty, prompt for one) + void insertPlaintextFile(support::FileName const & f, bool asParagraph); /// - int height_; + void insertLyXFile(support::FileName const & f, bool const ignorelang = false); + /// save temporary bookmark for jump back navigation + void bookmarkEditPosition(); + /// Find and return the inset associated with given dialog name. + Inset * editedInset(std::string const & name) const; + /// Associate an inset associated with given dialog name. + void editInset(std::string const & name, Inset * inset); /// - ScrollbarParameters scrollbarParameters_; - + void clearLastInset(Inset * inset) const; + /// Is the mouse hovering a clickable inset or element? + bool clickableInset() const; /// - ViewMetricsInfo metrics_info_; + void makeDocumentClass(); + /// Are we currently performing a selection with the mouse? + bool mouseSelecting() const; + + /// Reference value for statistics (essentially subtract this from the actual value to see relative counts) + /// (words/chars/chars no blanks) + int stats_ref_value_w() const; + int stats_ref_value_c() const; + int stats_ref_value_nb() const; + //signals need for update in gui + bool stats_update_trigger(); - /// - Buffer * buffer_; +private: + /// noncopyable + BufferView(BufferView const &); + void operator=(BufferView const &); + + /// the position relative to (0, baseline) of outermost paragraph + Point coordOffset(DocIterator const & dit) const; + /// Update current paragraph metrics. + /// \return true if no further update is needed. + bool singleParUpdate(); + /** Helper for the public updateMetrics() and for processUpdateFlags() + * * When \c force is true, get rid of all paragraph metrics and + rebuild them anew. + * * When it is false, keep the paragraphs that are still visible in + * WorkArea and rebuild the missing ones. + * + * This does also set the anchor paragraph and its position correctly + */ + void updateMetrics(bool force); + + // Set the row on which the cursor lives. + void setCurrentRowSlice(CursorSlice const & rowSlice); + + // Check whether the row where the cursor lives needs to be scrolled. + // Update the drawing strategy if needed. + void checkCursorScrollOffset(); + + /// The minimal size of the document that is visible. Used + /// when it is allowed to scroll below the document. + int minVisiblePart(); + + /// Search recursively for the innermost inset that covers (x, y) position. + /// \retval 0 if no inset is found. + Inset const * getCoveringInset( + Text const & text, //< The Text where we start searching. + int x, //< x-coordinate on screen + int y //< y-coordinate on screen + ) const; + + /// Update the hovering status of the insets. This is called when + /// either the screen is updated or when the buffer has scolled. + void updateHoveredInset() const; - /// Estimated average par height for scrollbar - int wh_; /// - class Position { - public: - /// Filename - std::string filename; - /// Cursor paragraph Id - int par_id; - /// Cursor position - lyx::pos_type par_pos; - /// - Position() : par_id(0), par_pos(0) {} - /// - Position(std::string const & f, int id, lyx::pos_type pos) - : filename(f), par_id(id), par_pos(pos) {} - }; + void updateDocumentClass(DocumentClassConstPtr olddc); /// - std::vector saved_positions; - /// - void menuInsertLyXFile(std::string const & filen); - - /// this is used to handle XSelection events in the right manner - struct { - CursorSlice cursor; - CursorSlice anchor; - bool set; - } xsel_cache_; - /// - LCursor cursor_; + int width_; /// - bool multiparsel_cache_; + int height_; /// - lyx::pit_type anchor_ref_; + bool full_screen_; /// - int offset_ref_; + Buffer & buffer_; - /// keyboard mapping object - boost::scoped_ptr const intl_; + struct Private; + Private * const d; }; +/// some space for drawing the 'nested' markers (in pixel) +inline int nestMargin() { return 15; } + +/// margin for changebar +inline int changebarMargin() { return 12; } + +} // namespace lyx + #endif // BUFFERVIEW_H