#include "InsetCode.h"
#include "support/strfwd.h"
+#include "support/types.h"
-#include <vector>
namespace lyx {
class BufferParams;
class BufferView;
class Change;
+class CompletionList;
class Cursor;
class CursorSlice;
class Dimension;
+class DocIterator;
class FuncRequest;
class FuncStatus;
class InsetCollapsable;
namespace graphics { class PreviewLoader; }
+/** returns the InsetCode corresponding to the \c name.
+* Eg, insetCode("branch") == BRANCH_CODE
+* Implemented in 'Inset.cpp'.
+*/
+InsetCode insetCode(std::string const & name);
+/// the other way
+std::string insetName(InsetCode);
+
/// Common base class to all insets
// Do not add _any_ (non-static) data members as this would inflate
/// virtual base class destructor
virtual ~Inset() {}
+ /// change associated Buffer
+ /// FIXME this should go.
+ virtual void setBuffer(Buffer & buffer);
+ /// retrieve associated Buffer
+ virtual Buffer & buffer();
+ virtual Buffer const & buffer() const;
+
+ /// initialize view for this inset.
+ /**
+ * This is typically used after this inset is created interactively.
+ * Intented purpose is to sanitize internal state with regard to current
+ * Buffer. The default implementation calls updateLabels(buffer()) is
+ * the inset is labeled.
+ *
+ * \sa isLabeled()
+ **/
+ virtual void initView();
+ /// \return true if this inset is labeled.
+ virtual bool isLabeled() const { return false; }
+
/// identification as math inset
virtual InsetMath * asInsetMath() { return 0; }
/// true for 'math' math inset, but not for e.g. mbox
virtual col_type col(idx_type) const { return 0; }
/// to which row belongs a cell with a given index?
virtual row_type row(idx_type) const { return 0; }
- /// cell idex corresponding to row and column;
+ /// cell index corresponding to row and column;
virtual idx_type index(row_type row, col_type col) const;
/// any additional x-offset when drawing a cell?
virtual int cellXOffset(idx_type) const { return 0; }
virtual size_t nrows() const { return 0; }
/// number of columns in gridlike structures
virtual size_t ncols() const { return 0; }
- /// is called when the cursor leaves this inset
- /// returns true if cursor is now invalid. The cursor parameter
- /// is _not_ necessarily pointing to the inset.
- virtual bool notifyCursorLeaves(Cursor &) { return false; }
+ /// Is called when the cursor leaves this inset.
+ /// Returns true if cursor is now invalid, e.g. if former
+ /// insets in higher cursor slices of \c old do not exist
+ /// anymore.
+ /// \c old is the old cursor, i.e. there is a slice pointing to this.
+ /// \c cur is the new cursor. Use the update flags to cause a redraw.
+ virtual bool notifyCursorLeaves(Cursor const & /*old*/, Cursor & /*cur*/)
+ { return false; }
/// is called when the mouse enter or leave this inset
/// return true if this inset needs repaint
virtual bool setMouseHover(bool) { return false; }
/// request "external features"
virtual void validate(LaTeXFeatures &) const {}
- /// Appends \c list with all labels found within this inset.
- virtual void getLabelList(Buffer const &,
- std::vector<docstring> & /* list */) const {}
/// describe content if cursor inside
virtual void infoize(odocstream &) const {}
/// describe content if cursor behind
virtual void infoize2(odocstream &) const {}
- enum {
- PLAINTEXT_NEWLINE = 10000
- };
+ enum { PLAINTEXT_NEWLINE = 10000 };
/// plain text output in ucs4 encoding
/// return the number of characters; in case of multiple lines of
/// output, add PLAINTEXT_NEWLINE to the number of chars in the last line
- virtual int plaintext(Buffer const &, odocstream &,
- OutputParams const &) const = 0;
+ virtual int plaintext(odocstream &, OutputParams const &) const = 0;
/// docbook output
- virtual int docbook(Buffer const &, odocstream & os,
- OutputParams const &) const;
+ virtual int docbook(odocstream & os, OutputParams const &) const;
/// the string that is passed to the TOC
- virtual void textString(Buffer const &, odocstream &) const {}
+ virtual void textString(odocstream &) const {}
/** This enum indicates by which means the inset can be modified:
- NOT_EDITABLE: the inset's content cannot be modified at all
HIGHLY_EDITABLE
};
/// what appears in the minibuffer when opening
- virtual docstring const editMessage() const;
+ virtual docstring editMessage() const;
///
virtual EDITABLE editable() const;
/// can we go further down on mouse click?
/// return true if the inset should be removed automatically
virtual bool autoDelete() const;
+ /// Returns true if the inset supports completions.
+ virtual bool completionSupported(Cursor const &) const { return false; }
+ /// Returns true if the inset supports inline completions at the
+ /// cursor position. In this case the completion might be stored
+ /// in the BufferView's inlineCompletion property.
+ virtual bool inlineCompletionSupported(Cursor const & /*cur*/) const
+ { return false; }
+ /// Return true if the inline completion should be automatic.
+ virtual bool automaticInlineCompletion() const { return true; }
+ /// Return true if the popup completion should be automatic.
+ virtual bool automaticPopupCompletion() const { return true; }
+ /// Return true if the cursor should indicate a completion.
+ virtual bool showCompletionCursor() const { return true; }
+ /// Returns completion suggestions at cursor position. Return an
+ /// null pointer if no completion is a available or possible.
+ /// The caller is responsible to free the returned object!
+ virtual CompletionList const * createCompletionList(Cursor const &) const
+ { return 0; }
+ /// Returns the completion prefix to filter the suggestions for completion.
+ /// This is only called if completionList returned a non-null list.
+ virtual docstring completionPrefix(Cursor const &) const;
+ /// Do a completion at the cursor position. Return true on success.
+ /// The completion does not contain the prefix. If finished is true, the
+ /// completion is final. If finished is false, completion might only be
+ /// a partial completion.
+ virtual bool insertCompletion(Cursor & /*cur*/,
+ docstring const & /*completion*/, bool /*finished*/)
+ { return false; }
+ /// Get the completion inset position and size
+ virtual void completionPosAndDim(Cursor const &, int & /*x*/, int & /*y*/,
+ Dimension & /*dim*/) const {}
+
/// returns true if the inset can hold an inset of given type
virtual bool insetAllowed(InsetCode) const { return false; }
/// should this inset use the empty layout by default rather than
virtual bool useEmptyLayout() const { return forceEmptyLayout(); }
/// if this inset has paragraphs should they be forced to use the
/// empty layout?
- virtual bool forceEmptyLayout() const { return false; }
+ virtual bool forceEmptyLayout(idx_type = 0) const { return false; }
/// if this inset has paragraphs should the user be allowed to
/// customize alignment, etc?
- virtual bool allowParagraphCustomization(idx_type) const { return true; }
+ virtual bool allowParagraphCustomization(idx_type = 0) const { return true; }
/// Is the width forced to some value?
virtual bool hasFixedWidth() const { return false; }
/// is this equivalent to a space (which is BTW different from
/// a line separator)?
virtual bool isSpace() const { return false; }
+ /// is this an expandible space (rubber length)?
+ virtual bool isStretchableSpace() const { return false; }
enum DisplayType {
Inline = 0,
/// should we break lines after this inset?
virtual bool isLineSeparator() const { return false; }
/// should paragraph indendation be ommitted in any case?
- virtual bool neverIndent(Buffer const &) const { return false; }
+ virtual bool neverIndent() const { return false; }
/// dumps content to lyxerr
virtual void dump() const;
/// write inset in .lyx format
- virtual void write(Buffer const &, std::ostream &) const {}
+ virtual void write(std::ostream &) const {}
/// read inset in .lyx format
- virtual void read(Buffer const &, Lexer &) {}
+ virtual void read(Lexer &) {}
/** Export the inset to LaTeX.
* Don't use a temporary stringstream if the final output is
* supposed to go to a file.
* \sa Buffer::writeLaTeXSource for the reason.
* \return the number of rows (\n's) of generated LaTeX code.
*/
- virtual int latex(Buffer const &, odocstream &,
- OutputParams const &) const { return 0; }
+ virtual int latex(odocstream &, OutputParams const &) const { return 0; }
/// returns true to override begin and end inset in file
virtual bool directWrite() const;
///
virtual void addPreview(graphics::PreviewLoader &) const {}
/// Add an entry to the TocList
/// pit is the ParConstIterator of the paragraph containing the inset
- virtual void addToToc(TocList &, Buffer const &, ParConstIterator const &) const {}
+ virtual void addToToc(ParConstIterator const &) const {}
/// report files that can be embedded with the lyx file
- virtual void registerEmbeddedFiles(Buffer const &, EmbeddedFileList &) const {}
- /// use embedded or external file after the embedding status of a file is changed
- virtual void updateEmbeddedFile(Buffer const &, EmbeddedFile const &) {}
+ virtual void registerEmbeddedFiles(EmbeddedFileList &) const {}
+ /// update the properties of an embedded file of an inset
+ /// the name of the embedded file should not change.
+ virtual void updateEmbeddedFile(EmbeddedFile const &) {}
/// Fill keys with BibTeX information
- virtual void fillWithBibKeys(Buffer const &,
- BiblioInfo &, InsetIterator const &) const {}
+ virtual void fillWithBibKeys(BiblioInfo &, InsetIterator const &) const {}
/// Update the counters of this inset and of its contents
- virtual void updateLabels(Buffer const &, ParIterator const &) {}
+ virtual void updateLabels(ParIterator const &) {}
/// Updates the inset's dialog
virtual Buffer const * updateFrontend() const;
enum { TEXT_TO_INSET_OFFSET = 4 };
protected:
- Inset() {}
+ /// Constructor
+ explicit Inset() : buffer_(0) {}
/// replicate ourselves
friend class InsetList;
* \sa getStatus
*/
virtual void doDispatch(Cursor & cur, FuncRequest & cmd);
+
+ Buffer * buffer_;
};
} // namespace lyx