* Licence details can be found in the file COPYING.
*
* \author Alejandro Aguilar Sierra
- * \author Jürgen Vigna
- * \author Lars Gullik Bjønnes
+ * \author Jürgen Vigna
+ * \author Lars Gullik Bjønnes
* \author Matthias Ettrich
*
* Full author contact details are available in file CREDITS.
#include "ColorCode.h"
#include "InsetCode.h"
+#include "Layout.h"
#include "support/strfwd.h"
#include "support/types.h"
class BiblioInfo;
class Buffer;
-class BufferParams;
class BufferView;
class Change;
class CompletionList;
class FuncRequest;
class FuncStatus;
class InsetCollapsable;
+class InsetCommand;
class InsetIterator;
class InsetLayout;
class InsetList;
class InsetMath;
+class InsetTabular;
class InsetText;
class LaTeXFeatures;
class Lexer;
class ParIterator;
class Text;
class TocList;
-class EmbeddedFile;
-class EmbeddedFileList;
-
+class XHTMLStream;
namespace graphics { class PreviewLoader; }
virtual ~Inset() {}
/// change associated Buffer
- /// FIXME this should go.
virtual void setBuffer(Buffer & buffer);
+ /// remove the buffer reference
+ void resetBuffer() { setBuffer( *static_cast<Buffer *>(0)); }
/// 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.
+ 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 updateLabels(buffer()) is
+ * Buffer. The default implementation calls buffer().updateLabels() if
* the inset is labeled.
*
* \sa isLabeled()
/// identification as math inset
virtual InsetMath * asInsetMath() { return 0; }
+ /// identification as math inset
+ virtual InsetMath const * asInsetMath() const { return 0; }
/// true for 'math' math inset, but not for e.g. mbox
virtual bool inMathed() const { return false; }
/// is this inset based on the InsetText class?
virtual InsetCollapsable * asInsetCollapsable() { return 0; }
/// is this inset based on the InsetCollapsable class?
virtual InsetCollapsable const * asInsetCollapsable() const { return 0; }
+ /// is this inset based on the InsetTabular class?
+ virtual InsetTabular * asInsetTabular() { return 0; }
+ /// is this inset based on the InsetTabular class?
+ virtual InsetTabular const * asInsetTabular() const { return 0; }
+ /// is this inset based on the InsetCommand class?
+ virtual InsetCommand * asInsetCommand() { return 0; }
+ /// is this inset based on the InsetCommand class?
+ virtual InsetCommand const * asInsetCommand() const { return 0; }
/// the real dispatcher
void dispatch(Cursor & cur, FuncRequest & cmd);
virtual void draw(PainterInfo & pi, int x, int y) const = 0;
/// draw inset selection if necessary
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 bool editing(BufferView const * bv) const;
///
virtual void cursorPos(BufferView const & bv,
CursorSlice const & sl, bool boundary, int & x, int & y) const;
- ///
- virtual bool isFreeSpacing() const { return false; }
- ///
- virtual bool allowEmpty() const { return false; }
+ /// Allow multiple blanks
+ virtual bool isFreeSpacing() const;
+ /// Don't eliminate empty paragraphs
+ virtual bool allowEmpty() const;
/// Force inset into LTR environment if surroundings are RTL?
- virtual bool forceLTR() const { return false; }
+ virtual bool forceLTR() const;
- /// is this an inset that can be moved into?
- /// FIXME: merge with editable()
- virtual bool isActive() const { return nargs() > 0; }
/// Where should we go when we press the up or down cursor key?
virtual bool idxUpDown(Cursor & cur, bool up) const;
/// Move one cell backwards
/// 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 old is the old cursor, the last slice points 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 cursor enters 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 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; }
virtual int plaintext(odocstream &, OutputParams const &) const = 0;
/// docbook output
virtual int docbook(odocstream & os, OutputParams const &) const;
+ /// XHTML output
+ /// the inset is expected to write XHTML to the XHTMLStream
+ /// \return any "deferred" material that should be written outside the
+ /// 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 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
- (e.g. printindex, insetspecialchar)
- - IS_EDITABLE: content can be edited via dialog (e.g. bibtex, index, href)
- - HIGHLY_EDITABLE: content can be edited on screen (normally means that
- insettext is contained, e.g. collapsables, tabular) */
- // FIXME: This has not yet been fully implemented to math insets
- enum EDITABLE {
- ///
- NOT_EDITABLE = 0,
- ///
- IS_EDITABLE,
- ///
- HIGHLY_EDITABLE
- };
- /// what appears in the minibuffer when opening
- virtual docstring editMessage() const;
- ///
- virtual EDITABLE editable() const;
+ virtual void tocString(odocstream &) const {}
+
+ /// can the contents of the inset be edited on screen ?
+ // true for InsetCollapsables (not ButtonOnly) (not InsetInfo), InsetText
+ virtual bool editable() const;
+ /// has the Inset settings that can be modified in a dialog ?
+ virtual bool hasSettings() const;
/// can we go further down on mouse click?
- virtual bool descendable() const { return false; }
+ // true for InsetCaption, InsetCollapsables (not ButtonOnly), InsetTabular
+ virtual bool descendable(BufferView const &) const { return false; }
+ /// is this an inset that can be moved into?
+ /// FIXME: merge with editable()
+ // true for InsetTabular & InsetText
+ virtual bool isActive() const { return nargs() > 0; }
+
/// does this contain text that can be change track marked in DVI?
virtual bool canTrackChanges() const { return false; }
/// return true if the inset should be removed automatically
virtual bool insetAllowed(InsetCode) const { return false; }
/// should this inset use the empty layout by default rather than
/// the standard layout? (default: only if that is forced.)
- virtual bool useEmptyLayout() const { return forceEmptyLayout(); }
+ virtual bool usePlainLayout() const { return forcePlainLayout(); }
/// if this inset has paragraphs should they be forced to use the
/// empty layout?
- virtual bool forceEmptyLayout() const { return false; }
+ 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) 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 the content of this inset part of the output document?
+ virtual bool producesOutput() const { return true; }
+
/// \return Tool tip for this inset.
/// This default implementation returns an empty string.
virtual docstring toolTip(BufferView const & bv, int x, int y) const;
///
virtual docstring name() const;
///
- virtual InsetLayout const & getLayout(BufferParams const & bp) const;
+ virtual InsetLayout const & getLayout() const;
+ /// 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 we have a non-filled line before this inset?
virtual DisplayType display() const { return Inline; }
+ ///
+ virtual LyXAlignment contentAlignment() const { return LYX_ALIGN_NONE; }
/// should we break lines after this inset?
virtual bool isLineSeparator() const { return false; }
/// should paragraph indendation be ommitted in any case?
* Most insets have no interest in this capability, so the method
* defaults to empty.
*/
- virtual void addPreview(graphics::PreviewLoader &) const {}
+ virtual void addPreview(DocIterator const &,
+ graphics::PreviewLoader &) const {}
+
+ /** Classifies the unicode characters appearing in a math inset
+ * depending on whether they are to be translated as latex
+ * math/text commands or used as math symbols without translation.
+ *
+ * Only math insets have interest in this classification, so the
+ * method defaults to empty.
+ */
+ virtual void initUnicodeMath() const {}
+
/// Add an entry to the TocList
/// pit is the ParConstIterator of the paragraph containing the inset
- virtual void addToToc(ParConstIterator const &) const {}
- /// report files that can be embedded with the lyx file
- 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 &) {}
+ virtual void addToToc(DocIterator const &) {}
/// Fill keys with BibTeX information
virtual void fillWithBibKeys(BiblioInfo &, InsetIterator const &) const {}
- /// Update the counters of this inset and of its contents
- virtual void updateLabels(ParIterator 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) {}
/// Updates the inset's dialog
virtual Buffer const * updateFrontend() const;
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 this inset is allowed in other insets of given mode
virtual bool allowedIn(mode_type) const { return true; }
/**
/// set the change for the entire inset
virtual void setChange(Change const &) {}
/// accept the changes within the inset
- virtual void acceptChanges(BufferParams const &) {};
+ virtual void acceptChanges() {}
/// reject the changes within the inset
- virtual void rejectChanges(BufferParams const &) {};
+ virtual void rejectChanges() {}
///
virtual Dimension const dimension(BufferView const &) const;
///
int scroll() const { return 0; }
///
- virtual ColorCode backgroundColor() const;
- ///
- enum CollapseStatus {
- Collapsed,
- Open
- };
+ virtual ColorCode backgroundColor(PainterInfo const &) const;
///
- virtual void setStatus(Cursor &, CollapseStatus) {}
+ virtual ColorCode labelColor() const;
//
enum { TEXT_TO_INSET_OFFSET = 4 };
protected:
- /// Constructor
- explicit Inset() : buffer_(0) {}
+ /// Constructors
+ Inset(Buffer * buf) : buffer_(buf) {}
+ Inset(Inset const &) : buffer_(0) {}
/// replicate ourselves
friend class InsetList;