src/insets/inset.h

   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 INSET_H
  16 #define INSET_H
  17
  18 #include "LString.h"
  19 #include "LColor.h"
  20 #include "insetbase.h"
  21 #include "support/types.h"
  22
  23 #include <vector>
  24
  25 class LyXFont;
  26 class Dimension;
  27 class Buffer;
  28 class Painter;
  29 class LyXText;
  30 class LyXLex;
  31 class Paragraph;
  32 class ParagraphList;
  33 class LyXCursor;
  34 class FuncRequest;
  35 class WordLangTuple;
  36
  37 struct LaTeXFeatures;
  38
  39 namespace grfx {
  40         class PreviewLoader;
  41 }
  42
  43 /// Insets
  44 class Inset : public InsetBase {
  45 public:
  46         /** This is not quite the correct place for this enum. I think
  47             the correct would be to let each subclass of Inset declare
  48             its own enum code. Actually the notion of an Inset::Code
  49             should be avoided, but I am not sure how this could be done
  50             in a cleaner way. */
  51         enum Code {
  52                 ///
  53                 NO_CODE,
  54                 ///
  55                 TOC_CODE,  // do these insets really need a code? (ale)
  56                 ///
  57                 QUOTE_CODE,
  58                 ///
  59                 MARK_CODE,
  60                 ///
  61                 REF_CODE, // 5
  62                 ///
  63                 URL_CODE,
  64                 ///
  65                 HTMLURL_CODE,
  66                 ///
  67                 SEPARATOR_CODE,
  68                 ///
  69                 ENDING_CODE,
  70                 ///
  71                 LABEL_CODE, // 10
  72                 ///
  73                 NOTE_CODE,
  74                 ///
  75                 ACCENT_CODE,
  76                 ///
  77                 MATH_CODE,
  78                 ///
  79                 INDEX_CODE,
  80                 ///
  81                 INCLUDE_CODE, // 15
  82                 ///
  83                 GRAPHICS_CODE,
  84                 ///
  85                 PARENT_CODE,
  86                 ///
  87                 BIBITEM_CODE,
  88                 ///
  89                 BIBTEX_CODE,
  90                 ///
  91                 TEXT_CODE,
  92                 ///
  93                 ERT_CODE, // 20
  94                 ///
  95                 FOOT_CODE,
  96                 ///
  97                 MARGIN_CODE,
  98                 ///
  99                 FLOAT_CODE,
 100                 ///
 101                 WRAP_CODE,
 102                 ///
 103                 MINIPAGE_CODE,
 104                 ///
 105                 SPECIALCHAR_CODE, // 25
 106                 ///
 107                 TABULAR_CODE,
 108                 ///
 109                 EXTERNAL_CODE,
 110 #if 0
 111                 ///
 112                 THEOREM_CODE,
 113 #endif
 114                 ///
 115                 CAPTION_CODE,
 116                 ///
 117                 MATHMACRO_CODE, // 30
 118                 ///
 119                 ERROR_CODE,
 120                 ///
 121                 CITE_CODE,
 122                 ///
 123                 FLOAT_LIST_CODE,
 124                 ///
 125                 INDEX_PRINT_CODE,
 126                 ///
 127                 OPTARG_CODE,
 128                 ///
 129                 ENVIRONMENT_CODE,
 130                 ///
 131                 HFILL_CODE,
 132                 ///
 133                 NEWLINE_CODE
 134         };
 135
 136         ///
 137         enum {
 138                 ///
 139                 TEXT_TO_INSET_OFFSET = 2
 140         };
 141
 142         ///
 143         enum EDITABLE {
 144                 ///
 145                 NOT_EDITABLE = 0,
 146                 ///
 147                 IS_EDITABLE,
 148                 ///
 149                 HIGHLY_EDITABLE
 150         };
 151
 152         ///
 153         typedef dispatch_result RESULT;
 154
 155         ///
 156         Inset();
 157         ///
 158         Inset(Inset const & in, bool same_id = false);
 159         ///
 160         virtual void dimension(BufferView *, LyXFont const &, Dimension &) const = 0;
 161         ///
 162         int ascent(BufferView *, LyXFont const &) const;
 163         ///
 164         int descent(BufferView *, LyXFont const &) const;
 165         ///
 166         int width(BufferView *, LyXFont const &) const;
 167         ///
 168         virtual void draw(BufferView *, LyXFont const &, int baseline, float & x) const = 0;
 169         /// update the inset representation
 170         virtual void update(BufferView *, bool = false)
 171                 {}
 172         /// what appears in the minibuffer when opening
 173         virtual string const editMessage() const;
 174         ///
 175         virtual EDITABLE editable() const;
 176         ///
 177         virtual bool isTextInset() const { return false; }
 178         /// return true if the inset should be removed automatically
 179         virtual bool autoDelete() const;
 180         /// returns true the inset can hold an inset of given type
 181         virtual bool insetAllowed(Inset::Code) const { return false; }
 182         /// wrapper around the above
 183         bool insetAllowed(Inset * in) const;
 184         ///
 185         virtual void write(Buffer const *, std::ostream &) const = 0;
 186         ///
 187         virtual void read(Buffer const *, LyXLex & lex) = 0;
 188         /** returns the number of rows (\n's) of generated tex code.
 189             fragile == true means, that the inset should take care about
 190             fragile commands by adding a \protect before.
 191             If the free_spc (freespacing) variable is set, then this inset
 192             is in a free-spacing paragraph.
 193         */
 194         virtual int latex(Buffer const *, std::ostream &, bool fragile,
 195                           bool free_spc) const = 0;
 196         ///
 197         virtual int ascii(Buffer const *,
 198                           std::ostream &, int linelen = 0) const = 0;
 199         ///
 200         virtual int linuxdoc(Buffer const *, std::ostream &) const = 0;
 201         ///
 202         virtual int docbook(Buffer const *, std::ostream &, bool) const = 0;
 203         /// Updates needed features for this inset.
 204         virtual void validate(LaTeXFeatures & features) const;
 205
 206         /// returns LyX code associated with the inset. Used for TOC, ...)
 207         virtual Inset::Code lyxCode() const { return NO_CODE; }
 208
 209         virtual std::vector<string> const getLabelList() const {
 210                 return std::vector<string>();
 211         }
 212
 213         ///
 214         virtual Inset * clone(Buffer const &, bool same_ids = false) const = 0;
 215
 216         /// returns true to override begin and end inset in file
 217         virtual bool directWrite() const;
 218
 219         /// Returns true if the inset should be centered alone
 220         virtual bool display() const { return false; }
 221         /// Changes the display state of the inset
 222         virtual void display(bool) {}
 223         ///
 224         /// returns true if this inset needs a row on it's own
 225         ///
 226         virtual bool needFullRow() const { return false; }
 227         ///
 228         void setInsetName(string const & s) { name_ = s; }
 229         ///
 230         string const & getInsetName() const { return name_; }
 231         ///
 232         void setOwner(Inset * inset) { owner_ = inset; }
 233         ///
 234         Inset * owner() const { return owner_; }
 235         ///
 236         void parOwner(Paragraph * par) { par_owner_ = par; }
 237         ///
 238         Paragraph * parOwner() const { return par_owner_; }
 239         ///
 240         void setBackgroundColor(LColor::color);
 241         ///
 242         LColor::color backgroundColor() const;
 243         ///
 244         int x() const { return top_x; }
 245         ///
 246         int y() const { return top_baseline; }
 247         //
 248         // because we could have fake text insets and have to call this
 249         // inside them without cast!!!
 250         ///
 251         virtual LyXText * getLyXText(BufferView const *,
 252                                      bool const recursive = false) const;
 253         ///
 254         virtual void deleteLyXText(BufferView *, bool = true) const {}
 255         ///
 256         virtual void resizeLyXText(BufferView *, bool /*force*/= false) const {}
 257         /// returns the actuall scroll-value
 258         virtual int scroll(bool recursive=true) const {
 259                 if (!recursive || !owner_)
 260                         return scx;
 261                 return 0;
 262         }
 263
 264         /// try to get a inset pointer from it's id if we have
 265         /// an inset to give back!
 266         virtual Inset * getInsetFromID(int /*id*/) const { return 0; }
 267         /// if this insets owns paragraphs (f.ex. InsetText) then it
 268         /// should return it's very first one!
 269         virtual ParagraphList * getParagraphs(int /*num*/) const { return 0; }
 270         ///
 271         virtual bool haveParagraphs() const {
 272                 return false;
 273         }
 274
 275         /// return the cursor if we own one otherwise giv'em just the
 276         /// BufferView cursor to work with.
 277         virtual LyXCursor const & cursor(BufferView * bview) const;
 278         /// id functions
 279         int id() const;
 280         ///
 281         void id(int id_arg);
 282
 283         /// used to toggle insets
 284         // is the inset open?
 285         virtual bool isOpen() const { return false; }
 286         /// open the inset
 287         virtual void open(BufferView *) {}
 288         /// close the inset
 289         virtual void close(BufferView *) const {}
 290         /// check if the font of the char we want inserting is correct
 291         /// and modify it if it is not.
 292         virtual bool checkInsertChar(LyXFont &);
 293         /// we need this here because collapsed insets are only EDITABLE
 294         virtual void setFont(BufferView *, LyXFont const &,
 295                          bool toggleall = false, bool selectall = false);
 296         ///
 297         // needed for spellchecking text
 298         ///
 299         virtual bool allowSpellcheck() const { return false; }
 300
 301         // should this inset be handled like a normal charater
 302         virtual bool isChar() const { return false; }
 303         // is this equivalent to a letter?
 304         virtual bool isLetter() const { return false; }
 305         // is this equivalent to a space (which is BTW different from
 306         // a line separator)?
 307         virtual bool isSpace() const { return false; }
 308         // should we break lines after this inset?
 309         virtual bool isLineSeparator() const { return false; }
 310         // if this inset has paragraphs should they be output all as default
 311         // paragraphs with "Standard" layout?
 312         virtual bool forceDefaultParagraphs(Inset const *) const;
 313         /** returns true if, when outputing LaTeX, font changes should
 314             be closed before generating this inset. This is needed for
 315             insets that may contain several paragraphs */
 316         virtual bool noFontChange() const { return false; }
 317         //
 318         virtual void getDrawFont(LyXFont &) const {}
 319         /* needed for widths which are % of something
 320            returns the value of \textwidth in this inset. Most of the
 321            time this is the width of the workarea, but if there is a
 322            minipage somewhere, it will be the width of this minipage */
 323         virtual int latexTextWidth(BufferView *) const;
 324
 325         /// mark the inset contents as erased (for change tracking)
 326         virtual void markErased() {}
 327
 328         /** Adds a LaTeX snippet to the Preview Loader for transformation
 329          *  into a bitmap image. Does not start the laoding process.
 330          *
 331          *  Most insets have no interest in this capability, so the method
 332          *  defaults to empty.
 333          */
 334         virtual void addPreview(grfx::PreviewLoader &) const {}
 335
 336         /** Find the PreviewLoader, add a LaTeX snippet to it and
 337          *  start the loading process.
 338          *
 339          *  Most insets have no interest in this capability, so the method
 340          *  defaults to empty.
 341          */
 342         virtual void generatePreview() const {}
 343
 344 protected:
 345         ///
 346         mutable int top_x;
 347         ///
 348         mutable int top_baseline;
 349         ///
 350         mutable int scx;
 351         ///
 352         unsigned int id_;
 353         ///
 354         static unsigned int inset_id;
 355
 356 private:
 357         ///
 358         Inset * owner_;
 359         /// the paragraph in which this inset has been inserted
 360         Paragraph * par_owner_;
 361         ///
 362         string name_;
 363         ///
 364         LColor::color background_color_;
 365 };
 366
 367
 368 inline
 369 bool Inset::insetAllowed(Inset * in) const
 370 {
 371         return insetAllowed(in->lyxCode());
 372 }
 373
 374
 375 inline
 376 bool Inset::checkInsertChar(LyXFont &)
 377 {
 378         return false;
 379 }
 380
 381 /**
 382  * returns true if pointer argument is valid
 383  * and points to an editable inset
 384  */
 385 inline bool isEditableInset(Inset const * i)
 386 {
 387         return i && i->editable();
 388 }
 389
 390 /**
 391  * returns true if pointer argument is valid
 392  * and points to a highly editable inset
 393  */
 394 inline bool isHighlyEditableInset(Inset const * i)
 395 {
 396         return i && i->editable() == Inset::HIGHLY_EDITABLE;
 397 }
 398
 399 #endif