X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Finsets%2Finsetbase.h;h=540f117e3ad10ec6c2f173ec5c9a03d514953c4a;hb=e28331ed63062dea10d0a21b9ec12034b4b17b9a;hp=5f9e1c2ac9dec8737bc52d4246aff752f1cfe4ce;hpb=b3eefc106e14aefca3baa0bb8270fc5d430531eb;p=lyx.git diff --git a/src/insets/insetbase.h b/src/insets/insetbase.h index 5f9e1c2ac9..540f117e3a 100644 --- a/src/insets/insetbase.h +++ b/src/insets/insetbase.h @@ -12,29 +12,35 @@ #ifndef INSETBASE_H #define INSETBASE_H -#include -#include +#include "changes.h" +#include "dimension.h" + +#include "support/docstream.h" + #include +#include + +namespace lyx { class Buffer; class BufferView; class CursorSlice; -class DispatchResult; class FuncRequest; class FuncStatus; +class InsetMath; +class InsetText; class LaTeXFeatures; class LCursor; class LyXLex; class LyXText; -class MathInset; class MetricsInfo; class Dimension; class PainterInfo; class OutputParams; -class UpdatableInset; +class TocList; -namespace lyx { namespace graphics { class PreviewLoader; } } +namespace graphics { class PreviewLoader; } /// Common base class to all insets @@ -61,18 +67,34 @@ public: /// virtual base class destructor virtual ~InsetBase() {} /// replicate ourselves - virtual std::auto_ptr clone() const = 0; + std::auto_ptr clone() const; /// identification as math inset - virtual MathInset * asMathInset() { return 0; } - /// identification as non-math inset - virtual UpdatableInset * asUpdatableInset() { return 0; } + virtual InsetMath * asInsetMath() { return 0; } /// true for 'math' math inset, but not for e.g. mbox virtual bool inMathed() const { return false; } - // the real dispatcher + /// the real dispatcher void dispatch(LCursor & cur, FuncRequest & cmd); - /// do we want to handle this event? + /** + * \returns true if this function made a definitive decision on + * whether the inset wants to handle the request \p cmd or not. + * The result of this decision is put into \p status. + * + * Every request that is enabled in this method needs to be handled + * in doDispatch(). Normally we have a 1:1 relationship between the + * requests handled in getStatus() and doDispatch(), but there are + * some exceptions: + * - A request that is disabled in getStatus() does not need to + * appear in doDispatch(). It is guaranteed that doDispatch() + * is never called with this request. + * - A few requests are en- or disabled in InsetBase::getStatus(). + * These need to be handled in the doDispatch() methods of the + * derived insets, since InsetBase::doDispatch() has not enough + * information to handle them. + * - LFUN_MOUSE_* need not to be handled in getStatus(), because these + * are dispatched directly + */ virtual bool getStatus(LCursor & cur, FuncRequest const & cmd, FuncStatus & status) const; @@ -82,13 +104,20 @@ public: virtual InsetBase * editXY(LCursor & cur, int x, int y); /// compute the size of the object returned in dim - virtual void metrics(MetricsInfo & mi, Dimension & dim) const = 0; + /// \retval true if metrics changed. + virtual bool 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; /// draw inset selection if necessary virtual void drawSelection(PainterInfo &, int, int) const {} /// virtual bool editing(BufferView * bv) const; + /// + virtual bool showInsetDialog(BufferView *) const { return false; } + + /// 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; /// draw two angular markers @@ -98,22 +127,21 @@ public: /// add space for markers void metricsMarkers2(Dimension & dim, int framesize = 1) const; /// last drawn position for 'important' insets - virtual int xo() const { return 0; } + int xo(BufferView const & bv) const; /// last drawn position for 'important' insets - virtual int yo() const { return 0; } + int yo(BufferView const & bv) const; /// set x/y drawing position cache if available virtual void setPosCache(PainterInfo const &, int, int) const {} /// do we cover screen position x/y? - virtual bool covers(int x, int y) const; + virtual bool covers(BufferView const & bv, int x, int y) const; /// get the screen positions of the cursor (see note in cursor.C) - virtual void getCursorPos(LCursor const & cur, int & x, int & y) const; + virtual void cursorPos(BufferView const & bv, + CursorSlice const & sl, bool boundary, int & x, int & y) const; /// is this an inset that can be moved into? virtual bool isActive() const { return nargs() > 0; } /// Where should we go when we press the up or down cursor key? virtual bool idxUpDown(LCursor & cur, bool up) const; - /// Where should we go when we press the up or down cursor key? - virtual bool idxUpDown2(LCursor & cur, bool up) const; /// Move one cell to the left virtual bool idxLeft(LCursor &) const { return false; } /// Move one cell to the right @@ -133,8 +161,8 @@ public: virtual bool idxDelete(idx_type &) { return false; } /// pulls cell after pressing erase virtual void idxGlue(idx_type) {} - // returns list of cell indices that are "between" from and to for - // selection purposes + /// returns list of cell indices that are "between" from and to for + /// selection purposes virtual bool idxBetween(idx_type idx, idx_type from, idx_type to) const; /// to which column belongs a cell with a given index? @@ -154,30 +182,39 @@ public: /// number of columns in gridlike structures virtual size_t ncols() const { return 0; } /// is called when the cursor leaves this inset - virtual void notifyCursorLeaves(LCursor &) {} + // returns true if cursor is now invalid. + virtual bool notifyCursorLeaves(LCursor &) { 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 & /* list */) const {} + std::vector & /* list */) const {} /// describe content if cursor inside - virtual void infoize(std::ostream &) const {} + virtual void infoize(odocstream &) const {} /// describe content if cursor behind - virtual void infoize2(std::ostream &) const {} + virtual void infoize2(odocstream &) const {} - /// plain ascii output - virtual int plaintext(Buffer const &, std::ostream & os, - OutputParams const &) const; - /// linuxdoc output - virtual int linuxdoc(Buffer const &, std::ostream & os, + /// plain text output in ucs4 encoding + virtual int plaintext(Buffer const &, odocstream &, OutputParams const &) const; /// docbook output - virtual int docbook(Buffer const &, std::ostream & os, + virtual int docbook(Buffer const &, odocstream & os, OutputParams const &) const; - - /// + /// the string that is passed to the TOC + virtual void textString(Buffer const &, 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, url) + - 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, @@ -187,19 +224,21 @@ public: HIGHLY_EDITABLE }; /// what appears in the minibuffer when opening - virtual std::string const editMessage() const; + virtual docstring const editMessage() const; /// virtual EDITABLE editable() const; /// can we go further down on mouse click? virtual bool descendable() const { return false; } - /// - virtual bool isTextInset() const { return false; } + /// does this contain text that can be change track marked in DVI? + virtual bool canTrackChanges() const { return false; } + /// is this inset based on the TextInset class? + virtual InsetText const * asTextInset() const { return 0; } /// return true if the inset should be removed automatically virtual bool autoDelete() const; /** This is not quite the correct place for this enum. I think the correct would be to let each subclass of Inset declare - its own enum code. Actually the notion of an InsetOld::Code + its own enum code. Actually the notion of an InsetBase::Code should be avoided, but I am not sure how this could be done in a cleaner way. */ enum Code { @@ -268,8 +307,6 @@ public: /// MATHMACRO_CODE, // 30 /// - ERROR_CODE, - /// CITE_CODE, /// FLOAT_LIST_CODE, @@ -294,7 +331,11 @@ public: /// VSPACE_CODE, /// - MATHMACROARG_CODE + MATHMACROARG_CODE, + /// + NOMENCL_CODE, // 45 + /// + NOMENCL_PRINT_CODE }; /** returns the Code corresponding to the \c name. @@ -302,39 +343,42 @@ public: */ static Code translate(std::string const & name); - /// returns true the inset can hold an inset of given type + /// returns true if the inset can hold an inset of given type virtual bool insetAllowed(Code) const { return false; } - // if this inset has paragraphs should they be output all as default - // paragraphs with "Standard" layout? - virtual bool forceDefaultParagraphs(InsetBase const *) const { return false; } + /// if this inset has paragraphs should they be output all as default + /// paragraphs with the default layout of the text class? + virtual bool forceDefaultParagraphs(idx_type) const { return false; } + /// - virtual std::string const & getInsetName() const; + virtual docstring const & getInsetName() const; /// used to toggle insets - // is the inset open? - virtual bool isOpen() const { return false; } - /// open the inset - virtual void open() {} - /// close the inset - virtual void close() {} - // should this inset be handled like a normal charater + /// is the inset open? + /// should this inset be handled like a normal charater virtual bool isChar() const { return false; } - // is this equivalent to a letter? + /// is this equivalent to a letter? virtual bool isLetter() const { return false; } - // is this equivalent to a space (which is BTW different from - // a line separator)? + /// is this equivalent to a space (which is BTW different from + /// a line separator)? virtual bool isSpace() const { return false; } - // should we have a non-filled line before this inset? + /// should we have a non-filled line before this inset? virtual bool display() const { return false; } - // should we break lines after this inset? + /// 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; } /// dumps content to lyxerr virtual void dump() const; - /// + /// write inset in .lyx format virtual void write(Buffer const &, std::ostream &) const {} - /// + /// read inset in .lyx format virtual void read(Buffer const &, LyXLex &) {} - /// returns the number of rows (\n's) of generated tex code. - virtual int latex(Buffer const &, std::ostream &, + /** 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; } /// returns true to override begin and end inset in file virtual bool directWrite() const; @@ -350,10 +394,10 @@ public: * Most insets have no interest in this capability, so the method * defaults to empty. */ - virtual void addPreview(lyx::graphics::PreviewLoader &) const {} -protected: - // the real dispatcher - virtual void priv_dispatch(LCursor & cur, FuncRequest & cmd); + virtual void addPreview(graphics::PreviewLoader &) const {} + /// Add an entry to the TocList + virtual void addToToc(TocList &, Buffer const &) const {} + public: /// returns LyX code associated with the inset. Used for TOC, ...) virtual Code lyxCode() const { return NO_CODE; } @@ -362,18 +406,61 @@ public: 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; } - - /// is this inset allowed within a font change? + /// 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. + */ virtual bool noFontChange() const { return false; } - /// - virtual void markErased(); + /// set the change for the entire inset + virtual void setChange(Change const &) {} + /// accept the changes within the inset + virtual void acceptChanges() {}; + /// reject the changes within the inset + virtual void rejectChanges() {}; + /// pretty arbitrary virtual int width() const { return 10; } /// pretty arbitrary virtual int ascent() const { return 10; } /// pretty arbitrary virtual int descent() const { return 10; } + /// + int scroll() const { return 0; } + /// + enum CollapseStatus { + Collapsed, + Inlined, + Open + }; + /// + virtual void setStatus(LCursor &, CollapseStatus) {} +protected: + InsetBase() {} + InsetBase(InsetBase const &) {} + /** The real dispatcher. + * Gets normally called from LCursor::dispatch(). LCursor::dispatch() + * assumes the common case of 'LFUN handled, need update'. + * This has to be overriden by calling LCursor::undispatched() or + * LCursor::noUpdate() 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 + * called from LCursor::dispatch(), and these can lead to crashes. + * \sa getStatus + */ + virtual void doDispatch(LCursor & cur, FuncRequest & cmd); + + /// Cached dimensions of the inset. + mutable Dimension dim_; +private: + virtual std::auto_ptr doClone() const = 0; }; @@ -390,4 +477,6 @@ bool isEditableInset(InsetBase const * inset); */ bool isHighlyEditableInset(InsetBase const * inset); +} // namespace lyx + #endif