lyx_mirror/src/insets/Inset.h

556 lines
17 KiB
C
Raw Normal View History

// -*- C++ -*-
/**
* \file Inset.h
* This file is part of LyX, the document processor.
* Licence details can be found in the file COPYING.
*
* \author Alejandro Aguilar Sierra
* \author J<EFBFBD>rgen Vigna
* \author Lars Gullik Bj<EFBFBD>nnes
* \author Matthias Ettrich
*
* Full author contact details are available in file CREDITS.
*/
#ifndef INSETBASE_H
#define INSETBASE_H
#include "Dimension.h"
#include "support/docstream.h"
#include <memory>
#include <vector>
namespace lyx {
class BiblioInfo;
class Buffer;
class BufferParams;
class BufferView;
class Change;
class Color_color;
class Cursor;
class CursorSlice;
class FuncRequest;
class FuncStatus;
class InsetIterator;
class InsetLayout;
class InsetMath;
class InsetText;
class LaTeXFeatures;
class Lexer;
class MathAtom;
class MetricsInfo;
class OutputParams;
class PainterInfo;
class Paragraph;
class ParConstIterator;
class ParIterator;
class Text;
class TocList;
class EmbeddedFiles;
namespace graphics { class PreviewLoader; }
/// Common base class to all insets
// Do not add _any_ (non-static) data members as this would inflate
// everything storing large quantities of insets. Mathed e.g. would
// suffer.
class Inset {
public:
///
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 ~Inset() {}
/// 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; }
/// is this inset based on the TextInset class?
virtual InsetText * asTextInset() { return 0; }
/// is this inset based on the TextInset class?
virtual InsetText const * asTextInset() const { return 0; }
/// the real dispatcher
void dispatch(Cursor & 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 Inset::getStatus().
* These need to be handled in the doDispatch() methods of the
* derived insets, since Inset::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(Cursor & cur, FuncRequest const & cmd,
FuncStatus & status) const;
/// cursor enters
virtual void edit(Cursor & cur, bool left);
/// cursor enters
virtual Inset * editXY(Cursor & 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.cpp)
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?
/// 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 to the left
virtual bool idxLeft(Cursor &) const { return false; }
/// Move one cell to the right
virtual bool idxRight(Cursor &) const { return false; }
/// Move one physical cell up
virtual bool idxNext(Cursor &) const { return false; }
/// Move one physical cell down
virtual bool idxPrev(Cursor &) const { return false; }
/// Target pos when we enter the inset from the left by pressing "Right"
virtual bool idxFirst(Cursor &) const { return false; }
/// Target pos when we enter the inset from the right by pressing "Left"
virtual bool idxLast(Cursor &) 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(Cursor &) { 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; }
/// 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; }
/// 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
};
/// 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;
/// 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
};
/// what appears in the minibuffer when opening
virtual docstring const editMessage() const;
///
virtual EDITABLE editable() const;
/// can we go further down on mouse click?
virtual bool descendable() const { return false; }
/// 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 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 Inset::Code
should be avoided, but I am not sure how this could be done
in a cleaner way. */
enum Code {
///
NO_CODE, // 0
///
TOC_CODE, // do these insets really need a code? (ale)
///
QUOTE_CODE,
///
MARK_CODE,
///
REF_CODE,
///
URL_CODE, // 5
///
HTMLURL_CODE,
///
SEPARATOR_CODE,
///
ENDING_CODE,
///
LABEL_CODE,
///
NOTE_CODE, // 10
///
ACCENT_CODE,
///
MATH_CODE,
///
INDEX_CODE,
///
INCLUDE_CODE,
///
GRAPHICS_CODE, // 15
///
BIBITEM_CODE,
///
BIBTEX_CODE,
///
TEXT_CODE,
///
ERT_CODE,
///
FOOT_CODE, // 20
///
MARGIN_CODE,
///
FLOAT_CODE,
///
WRAP_CODE,
///
SPACE_CODE, // 25
///
SPECIALCHAR_CODE,
///
TABULAR_CODE,
///
EXTERNAL_CODE,
#if 0
///
THEOREM_CODE,
#endif
///
CAPTION_CODE,
///
MATHMACRO_CODE, // 30
///
CITE_CODE,
///
FLOAT_LIST_CODE,
///
INDEX_PRINT_CODE,
///
OPTARG_CODE, // 35
///
ENVIRONMENT_CODE,
///
HFILL_CODE,
///
NEWLINE_CODE,
///
LINE_CODE,
///
BRANCH_CODE, // 40
///
BOX_CODE,
///
FLEX_CODE,
///
VSPACE_CODE,
///
New nomenclature inset from Ugras * src/LyXAction.C (LyXAction::init): Add LFUN_NOMENCL_INSERT and LFUN_NOMENCL_PRINT * src/insets/insetbase.C (build_translator): ditto * src/LaTeXFeatures.C (LaTeXFeatures::getPackages): Add nomencl * src/insets/insetnomencl.[Ch]: new insets InsetNomencl and InsetPrintNomencl * src/insets/insetbase.h: Add NOMENCL_CODE and NOMENCL_PRINT_CODE * src/insets/insetcommandparams.C (InsetCommandParams::findInfo): Add nomenclature and printnomenclature (InsetCommandParams::getCommand): Extend end of command protection to cover commands with only optional arguments like printnomenclature * src/insets/insetert.C (InsetERT::getStatus): disable LFUN_NOMENCL_INSERT and LFUN_NOMENCL_PRINT * src/insets/Makefile.am: Add new files * src/frontends/qt4/Makefile.dialogs: ditto * src/frontends/qt4/Makefile.am: ditto * src/factory.C (createInset): Handle InsetNomencl and InsetPrintNomencl (readInset): ditto * src/buffer.C (LYX_FORMAT): increase * src/lyxfunc.C (LyXFunc::dispatch): Handle nomenclature * src/LaTeX.C (LaTeX::deleteFilesOnError): Delete .nls file (LaTeX::run): Run makeindex for nomenclature (LaTeX::runMakeIndex): handle nomenclature options (LaTeX::deplog): Recognize nomenclature file * src/frontends/qt4/QNomenclDialog.[Ch]: new * src/frontends/qt4/QNomencl.[Ch]: ditto * src/frontends/qt4/ui/QNomenclUi.ui: ditto * src/frontends/qt4/Dialogs.C (Dialogs::build): handle nomenclature dialog * src/text3.C (LyXText::dispatch): Handle LFUN_NOMENCL_INSERT and LFUN_NOMENCL_PRINT (LyXText::getStatus): Ditto * src/lfuns.h (kb_action): Add LFUN_NOMENCL_INSERT and LFUN_NOMENCL_PRINT * lib/lyx2lyx/LyX.py (format_relation): Update 1.5 format range * lib/lyx2lyx/lyx_1_5.py (revert_nomenclature): New (revert_printnomenclature): ditto * lib/chkconfig.ltx: Test for nomencl package * lib/doc/LaTeXConfig.lyx.in: Add nomencl package * lib/doc/Extended.lyx: Add documentation for nomencl * lib/ui/stdtoolbars.ui (Toolbar "extra" "Extra"): Add nomencl-insert * lib/ui/classic.ui: Add nomencl-insert and nomencl-print * lib/ui/stdmenus.ui: ditto * development/scons/scons_manifest.py: Add new files * development/FORMAT: Describe new format git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@15739 a592a061-630c-0410-9148-cb99ea01b6c8
2006-11-04 17:55:36 +00:00
MATHMACROARG_CODE,
///
NOMENCL_CODE, // 45
///
NOMENCL_PRINT_CODE,
///
Add support for listings package. Two listings command \lstinline, \lstinputlisting and an environment \lstlisting are supported, along with preamble \lstset. \lstinputlisting is implemented through Include dialog, and the other two are implemented with a new inset listings, along with its dialog. * src/LyXAction.cpp: listing-insert action * src/insets/Inset.h,cpp: LISTINGS_CODE * src/insets/InsetInclude.cpp: handle \lstinputlisting * src/insets/InsetListings.h,cpp: new listings inset * src/insets/InsetListingsParams.h,cpp: parameters from listings package * src/insets/InsetCommandParams.h,cpp: handle lstinputlisting option * src/Bidi.cpp: handle LISTINGS_CODE * src/frontends/qt4/ui/TextLayoutUi.ui: update UI * src/frontends/qt4/ui/ListingsUi.ui: new dialog * src/frontends/qt4/ui/IncludeUi.ui: update UI * src/frontends/qt4/QInclude.h,cpp: add lstinputlisting * src/frontends/qt4/QDocument.h,cpp: add textedit for preamble listings_params * src/frontends/qt4/QListings.h,cpp: new listings inset * src/frontends/qt4/Dialogs.cpp: new listings dialog * src/frontends/controllers/ControlInclude.h,cpp: add lstinputlisting * src/frontends/controllers/ControlListings.h,cpp: new listings inset * src/LyXFunc.cpp: handle LISTING_CODE * src/Paragraph.cpp: handle LISTING_CODE * src/factory.cpp: new listings inset * src/CutAndPaste.cpp: handle LISTINGS_CODE * src/LaTeXFeatures.cpp: require listings * src/Text3.cpp: Handle LISTINGS_CODE * src/lfuns.h: add LFUN_LISTING_INSERT * src/Buffer.cpp: change lyx file format to 269 * src/BufferParams.h,cpp: add listings_params to preamble * lib/lyx2lyx/LyX.py: lyx2lyx * lib/lyx2lyx/lyx_1_5.py: lyx2lyx * lib/ui/stdmenus.inc: new menu item (no shortcut!) * src/insets/Makefile.am: update autotools * src/frontends/controllers/Makefile.am * src/frontends/qt4/Makefile.dialogs * src/frontends/qt4/Makefile.am * po/POTFILES.in: a few more translatable files. * development/scons/scons_manifest.py: scons build system * development/FORMAT: document format changes git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@18243 a592a061-630c-0410-9148-cb99ea01b6c8
2007-05-09 19:11:42 +00:00
PAGEBREAK_CODE,
///
LISTINGS_CODE
};
/** returns the Code corresponding to the \c name.
* Eg, translate("branch") == BRANCH_CODE
*/
static Code translate(std::string const & name);
/// 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 the default layout of the text class?
virtual bool forceDefaultParagraphs(idx_type) const { return false; }
/// Is the width forced to some value?
virtual bool hasFixedWidth() const { return false; }
///
virtual docstring name() const { return from_ascii("unknown"); }
///
virtual InsetLayout const & getLayout(BufferParams const & bp) const;
/// used to toggle insets
/// 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?
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; }
enum DisplayType {
Inline = 0,
AlignLeft,
AlignCenter,
AlignRight
};
/// should we have a non-filled line before this inset?
virtual DisplayType display() const { return Inline; }
/// 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 &, Lexer &) {}
Make the output of \inputencoding commands (and the change of output encodings) more fine grained: From paragraph level to individual character level. The inputenc package supports that since at least 2000. * src/insets/insetbase.h (latex): Document the differences between output to a string stream and a file stream * src/buffer.h (writeLaTeXSource): ditto * src/output_latex.h (latexParagraphs): ditto (switchEncoding): new function to change the encoding of a stream (and output \inputencoding commands) * src/paragraph_pimpl.C (Paragraph::Pimpl::simpleTeXSpecialC): Adjust to latexWriteEndChanges changes * src/support/docstream.[Ch] (setEncoding, operator<<): New stream modifier that changes the encoding of file streams * src/lyxfont.[Ch] (LyXFont::latexWriteStartChanges): Change stream encoding if needed (LyXFont::latexWriteEndChanges): Change stream encoding if needed * src/lyxfont.h (public:): * src/paragraph.C (Paragraph::simpleTeXOnePar): Adjust to latexWriteStartChanges and latexWriteEndChanges changes (bool Paragraph::simpleTeXOnePar): (bool Paragraph::simpleTeXOnePar): (bool Paragraph::simpleTeXOnePar): (bool Paragraph::simpleTeXOnePar): (bool Paragraph::simpleTeXOnePar): * src/output_latex.C (TeXOnePar): Remove the ugly hack to for wencoding changes and use switchEncoding instead. A nice side effect is that the old hack would not work if the main language encoding is latin1 and a character would be mapped to a cedilla in the "fake ucs4" encoding, because iconv refuses to convert such a character to latin1, although it exists in latin1 (it wants to attach it to a base character). git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@16633 a592a061-630c-0410-9148-cb99ea01b6c8
2007-01-09 19:25:40 +00:00
/** 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;
///
virtual bool allowSpellCheck() const { return false; }
/// if this insets owns text cells (e.g. InsetText) return cell num
virtual Text * getText(int /*num*/) const { return 0; }
/** Adds a LaTeX snippet to the Preview Loader for transformation
* into a bitmap image. Does not start the laoding process.
*
* Most insets have no interest in this capability, so the method
* defaults to empty.
*/
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 {}
/// report files that can be embedded with the lyx file
virtual void registerEmbeddedFiles(Buffer const &, EmbeddedFiles &,
ParConstIterator const &) const {};
/// Fill keys with BibTeX information
virtual void fillWithBibKeys(Buffer const &,
BiblioInfo &, InsetIterator const &) const { return; }
/// Update the counters of this inset and of its contents
Rewrite the label numbering code. * buffer_funcs.cpp (updateLabels): new function taking a buffer and a ParIterator as arguments. This one is used to update labels into an InsetText. Cleanup the code to reset depth. Call setLabel for each paragraph, and then updateLabel on each inset it contains. (setCaptionLabels, setCaptions): removed. (setLabel): use Counters::current_float to make caption paragraphs labels. * insets/Inset.h (updateLabels): new virtual method, empty by default; this numbers the inset itself (if relevant) and then all the paragraphs it may contain. * insets/InsetText.cpp (updateLabels): basically calls lyx::updateLabels from buffer_func.cpp. * insets/InsetCaption.cpp (addToToc): use the label constructed by updateLabels. (computeFullLabel): removed. (metrics, plaintext): don't use computeFullLabel. (updateLabels): new method; set the label from Counters::current_float. * insets/InsetWrap.cpp (updateLabels): * insets/InsetFloat.cpp (updateLabel): new method; sets Counters::current_float to the float type. * insets/InsetBranch.cpp (updateLabels): new method; the numbering is reset afterwards if the branch is inactive. (bug 2671) * insets/InsetNote.cpp (updateLabels): new method; the numbering is reset after the underlying InsetText has been numbered. (bug 2671) * insets/InsetTabular.cpp (updateLabels): new method (also handles longtable) * insets/InsetListings.cpp (updateLabels): new method; mimics what is done for Floats (although Listings are not floats technically) * insets/InsetInclude.cpp (getScreenLabel): in the listings case, use the computed label. (updateLabels): new method; that either renumbers the child document or number the current listing. * LyXFunc.cpp (menuNew): do not updateLabels on empty documents (why do we do that at all?) git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@19482 a592a061-630c-0410-9148-cb99ea01b6c8
2007-08-12 21:43:58 +00:00
virtual void updateLabels(Buffer const &, ParIterator const &) {}
public:
/// returns LyX code associated with the inset. Used for TOC, ...)
virtual Code 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 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; }
/// set the change for the entire inset
virtual void setChange(Change const &) {}
/// accept the changes within the inset
virtual void acceptChanges(BufferParams const &) {};
/// reject the changes within the inset
virtual void rejectChanges(BufferParams const &) {};
/// FIXME: move dim_ out of Inset!
Dimension const & dimension() { return dim_; }
/// inset width.
int width() const { return dim_.wid; }
/// inset ascent.
int ascent() const { return dim_.asc; }
/// inset descent.
int descent() const { return dim_.des; }
///
int scroll() const { return 0; }
///
virtual Color_color backgroundColor() const;
///
enum CollapseStatus {
Collapsed,
Open
};
///
virtual void setStatus(Cursor &, CollapseStatus) {}
//
enum { TEXT_TO_INSET_OFFSET = 4 };
protected:
Inset();
/// replicate ourselves
friend class Paragraph;
friend class MathAtom;
virtual Inset * clone() const = 0;
/** The real dispatcher.
* 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.
* 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 Cursor::dispatch(), and these can lead to crashes.
* \sa getStatus
*/
virtual void doDispatch(Cursor & cur, FuncRequest & cmd);
/// Cached dimensions of the inset.
mutable Dimension dim_;
};
/**
* returns true if pointer argument is valid
* and points to an editable inset
*/
bool isEditableInset(Inset const * inset);
/**
* returns true if pointer argument is valid
* and points to a highly editable inset
*/
bool isHighlyEditableInset(Inset const * inset);
/** \c Inset_code is a wrapper for Inset::Code.
* It can be forward-declared and passed as a function argument without
* having to expose Inset.h.
*/
class Inset_code {
Inset::Code val_;
public:
Inset_code(Inset::Code val) : val_(val) {}
operator Inset::Code() const { return val_; }
};
} // namespace lyx
#endif