]> git.lyx.org Git - lyx.git/blob - src/insets/InsetNote.cpp
ed47e40e2271fe463fcd15e6b0a33f6228d7b862
[lyx.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 "InsetIterator.h"
28 #include "LaTeXFeatures.h"
29 #include "Lexer.h"
30 #include "LyXRC.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/gettext.h"
39 #include "support/Translator.h"
40
41 #include "frontends/Application.h"
42
43 #include <algorithm>
44 #include <sstream>
45
46 using namespace std;
47
48 namespace lyx {
49
50 namespace {
51
52 typedef Translator<string, InsetNoteParams::Type> NoteTranslator;
53 typedef Translator<docstring, InsetNoteParams::Type> NoteTranslatorLoc;
54
55 NoteTranslator const init_notetranslator()
56 {
57         NoteTranslator translator("Note", InsetNoteParams::Note);
58         translator.addPair("Comment", InsetNoteParams::Comment);
59         translator.addPair("Greyedout", InsetNoteParams::Greyedout);
60         return translator;
61 }
62
63
64 NoteTranslator const & notetranslator()
65 {
66         static NoteTranslator translator = init_notetranslator();
67         return translator;
68 }
69
70
71 } // anon
72
73
74 InsetNoteParams::InsetNoteParams()
75         : type(Note)
76 {}
77
78
79 void InsetNoteParams::write(ostream & os) const
80 {
81         string const label = notetranslator().find(type);
82         os << "Note " << label << "\n";
83 }
84
85
86 void InsetNoteParams::read(Lexer & lex)
87 {
88         string label;
89         lex >> label;
90         if (lex)
91                 type = notetranslator().find(label);
92 }
93
94
95 /////////////////////////////////////////////////////////////////////
96 //
97 // InsetNote
98 //
99 /////////////////////////////////////////////////////////////////////
100
101 InsetNote::InsetNote(Buffer * buf, string const & label)
102         : InsetCollapsable(buf)
103 {
104         params_.type = notetranslator().find(label);
105 }
106
107
108 InsetNote::~InsetNote()
109 {
110         hideDialogs("note", this);
111 }
112
113
114 docstring InsetNote::name() const 
115 {
116         return from_ascii("Note:" + notetranslator().find(params_.type));
117 }
118
119
120 Inset::DisplayType InsetNote::display() const
121 {
122         return Inline;
123 }
124
125
126 void InsetNote::write(ostream & os) const
127 {
128         params_.write(os);
129         InsetCollapsable::write(os);
130 }
131
132
133 void InsetNote::read(Lexer & lex)
134 {
135         params_.read(lex);
136         InsetCollapsable::read(lex);
137 }
138
139
140 bool InsetNote::showInsetDialog(BufferView * bv) const
141 {
142         bv->showDialog("note", params2string(params()),
143                 const_cast<InsetNote *>(this));
144         return true;
145 }
146
147
148 void InsetNote::doDispatch(Cursor & cur, FuncRequest & cmd)
149 {
150         switch (cmd.action()) {
151
152         case LFUN_INSET_MODIFY:
153                 cur.recordUndoInset(ATOMIC_UNDO, this);
154                 string2params(to_utf8(cmd.argument()), params_);
155                 setButtonLabel();
156                 // what we really want here is a TOC update, but that means
157                 // a full buffer update
158                 cur.forceBufferUpdate();
159                 break;
160
161         case LFUN_INSET_DIALOG_UPDATE:
162                 cur.bv().updateDialog("note", params2string(params()));
163                 break;
164
165         default:
166                 InsetCollapsable::doDispatch(cur, cmd);
167                 break;
168         }
169 }
170
171
172 bool InsetNote::getStatus(Cursor & cur, FuncRequest const & cmd,
173                 FuncStatus & flag) const
174 {
175         switch (cmd.action()) {
176
177         case LFUN_INSET_MODIFY:
178                 // disallow comment and greyed out in commands
179                 flag.setEnabled(!cur.paragraph().layout().isCommand() ||
180                                 cmd.getArg(2) == "Note");
181                 if (cmd.getArg(0) == "note") {
182                         InsetNoteParams params;
183                         string2params(to_utf8(cmd.argument()), params);
184                         flag.setOnOff(params_.type == params.type);
185                 }
186                 return true;
187
188         case LFUN_INSET_DIALOG_UPDATE:
189                 flag.setEnabled(true);
190                 return true;
191
192         default:
193                 return InsetCollapsable::getStatus(cur, cmd, flag);
194         }
195 }
196
197
198 void InsetNote::addToToc(DocIterator const & cpit)
199 {
200         DocIterator pit = cpit;
201         pit.push_back(CursorSlice(*this));
202
203         Toc & toc = buffer().tocBackend().toc("note");
204         InsetLayout const & il = getLayout();
205         docstring str = translateIfPossible(il.labelstring()) + from_ascii(": ");
206         text().forToc(str, TOC_ENTRY_LENGTH);
207         toc.push_back(TocItem(pit, 0, str, toolTipText()));
208         // Proceed with the rest of the inset.
209         InsetCollapsable::addToToc(cpit);
210 }
211
212
213 bool InsetNote::isMacroScope() const
214 {
215         // LyX note has no latex output
216         if (params_.type == InsetNoteParams::Note)
217                 return true;
218
219         return InsetCollapsable::isMacroScope();
220 }
221
222
223 int InsetNote::latex(odocstream & os, OutputParams const & runparams_in) const
224 {
225         if (params_.type == InsetNoteParams::Note)
226                 return 0;
227
228         OutputParams runparams(runparams_in);
229         if (params_.type == InsetNoteParams::Comment) {
230                 runparams.inComment = true;
231                 // Ignore files that are exported inside a comment
232                 runparams.exportdata.reset(new ExportData);
233         } 
234
235         odocstringstream ss;
236         InsetCollapsable::latex(ss, runparams);
237         // the space after the comment in 'a[comment] b' will be eaten by the
238         // comment environment since the space before b is ignored with the
239         // following latex output:
240         //
241         // a%
242         // \begin{comment}
243         // comment
244         // \end{comment}
245         //  b
246         //
247         // Adding {} before ' b' fixes this.
248         if (params_.type == InsetNoteParams::Comment)
249                 ss << "{}";
250
251         docstring const str = ss.str();
252         os << str;
253         runparams_in.encoding = runparams.encoding;
254         // Return how many newlines we issued.
255         return int(count(str.begin(), str.end(), '\n'));
256 }
257
258
259 int InsetNote::plaintext(odocstream & os,
260                          OutputParams const & runparams_in) const
261 {
262         if (params_.type == InsetNoteParams::Note)
263                 return 0;
264
265         OutputParams runparams(runparams_in);
266         if (params_.type == InsetNoteParams::Comment) {
267                 runparams.inComment = true;
268                 // Ignore files that are exported inside a comment
269                 runparams.exportdata.reset(new ExportData);
270         }
271         os << '[' << buffer().B_("note") << ":\n";
272         InsetText::plaintext(os, runparams);
273         os << "\n]";
274
275         return PLAINTEXT_NEWLINE + 1; // one char on a separate line
276 }
277
278
279 int InsetNote::docbook(odocstream & os, OutputParams const & runparams_in) const
280 {
281         if (params_.type == InsetNoteParams::Note)
282                 return 0;
283
284         OutputParams runparams(runparams_in);
285         if (params_.type == InsetNoteParams::Comment) {
286                 os << "<remark>\n";
287                 runparams.inComment = true;
288                 // Ignore files that are exported inside a comment
289                 runparams.exportdata.reset(new ExportData);
290         }
291
292         int const n = InsetText::docbook(os, runparams);
293
294         if (params_.type == InsetNoteParams::Comment)
295                 os << "\n</remark>\n";
296
297         // Return how many newlines we issued.
298         //return int(count(str.begin(), str.end(), '\n'));
299         return n + 1 + 2;
300 }
301
302
303 docstring InsetNote::xhtml(XHTMLStream & xs, OutputParams const & rp) const
304 {
305         if (params_.type == InsetNoteParams::Note)
306                 return docstring();
307
308         return InsetCollapsable::xhtml(xs, rp);
309 }
310
311
312 void InsetNote::validate(LaTeXFeatures & features) const
313 {
314         switch (params_.type) {
315         case InsetNoteParams::Comment:
316                 features.require("verbatim");
317                 break;
318         case InsetNoteParams::Greyedout:
319                 features.require("color");
320                 features.require("lyxgreyedout");
321                 InsetCollapsable::validate(features);
322                 break;
323         case InsetNoteParams::Note:
324                 break;
325         }
326 }
327
328
329 docstring InsetNote::contextMenuName() const
330 {
331         return from_ascii("context-note");
332 }
333
334 bool InsetNote::allowSpellCheck() const
335 {
336         return (params_.type == InsetNoteParams::Greyedout || lyxrc.spellcheck_notes);
337 }
338
339
340 string InsetNote::params2string(InsetNoteParams const & params)
341 {
342         ostringstream data;
343         data << "note" << ' ';
344         params.write(data);
345         return data.str();
346 }
347
348
349 void InsetNote::string2params(string const & in, InsetNoteParams & params)
350 {
351         params = InsetNoteParams();
352
353         if (in.empty())
354                 return;
355
356         istringstream data(in);
357         Lexer lex;
358         lex.setStream(data);
359         lex.setContext("InsetNote::string2params");
360         lex >> "note";
361         // There are cases, such as when we are called via getStatus() from
362         // Dialog::canApply(), where we are just called with "note" rather
363         // than a full "note Note TYPE".
364         if (!lex.isOK())
365                 return;
366         lex >> "Note";
367
368         params.read(lex);
369 }
370
371
372 } // namespace lyx