+ ///
+ typedef ptrdiff_t difference_type;
+ /// short of anything else reasonable
+ typedef size_t size_type;
+ /// type for cell indices
+ typedef size_t idx_type;
+ /// type for cursor positions
+ typedef ptrdiff_t pos_type;
+ /// type for row numbers
+ typedef size_t row_type;
+ /// type for column numbers
+ typedef size_t col_type;
+
+ /// virtual base class destructor
+ virtual ~InsetBase() {}
+ /// replicate ourselves
+ std::auto_ptr<InsetBase> clone() const;
+
+ /// identification as math inset
+ 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
+ void dispatch(LCursor & cur, FuncRequest & cmd);
+ /**
+ * \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;
+
+ /// cursor enters
+ virtual void edit(LCursor & cur, bool left);
+ /// cursor enters
+ virtual InsetBase * editXY(LCursor & cur, int x, int y);
+
+ /// compute the size of the object returned in dim
+ /// \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
+ 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;
+ /// 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 {}
+ /// do we cover screen position x/y?
+ 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 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;
+ /// Move one cell to the left
+ virtual bool idxLeft(LCursor &) const { return false; }
+ /// Move one cell to the right
+ virtual bool idxRight(LCursor &) const { return false; }
+
+ /// Move one physical cell up
+ virtual bool idxNext(LCursor &) const { return false; }
+ /// Move one physical cell down
+ virtual bool idxPrev(LCursor &) const { return false; }
+
+ /// Target pos when we enter the inset from the left by pressing "Right"
+ virtual bool idxFirst(LCursor &) const { return false; }
+ /// Target pos when we enter the inset from the right by pressing "Left"
+ virtual bool idxLast(LCursor &) const { return false; }
+
+ /// Delete a cell and move cursor
+ 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
+ virtual bool idxBetween(idx_type idx, idx_type from, idx_type to) const;
+
+ /// to which column belongs a cell with a given index?
+ 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;
+ 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
+ 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.
+ 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<docstring> & /* list */) const {}
+
+ /// describe content if cursor inside
+ virtual void infoize(odocstream &) const {}
+ /// describe content if cursor behind
+ virtual void infoize2(odocstream &) const {}
+
+ /// plain text output in ucs4 encoding
+ virtual int plaintext(Buffer const &, odocstream &,
+ OutputParams const &) const;
+ /// docbook output
+ 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,
+ ///
+ IS_EDITABLE,
+ ///
+ HIGHLY_EDITABLE