]> git.lyx.org Git - features.git/blob - src/insets/InsetNote.cpp
* InsetNote::addToToc(): Prefix toc entries with note type.
[features.git] / src / insets / InsetNote.cpp
1 /**
2  * \file InsetNote.cpp
3  * This file is part of LyX, the document processor.
4  * Licence details can be found in the file COPYING.
5  *
6  * \author Angus Leeming
7  * \author Martin Vermeer
8  * \author Jürgen Spitzmüller
9  *
10  * Full author contact details are available in file CREDITS.
11  */
12
13 #include <config.h>
14
15 #include "InsetNote.h"
16
17 #include "Buffer.h"
18 #include "BufferParams.h"
19 #include "BufferView.h"
20 #include "BufferParams.h"
21 #include "Counters.h"
22 #include "Cursor.h"
23 #include "DispatchResult.h"
24 #include "Exporter.h"
25 #include "FuncRequest.h"
26 #include "FuncStatus.h"
27 #include "support/gettext.h"
28 #include "LaTeXFeatures.h"
29 #include "Lexer.h"
30 #include "MetricsInfo.h"
31 #include "OutputParams.h"
32 #include "ParIterator.h"
33 #include "TextClass.h"
34 #include "TocBackend.h"
35
36 #include "support/debug.h"
37 #include "support/docstream.h"
38 #include "support/Translator.h"
39
40 #include <algorithm>
41 #include <sstream>
42
43 using namespace std;
44
45 namespace lyx {
46
47 namespace {
48
49 typedef Translator<string, InsetNoteParams::Type> NoteTranslator;
50 typedef Translator<docstring, InsetNoteParams::Type> NoteTranslatorLoc;
51
52 NoteTranslator const init_notetranslator()
53 {
54         NoteTranslator translator("Note", InsetNoteParams::Note);
55         translator.addPair("Comment", InsetNoteParams::Comment);
56         translator.addPair("Greyedout", InsetNoteParams::Greyedout);
57         return translator;
58 }
59
60
61 NoteTranslatorLoc const init_notetranslator_loc()
62 {
63         NoteTranslatorLoc translator(_("Note[[InsetNote]]"), InsetNoteParams::Note);
64         translator.addPair(_("Comment"), InsetNoteParams::Comment);
65         translator.addPair(_("Greyed out"), InsetNoteParams::Greyedout);
66         return translator;
67 }
68
69
70 NoteTranslator const & notetranslator()
71 {
72         static NoteTranslator translator = init_notetranslator();
73         return translator;
74 }
75
76
77 NoteTranslatorLoc const & notetranslator_loc()
78 {
79         static NoteTranslatorLoc translator = init_notetranslator_loc();
80         return translator;
81 }
82
83 } // anon
84
85
86
87
88 InsetNoteParams::InsetNoteParams()
89         : type(Note)
90 {}
91
92
93 void InsetNoteParams::write(ostream & os) const
94 {
95         string const label = notetranslator().find(type);
96         os << "Note " << label << "\n";
97 }
98
99
100 void InsetNoteParams::read(Lexer & lex)
101 {
102         string label;
103         lex >> label;
104         if (lex)
105                 type = notetranslator().find(label);
106 }
107
108
109 InsetNote::InsetNote(BufferParams const & bp, string const & label)
110         : InsetCollapsable(bp)
111 {
112         params_.type = notetranslator().find(label);
113 }
114
115
116 InsetNote::InsetNote(InsetNote const & in)
117         : InsetCollapsable(in), params_(in.params_)
118 {}
119
120
121 InsetNote::~InsetNote()
122 {
123         InsetNoteMailer(*this).hideDialog();
124 }
125
126
127 Inset * InsetNote::clone() const
128 {
129         return new InsetNote(*this);
130 }
131
132
133 docstring const InsetNote::editMessage() const
134 {
135         return _("Opened Note Inset");
136 }
137
138
139 docstring InsetNote::name() const 
140 {
141         return from_ascii("Note:" + notetranslator().find(params_.type));
142 }
143
144
145 Inset::DisplayType InsetNote::display() const
146 {
147         return Inline;
148 }
149
150
151 void InsetNote::write(Buffer const & buf, ostream & os) const
152 {
153         params_.write(os);
154         InsetCollapsable::write(buf, os);
155 }
156
157
158 void InsetNote::read(Buffer const & buf, Lexer & lex)
159 {
160         params_.read(lex);
161         InsetCollapsable::read(buf, lex);
162 }
163
164
165 void InsetNote::setButtonLabel()
166 {
167         docstring const label = notetranslator_loc().find(params_.type);
168         setLabel(label);
169 }
170
171
172 bool InsetNote::showInsetDialog(BufferView * bv) const
173 {
174         InsetNoteMailer(const_cast<InsetNote &>(*this)).showDialog(bv);
175         return true;
176 }
177
178
179 void InsetNote::doDispatch(Cursor & cur, FuncRequest & cmd)
180 {
181         switch (cmd.action) {
182
183         case LFUN_INSET_MODIFY:
184                 InsetNoteMailer::string2params(to_utf8(cmd.argument()), params_);
185                 // get a bp from cur:
186                 setLayout(cur.buffer().params());
187                 break;
188
189         case LFUN_INSET_DIALOG_UPDATE:
190                 InsetNoteMailer(*this).updateDialog(&cur.bv());
191                 break;
192         default:
193                 InsetCollapsable::doDispatch(cur, cmd);
194                 break;
195         }
196 }
197
198
199 bool InsetNote::getStatus(Cursor & cur, FuncRequest const & cmd,
200                 FuncStatus & flag) const
201 {
202         switch (cmd.action) {
203
204         case LFUN_INSET_MODIFY:
205         case LFUN_INSET_DIALOG_UPDATE:
206                 flag.enabled(true);
207                 return true;
208
209         default:
210                 return InsetCollapsable::getStatus(cur, cmd, flag);
211         }
212 }
213
214 void InsetNote::updateLabels(Buffer const & buf, ParIterator const & it)
215 {
216         TextClass const & tclass = buf.params().getTextClass();
217         Counters savecnt = tclass.counters();
218         InsetCollapsable::updateLabels(buf, it);
219         tclass.counters() = savecnt;
220 }
221
222
223 void InsetNote::addToToc(TocList & toclist, Buffer const & /*buf*/, ParConstIterator const &) const
224 {
225         ParConstIterator pit = par_const_iterator_begin(*this);
226
227         Toc & toc = toclist["note"];
228         docstring const str = notetranslator_loc().find(params_.type)
229                 + from_ascii(": ") + getNewLabel(str);
230         toc.push_back(TocItem(pit, 0, str));
231 }
232
233
234 bool InsetNote::isMacroScope(Buffer const & buf) const
235 {
236         // LyX note has no latex output
237         if (params_.type == InsetNoteParams::Note)
238                 return true;
239
240         return InsetCollapsable::isMacroScope(buf);
241 }
242
243
244 int InsetNote::latex(Buffer const & buf, odocstream & os,
245                      OutputParams const & runparams_in) const
246 {
247         if (params_.type == InsetNoteParams::Note)
248                 return 0;
249
250         OutputParams runparams(runparams_in);
251         if (params_.type == InsetNoteParams::Comment) {
252                 runparams.inComment = true;
253                 // Ignore files that are exported inside a comment
254                 runparams.exportdata.reset(new ExportData);
255         } 
256
257         odocstringstream ss;
258         InsetCollapsable::latex(buf, ss, runparams);
259         // the space after the comment in 'a[comment] b' will be eaten by the
260         // comment environment since the space before b is ignored with the
261         // following latex output:
262         //
263         // a%
264         // \begin{comment}
265         // comment
266         // \end{comment}
267         //  b
268         //
269         // Adding {} before ' b' fixes this.
270         if (params_.type == InsetNoteParams::Comment)
271                 ss << "{}";
272
273         docstring const str = ss.str();
274         os << str;
275         runparams_in.encoding = runparams.encoding;
276         // Return how many newlines we issued.
277         return int(count(str.begin(), str.end(), '\n'));
278 }
279
280
281 int InsetNote::plaintext(Buffer const & buf, odocstream & os,
282                          OutputParams const & runparams_in) const
283 {
284         if (params_.type == InsetNoteParams::Note)
285                 return 0;
286
287         OutputParams runparams(runparams_in);
288         if (params_.type == InsetNoteParams::Comment) {
289                 runparams.inComment = true;
290                 // Ignore files that are exported inside a comment
291                 runparams.exportdata.reset(new ExportData);
292         }
293         os << '[' << buf.B_("note") << ":\n";
294         InsetText::plaintext(buf, os, runparams);
295         os << "\n]";
296
297         return PLAINTEXT_NEWLINE + 1; // one char on a separate line
298 }
299
300
301 int InsetNote::docbook(Buffer const & buf, odocstream & os,
302                        OutputParams const & runparams_in) const
303 {
304         if (params_.type == InsetNoteParams::Note)
305                 return 0;
306
307         OutputParams runparams(runparams_in);
308         if (params_.type == InsetNoteParams::Comment) {
309                 os << "<remark>\n";
310                 runparams.inComment = true;
311                 // Ignore files that are exported inside a comment
312                 runparams.exportdata.reset(new ExportData);
313         }
314
315         int const n = InsetText::docbook(buf, os, runparams);
316
317         if (params_.type == InsetNoteParams::Comment)
318                 os << "\n</remark>\n";
319
320         // Return how many newlines we issued.
321         //return int(count(str.begin(), str.end(), '\n'));
322         return n + 1 + 2;
323 }
324
325
326 void InsetNote::validate(LaTeXFeatures & features) const
327 {
328         if (params_.type == InsetNoteParams::Comment)
329                 features.require("verbatim");
330         if (params_.type == InsetNoteParams::Greyedout) {
331                 features.require("color");
332                 features.require("lyxgreyedout");
333         }
334         InsetText::validate(features);
335 }
336
337
338
339 string const InsetNoteMailer::name_("note");
340
341 InsetNoteMailer::InsetNoteMailer(InsetNote & inset)
342         : inset_(inset)
343 {}
344
345
346 string const InsetNoteMailer::inset2string(Buffer const &) const
347 {
348         return params2string(inset_.params());
349 }
350
351
352 string const InsetNoteMailer::params2string(InsetNoteParams const & params)
353 {
354         ostringstream data;
355         data << name_ << ' ';
356         params.write(data);
357         return data.str();
358 }
359
360
361 void InsetNoteMailer::string2params(string const & in,
362                                     InsetNoteParams & params)
363 {
364         params = InsetNoteParams();
365
366         if (in.empty())
367                 return;
368
369         istringstream data(in);
370         Lexer lex(0,0);
371         lex.setStream(data);
372
373         string name;
374         lex >> name;
375         if (!lex || name != name_)
376                 return print_mailer_error("InsetNoteMailer", in, 1, name_);
377
378         // This is part of the inset proper that is usually swallowed
379         // by Text::readInset
380         string id;
381         lex >> id;
382         if (!lex || id != "Note")
383                 return print_mailer_error("InsetBoxMailer", in, 2, "Note");
384
385         params.read(lex);
386 }
387
388
389 } // namespace lyx