#include "ColorCode.h"
#include "InsetCode.h"
-#include "Layout.h"
+#include "InsetLayout.h"
+#include "LayoutEnums.h"
+#include "OutputEnums.h"
#include "support/strfwd.h"
#include "support/types.h"
+#include <climits>
+
namespace lyx {
class Text;
class TocList;
class XHTMLStream;
+class otexstream;
namespace graphics { class PreviewLoader; }
-/** returns the InsetCode corresponding to the \c name.
-* Eg, insetCode("branch") == BRANCH_CODE
-* Implemented in 'Inset.cpp'.
-*/
+/// returns the InsetCode corresponding to the \c name.
+/// Eg, insetCode("branch") == BRANCH_CODE
InsetCode insetCode(std::string const & name);
-/// the other way
+/// returns the Inset name corresponding to the \c InsetCode.
+/// Eg, insetName(BRANCH_CODE) == "branch"
std::string insetName(InsetCode);
+/// returns the Inset name corresponding to the \c InsetCode.
+/// Eg, insetDisplayName(BRANCH_CODE) == _("Branch")
+docstring insetDisplayName(InsetCode);
+///
+static int const TOC_ENTRY_LENGTH = 120;
/// Common base class to all insets
enum EntryDirection {
ENTRY_DIRECTION_IGNORE,
ENTRY_DIRECTION_RIGHT,
- ENTRY_DIRECTION_LEFT,
+ ENTRY_DIRECTION_LEFT
};
///
typedef ptrdiff_t difference_type;
/// change associated Buffer
virtual void setBuffer(Buffer & buffer);
- /// remove the buffer reference
- void resetBuffer() { setBuffer( *static_cast<Buffer *>(0)); }
+ /// reset associated Buffer to null value
+ virtual void resetBuffer();
/// retrieve associated Buffer
virtual Buffer & buffer();
virtual Buffer const & buffer() const;
- /// This checks whether the Buffer * actually points to an open
- /// Buffer. It might not if that Buffer has been closed.
+ /// Returns true if buffer_ actually points to a Buffer that has
+ /// been loaded into LyX and is still open. Note that this will
+ /// always return false for cloned Buffers. If you want to allow
+ /// for the case of cloned Buffers, use isBufferValid().
+ bool isBufferLoaded() const;
+ /// Returns true if this is a loaded buffer or a cloned buffer.
bool isBufferValid() 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 buffer().updateLabels() if
- * the inset is labeled.
- *
- * \sa isLabeled()
+ * Buffer.
**/
- virtual void initView();
+ virtual void initView() {}
/// \return true if this inset is labeled.
virtual bool isLabeled() const { return false; }
virtual Inset * editXY(Cursor & cur, int x, int y);
/// compute the size of the object returned in dim
- /// \retval true if metrics changed.
virtual void metrics(MetricsInfo & mi, Dimension & dim) const = 0;
/// draw inset and update (xo, yo)-cache
virtual void draw(PainterInfo & pi, int x, int y) const = 0;
virtual void drawSelection(PainterInfo &, int, int) const {}
/// draw inset background if the inset has an own background and a
/// selection is drawn by drawSelection.
- virtual void drawBackground(PainterInfo &, int, int) const {}
+ virtual void drawBackground(PainterInfo &, int, int) const;
///
virtual bool editing(BufferView const * bv) const;
///
- virtual bool showInsetDialog(BufferView *) const { return false; }
+ virtual bool showInsetDialog(BufferView *) const;
- /// draw inset decoration if necessary.
- /// This can use \c drawMarkers() for example.
- virtual void drawDecoration(PainterInfo &, int, int) const {}
- /// draw four angular markers
- void drawMarkers(PainterInfo & pi, int x, int y) const;
+ // The possible marker types for insets
+ enum marker_type { NO_MARKER, MARKER2, MARKER };
/// draw two angular markers
+ void drawMarkers(PainterInfo & pi, int x, int y) const;
+ /// draw four angular markers
void drawMarkers2(PainterInfo & pi, int x, int y) const;
/// add space for markers
void metricsMarkers(Dimension & dim, int framesize = 1) const;
/// add space for markers
void metricsMarkers2(Dimension & dim, int framesize = 1) const;
+ /// draw inset decoration if necessary.
+ /// This can use \c drawMarkers() for example.
+ virtual void drawDecoration(PainterInfo &, int, int) const {}
+
+ /// last metrics computed for the inset
+ Dimension const dimension(BufferView const &) const;
/// last drawn position for 'important' insets
int xo(BufferView const & bv) const;
/// last drawn position for 'important' insets
int yo(BufferView const & bv) const;
- /// set x/y drawing position cache if available
- virtual void setPosCache(PainterInfo const &, int, int) const;
- ///
- void setDimCache(MetricsInfo const &, Dimension const &) const;
/// do we cover screen position x/y?
- virtual bool covers(BufferView const & bv, int x, int y) const;
+ bool covers(BufferView const & bv, int x, int y) const;
/// get the screen positions of the cursor (see note in Cursor.cpp)
virtual void cursorPos(BufferView const & bv,
CursorSlice const & sl, bool boundary, int & x, int & y) const;
virtual bool isFreeSpacing() const;
/// Don't eliminate empty paragraphs
virtual bool allowEmpty() const;
- /// Force inset into LTR environment if surroundings are RTL?
+ /// Force inset into LTR environment if surroundings are RTL
virtual bool forceLTR() const;
+ /// whether to include this inset in the strings generated for the TOC
+ virtual bool isInToc() const;
/// Where should we go when we press the up or down cursor key?
virtual bool idxUpDown(Cursor & cur, bool up) const;
virtual row_type row(idx_type) const { return 0; }
/// 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; }
- /// any additional y-offset when drawing a cell?
- virtual int cellYOffset(idx_type) const { return 0; }
/// number of embedded cells
virtual size_t nargs() const { return 0; }
/// number of rows in gridlike structures
/// Returns true if cursor is now invalid, e.g. if former
/// insets in higher cursor slices of \c old do not exist
/// anymore.
- /// \c cur is the new cursor, some slice points to this. Use the update flags to cause a redraw.
+ /// \c cur is the new cursor, some slice points to this. Use the update
+ /// flags to cause a redraw.
virtual bool notifyCursorEnters(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; }
+ /// is called when the mouse enters or leaves this inset
+ /// return true if this inset needs a repaint
+ virtual bool setMouseHover(BufferView const *, bool) const
+ { return false; }
/// return true if this inset is hovered (under mouse)
/// This is by now only used by mathed to draw corners
/// (Inset::drawMarkers() and Inset::drawMarkers2()).
/// Other insets do not have to redefine this function to
/// return the correct status of mouseHovered.
- virtual bool mouseHovered() const { return false; }
+ virtual bool mouseHovered(BufferView const *) const { return false; }
/// request "external features"
virtual void validate(LaTeXFeatures &) const {}
+ /// Validate LFUN_INSET_MODIFY argument.
+ virtual bool validateModifyArgument(docstring const &) const { return true; }
+
/// describe content if cursor inside
virtual void infoize(odocstream &) const {}
/// describe content if cursor behind
/// 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(odocstream &, OutputParams const &) const = 0;
+ virtual int plaintext(odocstringstream &, OutputParams const &,
+ size_t max_length = INT_MAX) const = 0;
/// docbook output
virtual int docbook(odocstream & os, OutputParams const &) const;
/// XHTML output
/// normal stream, and which will in fact be written after the current
/// paragraph closes. this is appropriate e.g. for floats.
virtual docstring xhtml(XHTMLStream & xs, OutputParams const &) const;
- /// the string that is passed to the TOC
- virtual void tocString(odocstream &) const {}
+
+ /// Writes a string representation of the inset to the odocstream.
+ /// This one should be called when you want the whole contents of
+ /// the inset.
+ virtual void toString(odocstream &) const {}
+ /// Appends a potentially abbreviated version of the inset to
+ /// \param str. Intended for use by the TOC.
+ virtual void forOutliner(docstring & str,
+ size_t const maxlen = TOC_ENTRY_LENGTH,
+ bool const shorten = true) const;
/// can the contents of the inset be edited on screen ?
// true for InsetCollapsables (not ButtonOnly) (not InsetInfo), InsetText
/// FIXME: merge with editable()
// true for InsetTabular & InsetText
virtual bool isActive() const { return nargs() > 0; }
+ /// can we click at the specified position ?
+ virtual bool clickable(BufferView const &, int, int) const { return false; }
+ /// Move one cell backwards
+ virtual bool allowsCaptionVariation(std::string const &) const { return false; }
+ // true for insets that have a table structure (InsetMathGrid, InsetTabular)
+ virtual bool isTable() const { return false; }
/// does this contain text that can be change track marked in DVI?
virtual bool canTrackChanges() const { return false; }
+ /// Will this inset paint its own change tracking status (in the parent
+ /// paragraph) or will it let RowPainter handle it?
+ virtual bool canPaintChange(BufferView const &) const { return false; }
/// return true if the inset should be removed automatically
virtual bool autoDelete() const;
virtual bool forcePlainLayout(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 = 0) 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; }
+ /// if this inset has paragraphs should they be forced to use a
+ /// local font language switch?
+ virtual bool forceLocalFontSwitch() const { return false; }
/// Is the content of this inset part of the output document?
virtual bool producesOutput() const { return true; }
+ /// Is the content of this inset part of the immediate (visible) text sequence?
+ virtual bool isPartOfTextSequence() const { return producesOutput(); }
/// \return Tool tip for this inset.
- /// This default implementation returns an empty string.
+ /// This default implementation returns an empty string. This can be
+ /// either plain text or Qt html, and formatToolTip will be called
+ /// on it before display in both cases.
virtual docstring toolTip(BufferView const & bv, int x, int y) const;
+ /// \return Context menu identifier. This function determines
+ /// whose Inset's menu should be shown for the given position.
+ virtual std::string contextMenu(BufferView const & bv, int x, int y) const;
+
/// \return Context menu identifier for this inset.
/// This default implementation returns an empty string.
- virtual docstring contextMenu(BufferView const & bv, int x, int y) const;
+ virtual std::string contextMenuName() const;
- // FIXME This should really disappear in favor of
- // docstring name() const { return from_ascii(insetName(lyxCode()))); }
- // There's no reason to be using different names in different places.
- // But to do this we would need to change the file format, since the names
- // used there don't correspond to what is used here.
- ///
- virtual docstring name() const;
+
+ virtual docstring layoutName() const;
///
virtual InsetLayout const & getLayout() const;
+ ///
+ virtual bool isPassThru() const { return getLayout().isPassThru(); }
/// Is this inset's layout defined in the document's textclass?
bool undefined() const;
- /// used to toggle insets
- /// is the inset open?
- /// should this inset be handled like a normal charater
+ /// should this inset be handled like a normal character?
+ /// (a character can be a letter or punctuation)
virtual bool isChar() const { return false; }
/// is this equivalent to a letter?
+ /// (a letter is a character that is considered part of a word)
virtual bool isLetter() 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; }
+ /// does this inset try to use all available space (like \\hfill does)?
+ virtual bool isHfill() const { return false; }
enum DisplayType {
Inline = 0,
* 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(odocstream &, OutputParams const &) const { return 0; }
+ virtual void latex(otexstream &, OutputParams const &) const {}
/// returns true to override begin and end inset in file
virtual bool directWrite() const;
///
virtual void initUnicodeMath() const {}
/// Add an entry to the TocList
- /// pit is the ParConstIterator of the paragraph containing the inset
- virtual void addToToc(DocIterator const &) {}
- /// Fill keys with BibTeX information
- virtual void fillWithBibKeys(BiblioInfo &, InsetIterator const &) const {}
+ /// Pass a DocIterator that points at the paragraph containing
+ /// the inset
+ ///
+ /// \param output_active : is the inset active or is it in an inactive
+ /// branch or a note?
+ ///
+ /// \param utype : is the toc being generated for use by the output
+ /// routines?
+ virtual void addToToc(DocIterator const & /* di */,
+ bool /* output_active */,
+ UpdateType /* utype*/) const {}
+ /// Collect BibTeX information
+ virtual void collectBibKeys(InsetIterator const &) const {}
/// Update the counters of this inset and of its contents.
/// The boolean indicates whether we are preparing for output, e.g.,
/// of XHTML.
- virtual void updateLabels(ParIterator const &, bool) {}
+ virtual void updateBuffer(ParIterator const &, UpdateType) {}
/// Updates the inset's dialog
virtual Buffer const * updateFrontend() const;
/// returns LyX code associated with the inset. Used for TOC, ...)
virtual InsetCode lyxCode() const { return NO_CODE; }
- /// -1: text mode, 1: math mode, 0 undecided
+ ///
enum mode_type {UNDECIDED_MODE, TEXT_MODE, MATH_MODE};
/// return text or mathmode if that is possible to determine
virtual mode_type currentMode() const { return UNDECIDED_MODE; }
/// returns whether changing mode during latex export is forbidden
virtual bool lockedMode() const { return false; }
+ /// returns whether only ascii chars are allowed during latex export
+ virtual bool asciiOnly() const { return false; }
/// returns whether this inset is allowed in other insets of given mode
virtual bool allowedIn(mode_type) const { return true; }
/**
- * Is this inset allowed within a font change?
- *
- * FIXME: noFontChange means currently that the font change is closed
- * in LaTeX before the inset, and that the contents of the inset
- * will be in default font. This should be changed so that the inset
- * changes the font again.
+ * The font is inherited from the parent for LaTeX export if this
+ * method returns true. No open font changes are closed in front of
+ * the inset for LaTeX export, and the font is inherited for all other
+ * exports as well as on screen.
+ * If this method returns false all open font changes are closed in
+ * front of the inset for LaTeX export. The default font is used
+ * inside the inset for all exports and on screen.
*/
- virtual bool noFontChange() const { return false; }
+ virtual bool inheritFont() const { return true; }
+ /**
+ * If this method returns true all explicitly set font attributes
+ * are reset during editing operations.
+ * For copy/paste operations the language is never changed, since
+ * the language of a given text never changes if the text is
+ * formatted differently, while other font attribues like size may
+ * need to change if the text is copied from one environment to
+ * another one.
+ * If this method returns false no font attribute is reset.
+ * The default implementation returns true if the resetFont layout
+ * tag is set and otherwise the negation of inheritFont(),
+ * since inherited inset font attributes do not need to be changed,
+ * and non-inherited ones need to be set explicitly.
+ */
+ virtual bool resetFontEdit() const;
/// set the change for the entire inset
virtual void setChange(Change const &) {}
/// reject the changes within the inset
virtual void rejectChanges() {}
- ///
- virtual Dimension const dimension(BufferView const &) const;
- ///
- int scroll() const { return 0; }
///
virtual ColorCode backgroundColor(PainterInfo const &) const;
///
* Gets normally called from Cursor::dispatch(). Cursor::dispatch()
* assumes the common case of 'LFUN handled, need update'.
* This has to be overriden by calling Cursor::undispatched() or
- * Cursor::noUpdate() if appropriate.
+ * Cursor::noScreenUpdate() if appropriate.
* If you need to call the dispatch method of some inset directly
* you may have to explicitly request an update at that place. Don't
* do it in doDispatch(), since that causes nested updates when
projects / lyx.git / blobdiff