]> git.lyx.org Git - lyx.git/blob - src/insets/InsetCommand.cpp
Use the layout defined label for the TOC, too.
[lyx.git] / src / insets / InsetCommand.cpp
1 /**
2  * \file InsetCommand.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 Lars Gullik Bjønnes
8  *
9  * Full author contact details are available in file CREDITS.
10  */
11
12 #include <config.h>
13
14 #include "InsetCommand.h"
15
16 #include "Buffer.h"
17 #include "BufferView.h"
18 #include "Cursor.h"
19 #include "DispatchResult.h"
20 #include "FuncRequest.h"
21 #include "FuncStatus.h"
22 #include "Lexer.h"
23 #include "MetricsInfo.h"
24
25 #include "insets/InsetBox.h"
26 #include "insets/InsetBranch.h"
27 #include "insets/InsetCommand.h"
28 #include "insets/InsetERT.h"
29 #include "insets/InsetExternal.h"
30 #include "insets/InsetFloat.h"
31 #include "insets/InsetGraphics.h"
32 #include "insets/InsetLine.h"
33 #include "insets/InsetListings.h"
34 #include "insets/InsetNote.h"
35 #include "insets/InsetPhantom.h"
36 #include "insets/InsetSpace.h"
37 #include "insets/InsetTabular.h"
38 #include "insets/InsetVSpace.h"
39 #include "insets/InsetWrap.h"
40
41 #include "support/debug.h"
42 #include "support/gettext.h"
43
44 #include "frontends/Application.h"
45
46 #include <sstream>
47
48 using namespace std;
49
50
51 namespace lyx {
52
53 // FIXME Would it now be possible to use the InsetCode in 
54 // place of the mailer name and recover that information?
55 InsetCommand::InsetCommand(Buffer * buf, InsetCommandParams const & p)
56         : Inset(buf), p_(p)
57 {}
58
59
60 // The sole purpose of this copy constructor is to make sure
61 // that the mouse_hover_ map is not copied and remains empty.
62 InsetCommand::InsetCommand(InsetCommand const & rhs)
63         : Inset(rhs), p_(rhs.p_)
64 {}
65
66
67 InsetCommand::~InsetCommand()
68 {
69         if (p_.code() != NO_CODE)
70                 hideDialogs(insetName(p_.code()), this);
71
72         map<BufferView const *, bool>::iterator it = mouse_hover_.begin();
73         map<BufferView const *, bool>::iterator end = mouse_hover_.end();
74         for (; it != end; ++it)
75                 if (it->second)
76                         it->first->clearLastInset(this);
77 }
78
79
80 void InsetCommand::metrics(MetricsInfo & mi, Dimension & dim) const
81 {
82         button_.update(screenLabel(), editable() || hasSettings());
83         button_.metrics(mi, dim);
84 }
85
86
87 bool InsetCommand::setMouseHover(BufferView const * bv, bool mouse_hover)
88         const
89 {
90         mouse_hover_[bv] = mouse_hover;
91         return true;
92 }
93
94
95 void InsetCommand::draw(PainterInfo & pi, int x, int y) const
96 {
97         button_.setRenderState(mouse_hover_[pi.base.bv]);
98         button_.draw(pi, x, y);
99 }
100
101
102 void InsetCommand::setParam(string const & name, docstring const & value)
103 {
104         p_[name] = value;
105 }
106
107
108 docstring const & InsetCommand::getParam(string const & name) const
109 {
110         return p_[name];
111 }
112
113
114 void InsetCommand::setParams(InsetCommandParams const & p)
115 {
116         p_ = p;
117         initView();
118 }
119
120
121 int InsetCommand::latex(odocstream & os, OutputParams const & runparams_in) const
122 {
123         OutputParams runparams = runparams_in;
124         os << getCommand(runparams);
125         return 0;
126 }
127
128
129 int InsetCommand::plaintext(odocstream & os, OutputParams const &) const
130 {
131         docstring const str = "[" + buffer().B_("LaTeX Command: ")
132                 + from_utf8(getCmdName()) + "]";
133         os << str;
134         return str.size();
135 }
136
137
138 int InsetCommand::docbook(odocstream &, OutputParams const &) const
139 {
140         return 0;
141 }
142
143
144 void InsetCommand::doDispatch(Cursor & cur, FuncRequest & cmd)
145 {
146         switch (cmd.action()) {
147         case LFUN_INSET_MODIFY: {
148                 if (cmd.getArg(0) == "changetype") {
149                         cur.recordUndo();
150                         p_.setCmdName(cmd.getArg(1));
151                         cur.forceBufferUpdate();
152                         initView();
153                         break;
154                 }
155                 InsetCommandParams p(p_.code());
156                 InsetCommand::string2params(to_utf8(cmd.argument()), p);
157                 if (p.getCmdName().empty())
158                         cur.noScreenUpdate();
159                 else {
160                         cur.recordUndo();
161                         setParams(p);
162                 }
163                 // FIXME We might also want to check here if this one is in the TOC.
164                 // But I think most of those are labeled.
165                 if (isLabeled())
166                         cur.forceBufferUpdate();
167                 break;
168         }
169
170         case LFUN_INSET_DIALOG_UPDATE: {
171                 string const name = to_utf8(cmd.argument());
172                 cur.bv().updateDialog(name, params2string(params()));
173                 break;
174         }
175
176         default:
177                 Inset::doDispatch(cur, cmd);
178                 break;
179         }
180
181 }
182
183
184 bool InsetCommand::getStatus(Cursor & cur, FuncRequest const & cmd,
185         FuncStatus & status) const
186 {
187         switch (cmd.action()) {
188         // suppress these
189         case LFUN_ERT_INSERT:
190                 status.setEnabled(false);
191                 return true;
192         
193         // we handle these
194         case LFUN_INSET_MODIFY:
195                 if (cmd.getArg(0) == "changetype") {
196                         string const newtype = cmd.getArg(1);
197                         status.setEnabled(p_.isCompatibleCommand(p_.code(), newtype));
198                         status.setOnOff(newtype == p_.getCmdName());
199                 } 
200                 status.setEnabled(true);
201                 return true;
202         
203         case LFUN_INSET_DIALOG_UPDATE:
204                 status.setEnabled(true);
205                 return true;
206         
207         default:
208                 return Inset::getStatus(cur, cmd, status);
209         }
210 }
211
212
213 docstring InsetCommand::contextMenuName() const
214 {
215         return from_ascii("context-") + from_ascii(insetName(p_.code()));
216 }
217
218
219 bool InsetCommand::showInsetDialog(BufferView * bv) const
220 {
221         if (p_.code() != NO_CODE)
222                 bv->showDialog(insetName(p_.code()), params2string(p_),
223                         const_cast<InsetCommand *>(this));
224         return true;
225 }
226
227
228 bool InsetCommand::string2params(string const & data,
229         InsetCommandParams & params)
230 {
231         params.clear();
232         if (data.empty())
233                 return false;
234         // This happens when inset-insert is called without argument except for the
235         // inset type; ex:
236         // "inset-insert toc"
237         string const name = insetName(params.code());
238         if (data == name)
239                 return true;
240         istringstream dstream(data);
241         Lexer lex;
242         lex.setStream(dstream);
243         lex.setContext("InsetCommand::string2params");
244         lex >> name.c_str(); // check for name
245         lex >> "CommandInset";
246         params.read(lex);
247         return true;
248 }
249
250
251 string InsetCommand::params2string(InsetCommandParams const & params)
252 {
253         ostringstream data;
254         data << insetName(params.code()) << ' ';
255         params.write(data);
256         data << "\\end_inset\n";
257         return data.str();
258 }
259
260
261 bool decodeInsetParam(string const & name, string & data,
262         Buffer const & buffer)
263 {
264         InsetCode const code = insetCode(name);
265         switch (code) {
266         case BIBITEM_CODE:
267         case BIBTEX_CODE:
268         case INDEX_CODE:
269         case LABEL_CODE:
270         case LINE_CODE:
271         case NOMENCL_CODE:
272         case NOMENCL_PRINT_CODE:
273         case REF_CODE:
274         case TOC_CODE:
275         case HYPERLINK_CODE: {
276                 InsetCommandParams p(code);
277                 data = InsetCommand::params2string(p);
278                 break;
279         }
280         case INCLUDE_CODE: {
281                 // data is the include type: one of "include",
282                 // "input", "verbatiminput" or "verbatiminput*"
283                 if (data.empty())
284                         // default type is requested
285                         data = "include";
286                 InsetCommandParams p(INCLUDE_CODE, data);
287                 data = InsetCommand::params2string(p);
288                 break;
289         }
290         case BOX_CODE: {
291                 // \c data == "Boxed" || "Frameless" etc
292                 InsetBoxParams p(data);
293                 data = InsetBox::params2string(p);
294                 break;
295         }
296         case BRANCH_CODE: {
297                 InsetBranchParams p;
298                 data = InsetBranch::params2string(p);
299                 break;
300         }
301         case CITE_CODE: {
302                 InsetCommandParams p(CITE_CODE);
303                 data = InsetCommand::params2string(p);
304                 break;
305         }
306         case ERT_CODE: {
307                 data = InsetERT::params2string(InsetCollapsable::Open);
308                 break;
309         }
310         case EXTERNAL_CODE: {
311                 InsetExternalParams p;
312                 data = InsetExternal::params2string(p, buffer);
313                 break;
314         }
315         case FLOAT_CODE:  {
316                 InsetFloatParams p;
317                 data = InsetFloat::params2string(p);
318                 break;
319         }
320         case LISTINGS_CODE: {
321                 InsetListingsParams p;
322                 data = InsetListings::params2string(p);
323                 break;
324         }
325         case GRAPHICS_CODE: {
326                 InsetGraphicsParams p;
327                 data = InsetGraphics::params2string(p, buffer);
328                 break;
329         }
330         case NOTE_CODE: {
331                 InsetNoteParams p;
332                 data = InsetNote::params2string(p);
333                 break;
334         }
335         case PHANTOM_CODE: {
336                 InsetPhantomParams p;
337                 data = InsetPhantom::params2string(p);
338                 break;
339         }
340         case SPACE_CODE: {
341                 InsetSpaceParams p;
342                 data = InsetSpace::params2string(p);
343                 break;
344         }
345         case VSPACE_CODE: {
346                 VSpace space;
347                 data = InsetVSpace::params2string(space);
348                 break;
349         }
350         case WRAP_CODE: {
351                 InsetWrapParams p;
352                 data = InsetWrap::params2string(p);
353                 break;
354         }
355         default:
356                 return false;
357         } // end switch(code)
358         return true;
359 }
360
361 } // namespace lyx