1 // -*- C++ -*- 2 /** 3 * \file Inset.h 4 * This file is part of LyX, the document processor. 5 * Licence details can be found in the file COPYING. 6 * 7 * \author Alejandro Aguilar Sierra 8 * \author Jürgen Vigna 9 * \author Lars Gullik Bjønnes 10 * \author Matthias Ettrich 11 * 12 * Full author contact details are available in file CREDITS. 13 */ 14 15 #ifndef INSETBASE_H 16 #define INSETBASE_H 17 18 #include "ColorCode.h" 19 #include "InsetCode.h" 20 #include "InsetLayout.h" 21 #include "LayoutEnums.h" 22 #include "OutputEnums.h" 23 24 #include "support/strfwd.h" 25 #include "support/types.h" 26 #include "support/FileNameList.h" 27 28 #include <climits> 29 30 31 namespace lyx { 32 33 class BiblioInfo; 34 class Buffer; 35 class BufferView; 36 class Change; 37 class CompletionList; 38 class Cursor; 39 class CursorSlice; 40 class Dimension; 41 class DocIterator; 42 class Encoding; 43 class FuncRequest; 44 class FuncStatus; 45 class InsetArgument; 46 class InsetCollapsible; 47 class InsetCommand; 48 class InsetIterator; 49 class InsetLayout; 50 class InsetList; 51 class InsetMath; 52 class InsetTabular; 53 class InsetText; 54 class LaTeXFeatures; 55 class Lexer; 56 class MathAtom; 57 class MetricsInfo; 58 class OutputParams; 59 class PainterInfo; 60 class ParConstIterator; 61 class ParIterator; 62 class Text; 63 class TocBackend; 64 class TocList; 65 class XHTMLStream; 66 class otexstream; 67 68 namespace graphics { class PreviewLoader; } 69 70 71 /// returns the InsetCode corresponding to the \c name. 72 /// Eg, insetCode("branch") == BRANCH_CODE 73 InsetCode insetCode(std::string const & name); 74 /// returns the Inset name corresponding to the \c InsetCode. 75 /// Eg, insetName(BRANCH_CODE) == "branch" 76 std::string insetName(InsetCode); 77 /// returns the Inset name corresponding to the \c InsetCode. 78 /// Eg, insetDisplayName(BRANCH_CODE) == _("Branch") 79 docstring insetDisplayName(InsetCode); 80 /// 81 static int const TOC_ENTRY_LENGTH = 120; 82 83 /// Common base class to all insets 84 85 // Do not add _any_ (non-static) data members as this would inflate 86 // everything storing large quantities of insets. Mathed e.g. would 87 // suffer. 88 89 class Inset { 90 public: 91 /// 92 enum EntryDirection { 93 ENTRY_DIRECTION_IGNORE, 94 ENTRY_DIRECTION_RIGHT, 95 ENTRY_DIRECTION_LEFT 96 }; 97 /// 98 typedef ptrdiff_t difference_type; 99 /// short of anything else reasonable 100 typedef size_t size_type; 101 /// type for cell indices 102 typedef size_t idx_type; 103 /// type for cursor positions 104 typedef ptrdiff_t pos_type; 105 /// type for row numbers 106 typedef size_t row_type; 107 /// type for column numbers 108 typedef size_t col_type; 109 110 /// virtual base class destructor ~Inset()111 virtual ~Inset() {} 112 113 /// change associated Buffer 114 virtual void setBuffer(Buffer & buffer); 115 /// reset associated Buffer to null value 116 virtual void resetBuffer(); 117 /// retrieve associated Buffer 118 Buffer & buffer(); 119 Buffer const & buffer() const; 120 /// Returns true if buffer_ actually points to a Buffer that has 121 /// been loaded into LyX and is still open. Note that this will 122 /// always return false for cloned Buffers. If you want to allow 123 /// for the case of cloned Buffers, use isBufferValid(). 124 bool isBufferLoaded() const; 125 /// Returns true if this is a loaded buffer or a cloned buffer. 126 bool isBufferValid() const; 127 128 /// initialize view for this inset. 129 /** 130 * This is typically used after this inset is created interactively. 131 * Intented purpose is to sanitize internal state with regard to current 132 * Buffer. 133 **/ initView()134 virtual void initView() {} 135 /// \return true if this inset is labeled. isLabeled()136 virtual bool isLabeled() const { return false; } 137 138 /// identification as math inset asInsetMath()139 virtual InsetMath * asInsetMath() { return 0; } 140 /// identification as math inset asInsetMath()141 virtual InsetMath const * asInsetMath() const { return 0; } 142 /// true for 'math' math inset, but not for e.g. mbox inMathed()143 virtual bool inMathed() const { return false; } 144 /// is this inset based on the InsetText class? asInsetText()145 virtual InsetText * asInsetText() { return 0; } 146 /// is this inset based on the InsetText class? asInsetText()147 virtual InsetText const * asInsetText() const { return 0; } 148 /// is this inset based on the InsetCollapsible class? asInsetCollapsible()149 virtual InsetCollapsible * asInsetCollapsible() { return 0; } 150 /// is this inset based on the InsetCollapsible class? asInsetCollapsible()151 virtual InsetCollapsible const * asInsetCollapsible() const { return 0; } 152 /// is this inset based on the InsetTabular class? asInsetTabular()153 virtual InsetTabular * asInsetTabular() { return 0; } 154 /// is this inset based on the InsetTabular class? asInsetTabular()155 virtual InsetTabular const * asInsetTabular() const { return 0; } 156 /// is this inset based on the InsetCommand class? asInsetCommand()157 virtual InsetCommand * asInsetCommand() { return 0; } 158 /// is this inset based on the InsetCommand class? asInsetCommand()159 virtual InsetCommand const * asInsetCommand() const { return 0; } 160 /// is this inset based on the InsetArgument class? asInsetArgument()161 virtual InsetArgument const * asInsetArgument() const { return nullptr; } 162 163 /// the real dispatcher 164 void dispatch(Cursor & cur, FuncRequest & cmd); 165 /** 166 * \returns true if this function made a definitive decision on 167 * whether the inset wants to handle the request \p cmd or not. 168 * The result of this decision is put into \p status. 169 * 170 * Every request that is enabled in this method needs to be handled 171 * in doDispatch(). Normally we have a 1:1 relationship between the 172 * requests handled in getStatus() and doDispatch(), but there are 173 * some exceptions: 174 * - A request that is disabled in getStatus() does not need to 175 * appear in doDispatch(). It is guaranteed that doDispatch() 176 * is never called with this request. 177 * - A few requests are en- or disabled in Inset::getStatus(). 178 * These need to be handled in the doDispatch() methods of the 179 * derived insets, since Inset::doDispatch() has not enough 180 * information to handle them. 181 * - LFUN_MOUSE_* need not to be handled in getStatus(), because these 182 * are dispatched directly 183 */ 184 virtual bool getStatus(Cursor & cur, FuncRequest const & cmd, 185 FuncStatus & status) const; 186 187 /// cursor enters 188 virtual void edit(Cursor & cur, bool front, 189 EntryDirection entry_from = ENTRY_DIRECTION_IGNORE); 190 /// sets cursor recursively descending into nested editable insets 191 /** 192 \return the inset pointer if x,y is covering that inset 193 \param x,y are absolute screen coordinates. 194 */ 195 /// Note: this method must preserve the selection status. See: 196 /// https://www.mail-archive.com/lyx-devel@lists.lyx.org/msg199001.html 197 virtual Inset * editXY(Cursor & cur, int x, int y); 198 199 /// compute the size of the object returned in dim 200 virtual void metrics(MetricsInfo & mi, Dimension & dim) const = 0; 201 /// draw inset and update (xo, yo)-cache 202 virtual void draw(PainterInfo & pi, int x, int y) const = 0; 203 /// draw inset selection if necessary drawSelection(PainterInfo &,int,int)204 virtual void drawSelection(PainterInfo &, int, int) const {} 205 /// draw inset background if the inset has an own background and a 206 /// selection is drawn by drawSelection. 207 virtual void drawBackground(PainterInfo &, int, int) const; 208 /// 209 virtual bool editing(BufferView const * bv) const; 210 /// 211 virtual bool showInsetDialog(BufferView *) const; 212 213 /// draw two angular markers 214 virtual void drawMarkers(PainterInfo & pi, int x, int y) const; 215 /// add space for markers 216 void metricsMarkers(Dimension & dim, int framesize = 1) const; 217 /// add space for markers 218 void metricsMarkers2(Dimension & dim, int framesize = 1) const; 219 /// draw inset decoration if necessary. 220 /// This can use \c drawMarkers() for example. drawDecoration(PainterInfo &,int,int)221 virtual void drawDecoration(PainterInfo &, int, int) const {} 222 223 /// last metrics computed for the inset 224 Dimension const dimension(BufferView const &) const; 225 /// last drawn position for 'important' insets 226 int xo(BufferView const & bv) const; 227 /// last drawn position for 'important' insets 228 int yo(BufferView const & bv) const; 229 /// do we cover screen position x/y? 230 bool covers(BufferView const & bv, int x, int y) const; 231 /// get the screen positions of the cursor (see note in Cursor.cpp) 232 virtual void cursorPos(BufferView const & bv, 233 CursorSlice const & sl, bool boundary, int & x, int & y) const; 234 235 /// Allow multiple blanks 236 virtual bool isFreeSpacing() const; 237 /// Don't eliminate empty paragraphs 238 virtual bool allowEmpty() const; 239 /// Force inset into LTR environment if surroundings are RTL 240 virtual bool forceLTR(OutputParams const &) const; 241 /// whether to include this inset in the strings generated for the TOC 242 virtual bool isInToc() const; 243 244 /// Where should we go when we press the up or down cursor key? 245 virtual bool idxUpDown(Cursor & cur, bool up) const; 246 /// Move one cell backwards idxBackward(Cursor &)247 virtual bool idxBackward(Cursor &) const { return false; } 248 /// Move one cell forward idxForward(Cursor &)249 virtual bool idxForward(Cursor &) const { return false; } 250 251 /// Move to the next cell idxNext(Cursor &)252 virtual bool idxNext(Cursor &) const { return false; } 253 /// Move to the previous cell idxPrev(Cursor &)254 virtual bool idxPrev(Cursor &) const { return false; } 255 256 /// Target pos when we enter the inset while moving forward idxFirst(Cursor &)257 virtual bool idxFirst(Cursor &) const { return false; } 258 /// Target pos when we enter the inset while moving backwards idxLast(Cursor &)259 virtual bool idxLast(Cursor &) const { return false; } 260 261 /// Delete a cell and move cursor idxDelete(idx_type &)262 virtual bool idxDelete(idx_type &) { return false; } 263 /// pulls cell after pressing erase idxGlue(idx_type)264 virtual void idxGlue(idx_type) {} 265 /// returns list of cell indices that are "between" from and to for 266 /// selection purposes 267 virtual bool idxBetween(idx_type idx, idx_type from, idx_type to) const; 268 269 /// to which column belongs a cell with a given index? col(idx_type)270 virtual col_type col(idx_type) const { return 0; } 271 /// to which row belongs a cell with a given index? row(idx_type)272 virtual row_type row(idx_type) const { return 0; } 273 /// cell index corresponding to row and column; 274 virtual idx_type index(row_type row, col_type col) const; 275 /// number of embedded cells nargs()276 virtual size_t nargs() const { return 0; } 277 /// number of rows in gridlike structures nrows()278 virtual size_t nrows() const { return 0; } 279 /// number of columns in gridlike structures ncols()280 virtual size_t ncols() const { return 0; } 281 /// Is called when the cursor leaves this inset. 282 /// Returns true if cursor is now invalid, e.g. if former 283 /// insets in higher cursor slices of \c old do not exist 284 /// anymore. 285 /// \c old is the old cursor, the last slice points to this. 286 /// \c cur is the new cursor. Use the update flags to cause a redraw. notifyCursorLeaves(Cursor const &,Cursor &)287 virtual bool notifyCursorLeaves(Cursor const & /*old*/, Cursor & /*cur*/) 288 { return false; } 289 /// Is called when the cursor enters this inset. 290 /// Returns true if cursor is now invalid, e.g. if former 291 /// insets in higher cursor slices of \c old do not exist 292 /// anymore. 293 /// \c cur is the new cursor, some slice points to this. Use the update 294 /// flags to cause a redraw. notifyCursorEnters(Cursor &)295 virtual bool notifyCursorEnters(Cursor & /*cur*/) 296 { return false; } 297 /// is called when the mouse enters or leaves this inset 298 /// return true if this inset needs a repaint setMouseHover(BufferView const *,bool)299 virtual bool setMouseHover(BufferView const *, bool) const 300 { return false; } 301 /// return true if this inset is hovered (under mouse) 302 /// This is by now only used by mathed to draw corners 303 /// (Inset::drawMarkers() and Inset::drawMarkers2()). 304 /// Other insets do not have to redefine this function to 305 /// return the correct status of mouseHovered. mouseHovered(BufferView const *)306 virtual bool mouseHovered(BufferView const *) const { return false; } 307 308 /// request "external features" validate(LaTeXFeatures &)309 virtual void validate(LaTeXFeatures &) const {} 310 311 /// Validate LFUN_INSET_MODIFY argument. validateModifyArgument(docstring const &)312 virtual bool validateModifyArgument(docstring const &) const { return true; } 313 314 /// describe content if cursor inside infoize(odocstream &)315 virtual void infoize(odocstream &) const {} 316 /// describe content if cursor behind infoize2(odocstream &)317 virtual void infoize2(odocstream &) const {} 318 319 enum { PLAINTEXT_NEWLINE = 10000 }; 320 321 /// plain text output in ucs4 encoding 322 /// return the number of characters; in case of multiple lines of 323 /// output, add PLAINTEXT_NEWLINE to the number of chars in the last line 324 virtual int plaintext(odocstringstream &, OutputParams const &, 325 size_t max_length = INT_MAX) const = 0; 326 /// docbook output 327 virtual int docbook(odocstream & os, OutputParams const &) const; 328 /// XHTML output 329 /// the inset is expected to write XHTML to the XHTMLStream 330 /// \return any "deferred" material that should be written outside the 331 /// normal stream, and which will in fact be written after the current 332 /// paragraph closes. this is appropriate e.g. for floats. 333 virtual docstring xhtml(XHTMLStream & xs, OutputParams const &) const; 334 335 /// Writes a string representation of the inset to the odocstream. 336 /// This one should be called when you want the whole contents of 337 /// the inset. toString(odocstream &)338 virtual void toString(odocstream &) const {} 339 /// Appends a potentially abbreviated version of the inset to 340 /// \param str. Intended for use by the TOC. 341 virtual void forOutliner(docstring & str, 342 size_t const maxlen = TOC_ENTRY_LENGTH, 343 bool const shorten = true) const; 344 345 /// Can a cursor be put in there ? 346 /// Forced to false for insets that have hidden contents, like 347 /// InsetMathCommand and InsetInfo. isActive()348 virtual bool isActive() const { return nargs() > 0; } 349 /// can the contents of the inset be edited on screen ? 350 // equivalent to isActive except for closed InsetCollapsible 351 virtual bool editable() const; 352 /// has the Inset settings that can be modified in a dialog ? 353 virtual bool hasSettings() const; 354 /// can we go further down on mouse click? 355 /// true for InsetCaption, InsetCollapsibles (not ButtonOnly), InsetTabular descendable(BufferView const &)356 virtual bool descendable(BufferView const &) const { return false; } 357 /// can we click at the specified position ? clickable(BufferView const &,int,int)358 virtual bool clickable(BufferView const &, int, int) const { return false; } 359 /// Move one cell backwards allowsCaptionVariation(std::string const &)360 virtual bool allowsCaptionVariation(std::string const &) const { return false; } 361 // true for insets that have a table structure (InsetMathGrid, InsetTabular) isTable()362 virtual bool isTable() const { return false; } 363 364 /// does this contain text that can be change track marked in DVI? canTrackChanges()365 virtual bool canTrackChanges() const { return false; } 366 /// Will this inset paint its own change tracking status (in the parent 367 /// paragraph) or will it let RowPainter handle it? canPaintChange(BufferView const &)368 virtual bool canPaintChange(BufferView const &) const { return false; } 369 /// return true if the inset should be removed automatically 370 virtual bool autoDelete() const; 371 372 /// Returns true if the inset supports completions. completionSupported(Cursor const &)373 virtual bool completionSupported(Cursor const &) const { return false; } 374 /// Returns true if the inset supports inline completions at the 375 /// cursor position. In this case the completion might be stored 376 /// in the BufferView's inlineCompletion property. inlineCompletionSupported(Cursor const &)377 virtual bool inlineCompletionSupported(Cursor const & /*cur*/) const 378 { return false; } 379 /// Return true if the inline completion should be automatic. automaticInlineCompletion()380 virtual bool automaticInlineCompletion() const { return true; } 381 /// Return true if the popup completion should be automatic. automaticPopupCompletion()382 virtual bool automaticPopupCompletion() const { return true; } 383 /// Return true if the cursor should indicate a completion. showCompletionCursor()384 virtual bool showCompletionCursor() const { return true; } 385 /// Returns completion suggestions at cursor position. Return an 386 /// null pointer if no completion is a available or possible. 387 /// The caller is responsible to free the returned object! createCompletionList(Cursor const &)388 virtual CompletionList const * createCompletionList(Cursor const &) const 389 { return 0; } 390 /// Returns the completion prefix to filter the suggestions for completion. 391 /// This is only called if completionList returned a non-null list. 392 virtual docstring completionPrefix(Cursor const &) const; 393 /// Do a completion at the cursor position. Return true on success. 394 /// The completion does not contain the prefix. If finished is true, the 395 /// completion is final. If finished is false, completion might only be 396 /// a partial completion. insertCompletion(Cursor &,docstring const &,bool)397 virtual bool insertCompletion(Cursor & /*cur*/, 398 docstring const & /*completion*/, bool /*finished*/) 399 { return false; } 400 /// Get the completion inset position and size completionPosAndDim(Cursor const &,int &,int &,Dimension &)401 virtual void completionPosAndDim(Cursor const &, int & /*x*/, int & /*y*/, 402 Dimension & /*dim*/) const {} 403 404 /// returns true if the inset can hold an inset of given type insetAllowed(InsetCode)405 virtual bool insetAllowed(InsetCode) const { return false; } 406 /// should this inset use the empty layout by default rather than 407 /// the standard layout? (default: only if that is forced.) usePlainLayout()408 virtual bool usePlainLayout() const { return forcePlainLayout(); } 409 /// if this inset has paragraphs should they be forced to use the 410 /// empty layout? 411 virtual bool forcePlainLayout(idx_type = 0) const { return false; } 412 /// if this inset has paragraphs should the user be allowed to 413 /// customize alignment, etc? 414 virtual bool allowParagraphCustomization(idx_type = 0) const 415 { return true; } 416 /// Is the width forced to some value? hasFixedWidth()417 virtual bool hasFixedWidth() const { return false; } 418 /// if this inset has paragraphs should they be forced to use a 419 /// local font language switch? forceLocalFontSwitch()420 virtual bool forceLocalFontSwitch() const { return false; } 421 /// Does the inset force a specific encoding? forcedEncoding(Encoding const *,Encoding const *)422 virtual Encoding const * forcedEncoding(Encoding const *, Encoding const *) const 423 { return 0; } 424 425 426 /// Is the content of this inset part of the output document? producesOutput()427 virtual bool producesOutput() const { return true; } 428 /// Is the content of this inset part of the immediate (visible) text sequence? isPartOfTextSequence()429 virtual bool isPartOfTextSequence() const { return producesOutput(); } 430 431 /// \return Tool tip for this inset. 432 /// This default implementation returns an empty string. This can be 433 /// either plain text or Qt html, and formatToolTip will be called 434 /// on it before display in both cases. 435 virtual docstring toolTip(BufferView const & bv, int x, int y) const; 436 437 /// \return Context menu identifier. This function determines 438 /// whose Inset's menu should be shown for the given position. 439 virtual std::string contextMenu(BufferView const & bv, int x, int y) const; 440 441 /// \return Context menu identifier for this inset. 442 /// This default implementation returns an empty string. 443 virtual std::string contextMenuName() const; 444 445 446 virtual docstring layoutName() const; 447 /// 448 virtual InsetLayout const & getLayout() const; 449 /// isPassThru()450 virtual bool isPassThru() const { return getLayout().isPassThru(); } 451 /// Is this inset's layout defined in the document's textclass? 452 bool undefined() const; 453 /// should this inset be handled like a normal character? 454 /// (a character can be a letter or punctuation) isChar()455 virtual bool isChar() const { return false; } 456 /// is this equivalent to a letter? 457 /// (a letter is a character that is considered part of a word) isLetter()458 virtual bool isLetter() const { return false; } 459 /// is this equivalent to a space (which is BTW different from 460 /// a line separator)? isSpace()461 virtual bool isSpace() const { return false; } 462 /// does this inset try to use all available space (like \\hfill does)? isHfill()463 virtual bool isHfill() const { return false; } 464 465 enum DisplayType { 466 Inline = 0, 467 AlignLeft, 468 AlignCenter, 469 AlignRight 470 }; 471 472 /// should we have a non-filled line before this inset? display()473 virtual DisplayType display() const { return Inline; } 474 /// indentation before this inset (only needed for displayed hull insets with fleqn option) indent(BufferView const &)475 virtual int indent(BufferView const &) const { return 0; } 476 /// contentAlignment()477 virtual LyXAlignment contentAlignment() const { return LYX_ALIGN_NONE; } 478 /// should we break lines after this inset? isLineSeparator()479 virtual bool isLineSeparator() const { return false; } 480 /// should paragraph indendation be omitted in any case? neverIndent()481 virtual bool neverIndent() const { return false; } 482 /// dumps content to lyxerr 483 virtual void dump() const; 484 /// write inset in .lyx format write(std::ostream &)485 virtual void write(std::ostream &) const {} 486 /// read inset in .lyx format read(Lexer &)487 virtual void read(Lexer &) {} 488 /** Export the inset to LaTeX. 489 * Don't use a temporary stringstream if the final output is 490 * supposed to go to a file. 491 * \sa Buffer::writeLaTeXSource for the reason. 492 */ latex(otexstream &,OutputParams const &)493 virtual void latex(otexstream &, OutputParams const &) const {} 494 /// returns true to override begin and end inset in file 495 virtual bool directWrite() const; 496 /// allowSpellCheck()497 virtual bool allowSpellCheck() const { return false; } 498 499 /// if this insets owns text cells (e.g. InsetText) return cell num getText(int)500 virtual Text * getText(int /*num*/) const { return 0; } 501 502 /** Adds a LaTeX snippet to the Preview Loader for transformation 503 * into a bitmap image. Does not start the laoding process. 504 * 505 * Most insets have no interest in this capability, so the method 506 * defaults to empty. 507 */ addPreview(DocIterator const &,graphics::PreviewLoader &)508 virtual void addPreview(DocIterator const &, 509 graphics::PreviewLoader &) const {} 510 511 /** Classifies the unicode characters appearing in a math inset 512 * depending on whether they are to be translated as latex 513 * math/text commands or used as math symbols without translation. 514 * 515 * Only math insets have interest in this classification, so the 516 * method defaults to empty. 517 */ initUnicodeMath()518 virtual void initUnicodeMath() const {} 519 520 /// Add an entry to the TocList 521 /// Pass a DocIterator that points at the paragraph containing 522 /// the inset 523 /// 524 /// \param output_active : is the inset active or is it in an inactive 525 /// branch or a note? 526 /// 527 /// \param utype : is the toc being generated for use by the output 528 /// routines? 529 /// 530 /// \param tocbackend : where to add the toc information. addToToc(DocIterator const &,bool,UpdateType,TocBackend &)531 virtual void addToToc(DocIterator const & /* di */, 532 bool /* output_active */, 533 UpdateType /* utype*/, 534 TocBackend & /* tocbackend */) const {} 535 /// Collect BibTeX information collectBibKeys(InsetIterator const &,support::FileNameList &)536 virtual void collectBibKeys(InsetIterator const &, support::FileNameList &) const {} 537 /// Update the counters of this inset and of its contents. 538 /// The boolean indicates whether we are preparing for output, e.g., 539 /// of XHTML. updateBuffer(ParIterator const &,UpdateType)540 virtual void updateBuffer(ParIterator const &, UpdateType) {} 541 542 /// Updates the inset's dialog 543 virtual Buffer const * updateFrontend() const; 544 545 public: 546 /// returns LyX code associated with the inset. Used for TOC, ...) lyxCode()547 virtual InsetCode lyxCode() const { return NO_CODE; } 548 549 /// 550 enum mode_type {UNDECIDED_MODE, TEXT_MODE, MATH_MODE}; 551 /// return text or mathmode if that is possible to determine currentMode()552 virtual mode_type currentMode() const { return UNDECIDED_MODE; } 553 /// returns whether changing mode during latex export is forbidden lockedMode()554 virtual bool lockedMode() const { return false; } 555 /// returns whether only ascii chars are allowed during latex export asciiOnly()556 virtual bool asciiOnly() const { return false; } 557 /// returns whether this inset is allowed in other insets of given mode allowedIn(mode_type)558 virtual bool allowedIn(mode_type) const { return true; } 559 /** 560 * The font is inherited from the parent for LaTeX export if this 561 * method returns true. No open font changes are closed in front of 562 * the inset for LaTeX export, and the font is inherited for all other 563 * exports as well as on screen. 564 * If this method returns false all open font changes are closed in 565 * front of the inset for LaTeX export. The default font is used 566 * inside the inset for all exports and on screen. 567 */ inheritFont()568 virtual bool inheritFont() const { return true; } 569 /** 570 * If this method returns true all explicitly set font attributes 571 * are reset during editing operations. 572 * For copy/paste operations the language is never changed, since 573 * the language of a given text never changes if the text is 574 * formatted differently, while other font attribues like size may 575 * need to change if the text is copied from one environment to 576 * another one. 577 * If this method returns false no font attribute is reset. 578 * The default implementation returns true if the resetFont layout 579 * tag is set and otherwise the negation of inheritFont(), 580 * since inherited inset font attributes do not need to be changed, 581 * and non-inherited ones need to be set explicitly. 582 */ 583 virtual bool resetFontEdit() const; 584 585 /// set the change for the entire inset setChange(Change const &)586 virtual void setChange(Change const &) {} 587 /// accept the changes within the inset acceptChanges()588 virtual void acceptChanges() {} 589 /// reject the changes within the inset rejectChanges()590 virtual void rejectChanges() {} 591 592 /// 593 virtual ColorCode backgroundColor(PainterInfo const &) const; 594 /// 595 virtual ColorCode labelColor() const; 596 // 597 enum { TEXT_TO_INSET_OFFSET = 4 }; 598 599 /// Determine the action of backspace and delete: do we select instead of 600 /// deleting if not already selected? confirmDeletion()601 virtual bool confirmDeletion() const { return false; } 602 603 protected: 604 /// Constructors Inset(Buffer * buf)605 Inset(Buffer * buf) : buffer_(buf) {} Inset(Inset const &)606 Inset(Inset const &) : buffer_(0) {} 607 608 /// replicate ourselves 609 friend class InsetList; 610 friend class MathAtom; 611 virtual Inset * clone() const = 0; 612 613 /** The real dispatcher. 614 * Gets normally called from Cursor::dispatch(). Cursor::dispatch() 615 * assumes the common case of 'LFUN handled, need update'. 616 * This has to be overriden by calling Cursor::undispatched() or 617 * Cursor::noScreenUpdate() if appropriate. 618 * If you need to call the dispatch method of some inset directly 619 * you may have to explicitly request an update at that place. Don't 620 * do it in doDispatch(), since that causes nested updates when 621 * called from Cursor::dispatch(), and these can lead to crashes. 622 * \sa getStatus 623 */ 624 virtual void doDispatch(Cursor & cur, FuncRequest & cmd); 625 626 Buffer * buffer_; 627 }; 628 629 } // namespace lyx 630 631 #endif 632