]> git.lyx.org Git - lyx.git/blob - src/insets/inset.h
replace getFirstParagraph() by getParagraphs()
[lyx.git] / 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
19 #include <vector>
20 #include "LString.h"
21 #include "LColor.h"
22 #include "insetbase.h"
23 #include "frontends/mouse_state.h"
24 #include "support/types.h"
25
26 class LyXFont;
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 int ascent(BufferView *, LyXFont const &) const = 0;
161         ///
162         virtual int descent(BufferView *, LyXFont const &) const = 0;
163         ///
164         virtual int width(BufferView *, LyXFont const &) const = 0;
165         ///
166         virtual void draw(BufferView *, LyXFont const &, int baseline, float & x) const = 0;
167         /// update the inset representation
168         virtual void update(BufferView *, bool = false)
169                 {}
170         /// what appears in the minibuffer when opening
171         virtual string const editMessage() const;
172         ///
173         virtual void edit(BufferView *, int x, int y, mouse_button::state button);
174         ///
175         virtual void edit(BufferView *, bool front = true);
176         ///
177         virtual EDITABLE editable() const;
178         ///
179         virtual bool isTextInset() const { return false; }
180         /// return true if the inset should be removed automatically
181         virtual bool autoDelete() const;
182         /// returns true the inset can hold an inset of given type
183         virtual bool insetAllowed(Inset::Code) const { return false; }
184         /// wrapper around the above
185         bool insetAllowed(Inset * in) const;
186         ///
187         virtual void write(Buffer const *, std::ostream &) const = 0;
188         ///
189         virtual void read(Buffer const *, LyXLex & lex) = 0;
190         /** returns the number of rows (\n's) of generated tex code.
191             fragile == true means, that the inset should take care about
192             fragile commands by adding a \protect before.
193             If the free_spc (freespacing) variable is set, then this inset
194             is in a free-spacing paragraph.
195         */
196         virtual int latex(Buffer const *, std::ostream &, bool fragile,
197                           bool free_spc) const = 0;
198         ///
199         virtual int ascii(Buffer const *,
200                           std::ostream &, int linelen = 0) const = 0;
201         ///
202         virtual int linuxdoc(Buffer const *, std::ostream &) const = 0;
203         ///
204         virtual int docbook(Buffer const *, std::ostream &, bool) const = 0;
205         /// Updates needed features for this inset.
206         virtual void validate(LaTeXFeatures & features) const;
207
208         /// returns LyX code associated with the inset. Used for TOC, ...)
209         virtual Inset::Code lyxCode() const { return NO_CODE; }
210
211         virtual std::vector<string> const getLabelList() const {
212                 return std::vector<string>();
213         }
214
215         ///
216         virtual Inset * clone(Buffer const &, bool same_ids = false) const = 0;
217
218         /// returns true to override begin and end inset in file
219         virtual bool directWrite() const;
220
221         /// Returns true if the inset should be centered alone
222         virtual bool display() const { return false; }
223         /// Changes the display state of the inset
224         virtual void display(bool) {}
225         ///
226         /// returns true if this inset needs a row on it's own
227         ///
228         virtual bool needFullRow() const { return false; }
229         ///
230         void setInsetName(string const & s) { name_ = s; }
231         ///
232         string const & getInsetName() const { return name_; }
233         ///
234         void setOwner(Inset * inset) { owner_ = inset; }
235         ///
236         Inset * owner() const { return owner_; }
237         ///
238         void parOwner(Paragraph * par) { par_owner_ = par; }
239         ///
240         Paragraph * parOwner() const { return par_owner_; }
241         ///
242         void setBackgroundColor(LColor::color);
243         ///
244         LColor::color backgroundColor() const;
245         ///
246         int x() const { return top_x; }
247         ///
248         int y() const { return top_baseline; }
249         //
250         // because we could have fake text insets and have to call this
251         // inside them without cast!!!
252         ///
253         virtual LyXText * getLyXText(BufferView const *,
254                                      bool const recursive = false) const;
255         ///
256         virtual void deleteLyXText(BufferView *, bool = true) const {}
257         ///
258         virtual void resizeLyXText(BufferView *, bool /*force*/= false) const {}
259         /// returns the actuall scroll-value
260         virtual int scroll(bool recursive=true) const {
261                 if (!recursive || !owner_)
262                         return scx;
263                 return 0;
264         }
265
266         /// try to get a inset pointer from it's id if we have
267         /// an inset to give back!
268         virtual Inset * getInsetFromID(int /*id*/) const { return 0; }
269         /// if this insets owns paragraphs (f.ex. InsetText) then it
270         /// should return it's very first one!
271         virtual ParagraphList * getParagraphs(int /*num*/) const { return 0; }
272         ///
273         virtual bool haveParagraphs() const {
274                 return false;
275         }
276
277         /// return the cursor if we own one otherwise giv'em just the
278         /// BufferView cursor to work with.
279         virtual LyXCursor const & cursor(BufferView * bview) const;
280         /// id functions
281         int id() const;
282         ///
283         void id(int id_arg);
284
285         /// used to toggle insets
286         // is the inset open?
287         virtual bool isOpen() const { return false; }
288         /// open the inset
289         virtual void open(BufferView *) {}
290         /// close the inset
291         virtual void close(BufferView *) const {}
292         /// check if the font of the char we want inserting is correct
293         /// and modify it if it is not.
294         virtual bool checkInsertChar(LyXFont &);
295         /// we need this here because collapsed insets are only EDITABLE
296         virtual void setFont(BufferView *, LyXFont const &,
297                          bool toggleall = false, bool selectall = false);
298         ///
299         // needed for spellchecking text
300         ///
301         virtual bool allowSpellcheck() const { return false; }
302
303         // should this inset be handled like a normal charater
304         virtual bool isChar() const { return false; }
305         // is this equivalent to a letter?
306         virtual bool isLetter() const { return false; }
307         // is this equivalent to a space (which is BTW different from
308         // a line separator)?
309         virtual bool isSpace() const { return false; }
310         // should we break lines after this inset?
311         virtual bool isLineSeparator() const { return false; }
312         // if this inset has paragraphs should they be output all as default
313         // paragraphs with "Standard" layout?
314         virtual bool forceDefaultParagraphs(Inset const *) const;
315         /** returns true if, when outputing LaTeX, font changes should
316             be closed before generating this inset. This is needed for
317             insets that may contain several paragraphs */
318         virtual bool noFontChange() const { return false; }
319         //
320         virtual void getDrawFont(LyXFont &) const {}
321         /* needed for widths which are % of something
322            returns the value of \textwidth in this inset. Most of the
323            time this is the width of the workarea, but if there is a
324            minipage somewhere, it will be the width of this minipage */
325         virtual int latexTextWidth(BufferView *) const;
326
327         /// mark the inset contents as erased (for change tracking)
328         virtual void markErased() {}
329
330         /** Adds a LaTeX snippet to the Preview Loader for transformation
331          *  into a bitmap image. Does not start the laoding process.
332          *
333          *  Most insets have no interest in this capability, so the method
334          *  defaults to empty.
335          */
336         virtual void addPreview(grfx::PreviewLoader &) const {}
337
338         /** Find the PreviewLoader, add a LaTeX snippet to it and
339          *  start the loading process.
340          *
341          *  Most insets have no interest in this capability, so the method
342          *  defaults to empty.
343          */
344         virtual void generatePreview() const {}
345
346 protected:
347         ///
348         mutable int top_x;
349         ///
350         mutable int top_baseline;
351         ///
352         mutable int scx;
353         ///
354         unsigned int id_;
355         ///
356         static unsigned int inset_id;
357
358 private:
359         ///
360         Inset * owner_;
361         /// the paragraph in which this inset has been inserted
362         Paragraph * par_owner_;
363         ///
364         string name_;
365         ///
366         LColor::color background_color_;
367 };
368
369
370 inline
371 bool Inset::insetAllowed(Inset * in) const
372 {
373         return insetAllowed(in->lyxCode());
374 }
375
376
377 inline
378 bool Inset::checkInsertChar(LyXFont &)
379 {
380         return false;
381 }
382
383 /**
384  * returns true if pointer argument is valid
385  * and points to an editable inset
386  */
387 inline bool isEditableInset(Inset const * i)
388 {
389         return i && i->editable();
390 }
391
392 /**
393  * returns true if pointer argument is valid
394  * and points to a highly editable inset
395  */
396 inline bool isHighlyEditableInset(Inset const * i)
397 {
398         return i && i->editable() == Inset::HIGHLY_EDITABLE;
399 }
400
401 #endif