]> git.lyx.org Git - lyx.git/blob - src/frontends/qt4/GuiDelimiter.cpp
Move some unsigned validators to signed (#10095)
[lyx.git] / src / frontends / qt4 / GuiDelimiter.cpp
1 /**
2  * \file GuiDelimiter.cpp
3  * This file is part of LyX, the document processor.
4  * Licence details can be found in the file COPYING.
5  *
6  * \author John Levon
7  *
8  * Full author contact details are available in file CREDITS.
9  */
10
11 #include <config.h>
12
13 #include "GuiDelimiter.h"
14
15 #include "GuiApplication.h"
16 #include "GuiFontLoader.h"
17 #include "GuiView.h"
18 #include "qt_helpers.h"
19
20 #include "FontEnums.h"
21 #include "FontInfo.h"
22 #include "FuncRequest.h"
23
24 #include "support/gettext.h"
25 #include "support/docstring.h"
26
27 #include <QPixmap>
28 #include <QCheckBox>
29 #include <QListWidgetItem>
30
31 #include <map>
32 #include <string>
33
34 using namespace std;
35
36 namespace lyx {
37 namespace frontend {
38
39 namespace {
40
41 static char const *  latex_delimiters[] = {
42         "(", ")", "{", "}", "[", "]",
43         "lceil", "rceil", "lfloor", "rfloor", "langle", "rangle",
44         "llbracket", "rrbracket",
45         "uparrow", "updownarrow", "Uparrow", "Updownarrow", "downarrow", "Downarrow",
46         "|", "Vert", "/", "backslash", ""
47 };
48
49
50 static int const nr_latex_delimiters =
51         sizeof(latex_delimiters) / sizeof(char const *);
52
53 static QString const bigleft[]  = {"", "bigl", "Bigl", "biggl", "Biggl"};
54
55 static QString const bigright[] = {"", "bigr", "Bigr", "biggr", "Biggr"};
56
57 static char const * const biggui[] = {
58         N_("big[[delimiter size]]"),
59         N_("Big[[delimiter size]]"),
60         N_("bigg[[delimiter size]]"),
61         N_("Bigg[[delimiter size]]"),
62         ""
63 };
64
65
66 // FIXME: It might be better to fix the big delim LFUN to not require
67 // additional '\' prefix.
68 static QString fix_name(QString const & str, bool big)
69 {
70         if (str.isEmpty())
71                 return ".";
72         if (!big || str == "(" || str == ")" || str == "[" || str == "]"
73             || str == "|" || str == "/")
74                 return str;
75
76         return "\\" + str;
77 }
78
79 struct MathSymbol {
80         MathSymbol(char_type uc = '?', unsigned char fc = 0,
81                 FontFamily ff = SYMBOL_FAMILY)
82                 : unicode(uc), fontcode(fc), fontfamily(ff)
83         {}
84         char_type unicode;
85         unsigned char fontcode;
86         FontFamily fontfamily;
87 };
88
89 /// TeX-name / Math-symbol map.
90 static map<std::string, MathSymbol> math_symbols_;
91 /// Math-symbol / TeX-name map.
92 /// This one is for fast search, it contains the same data as
93 /// \c math_symbols_.
94 static map<char_type, string> tex_names_;
95
96 void initMathSymbols()
97 {
98         // FIXME: Ideally, those unicode codepoints would be defined
99         // in "lib/symbols". Unfortunately, some of those are already
100         // defined with non-unicode ids for use within mathed.
101         // FIXME 2: We should fill-in this map with the parsed "symbols"
102         // file done in MathFactory.cpp.
103         math_symbols_["("] = MathSymbol('(', 40, CMR_FAMILY);
104         math_symbols_[")"] = MathSymbol(')', 41, CMR_FAMILY);
105         math_symbols_["{"] = MathSymbol('{', 102, CMSY_FAMILY);
106         math_symbols_["}"] = MathSymbol('}', 103, CMSY_FAMILY);
107         math_symbols_["["] = MathSymbol('[', 91, CMR_FAMILY);
108         math_symbols_["]"] = MathSymbol(']', 93, CMR_FAMILY);
109         math_symbols_["|"] = MathSymbol('|', 106, CMSY_FAMILY);
110         math_symbols_["/"] = MathSymbol('/', 47, CMR_FAMILY);
111         math_symbols_["backslash"] = MathSymbol('\\', 110, CMSY_FAMILY);
112         math_symbols_["lceil"] = MathSymbol(0x2308, 100, CMSY_FAMILY);
113         math_symbols_["rceil"] = MathSymbol(0x2309, 101, CMSY_FAMILY);
114         math_symbols_["lfloor"] = MathSymbol(0x230A, 98, CMSY_FAMILY);
115         math_symbols_["rfloor"] = MathSymbol(0x230B, 99, CMSY_FAMILY);
116         math_symbols_["langle"] = MathSymbol(0x2329, 104, CMSY_FAMILY);
117         math_symbols_["rangle"] = MathSymbol(0x232A, 105, CMSY_FAMILY);
118         math_symbols_["llbracket"] = MathSymbol(0x27e6, 74, STMARY_FAMILY);
119         math_symbols_["rrbracket"] = MathSymbol(0x27e7, 75, STMARY_FAMILY);
120         math_symbols_["uparrow"] = MathSymbol(0x2191, 34, CMSY_FAMILY);
121         math_symbols_["Uparrow"] = MathSymbol(0x21D1, 42, CMSY_FAMILY);
122         math_symbols_["updownarrow"] = MathSymbol(0x2195, 108, CMSY_FAMILY);
123         math_symbols_["Updownarrow"] = MathSymbol(0x21D5, 109, CMSY_FAMILY);
124         math_symbols_["downarrow"] = MathSymbol(0x2193, 35, CMSY_FAMILY);
125         math_symbols_["Downarrow"] = MathSymbol(0x21D3, 43, CMSY_FAMILY);
126         math_symbols_["downdownarrows"] = MathSymbol(0x21CA, 184, MSA_FAMILY);
127         math_symbols_["downharpoonleft"] = MathSymbol(0x21C3, 188, MSA_FAMILY);
128         math_symbols_["downharpoonright"] = MathSymbol(0x21C2, 186, MSA_FAMILY);
129         math_symbols_["vert"] = MathSymbol(0x007C, 106, CMSY_FAMILY);
130         math_symbols_["Vert"] = MathSymbol(0x2016, 107, CMSY_FAMILY);
131
132         map<string, MathSymbol>::const_iterator it = math_symbols_.begin();
133         map<string, MathSymbol>::const_iterator end = math_symbols_.end();
134         for (; it != end; ++it)
135                 tex_names_[it->second.unicode] = it->first;
136 }
137
138 /// \return the math unicode symbol associated to a TeX name.
139 MathSymbol const & mathSymbol(string tex_name)
140 {
141         map<string, MathSymbol>::const_iterator it =
142                 math_symbols_.find(tex_name);
143
144         static MathSymbol const unknown_symbol;
145         if (it == math_symbols_.end())
146                 return unknown_symbol;
147
148         return it->second;
149 }
150
151 /// \return the TeX name associated to a math unicode symbol.
152 string const & texName(char_type math_symbol)
153 {
154         map<char_type, string>::const_iterator it =
155                 tex_names_.find(math_symbol);
156
157         static string const empty_string;
158         if (it == tex_names_.end())
159                 return empty_string;
160
161         return it->second;
162 }
163
164 } // anon namespace
165
166
167 GuiDelimiter::GuiDelimiter(GuiView & lv)
168         : GuiDialog(lv, "mathdelimiter", qt_("Math Delimiter"))
169 {
170         setupUi(this);
171
172         connect(closePB, SIGNAL(clicked()), this, SLOT(accept()));
173
174         setFocusProxy(leftLW);
175
176         leftLW->setViewMode(QListView::IconMode);
177         rightLW->setViewMode(QListView::IconMode);
178
179         leftLW->setDragDropMode(QAbstractItemView::NoDragDrop);
180         rightLW->setDragDropMode(QAbstractItemView::NoDragDrop);
181
182         initMathSymbols();
183
184         FontInfo lyxfont;
185         lyxfont.setFamily(CMR_FAMILY);
186         QFontMetrics fm(frontend::getFont(lyxfont));
187         QSize item_size(fm.maxWidth(), fm.height() + 8);
188
189         typedef map<char_type, QListWidgetItem *> ListItems;
190         ListItems list_items;
191         // The last element is the empty one.
192         int const end = nr_latex_delimiters - 1;
193         for (int i = 0; i < end; ++i) {
194                 string const delim = latex_delimiters[i];
195                 MathSymbol const & ms = mathSymbol(delim);
196                 QString symbol(ms.fontcode?
197                         QChar(ms.fontcode) : toqstr(docstring(1, ms.unicode)));
198                 QListWidgetItem * lwi = new QListWidgetItem(symbol);
199                 lyxfont.setFamily(ms.fontfamily);
200                 QFont font = frontend::getFont(lyxfont);
201                 lwi->setFont(font);
202                 lwi->setToolTip(toqstr(delim));
203                 lwi->setSizeHint(item_size);
204                 lwi->setTextAlignment(Qt::AlignTop);
205                 list_items[ms.unicode] = lwi;
206                 leftLW->addItem(lwi);
207         }
208
209         for (int i = 0; i != leftLW->count(); ++i) {
210                 MathSymbol const & ms = mathSymbol(
211                         fromqstr(leftLW->item(i)->toolTip()));
212                 rightLW->addItem(list_items[doMatch(ms.unicode)]->clone());
213         }
214
215         // The last element is the empty one.
216         QListWidgetItem * lwi = new QListWidgetItem(qt_("(None)"));
217         QListWidgetItem * rwi = new QListWidgetItem(qt_("(None)"));
218         leftLW->addItem(lwi);
219         rightLW->addItem(rwi);
220
221         sizeCO->addItem(qt_("Variable"));
222
223         for (int i = 0; *biggui[i]; ++i)
224                 sizeCO->addItem(qt_(biggui[i]));
225
226         on_leftLW_currentRowChanged(0);
227         bc().setPolicy(ButtonPolicy::IgnorantPolicy);
228 }
229
230
231 char_type GuiDelimiter::doMatch(char_type const symbol)
232 {
233         string const & str = texName(symbol);
234         string match;
235         if (str == "(") match = ")";
236         else if (str == ")") match = "(";
237         else if (str == "[") match = "]";
238         else if (str == "]") match = "[";
239         else if (str == "{") match = "}";
240         else if (str == "}") match = "{";
241         else if (str == "l") match = "r";
242         else if (str == "rceil") match = "lceil";
243         else if (str == "lceil") match = "rceil";
244         else if (str == "rfloor") match = "lfloor";
245         else if (str == "lfloor") match = "rfloor";
246         else if (str == "rangle") match = "langle";
247         else if (str == "langle") match = "rangle";
248         else if (str == "llbracket") match = "rrbracket";
249         else if (str == "rrbracket") match = "llbracket";
250         else if (str == "backslash") match = "/";
251         else if (str == "/") match = "backslash";
252         else return symbol;
253
254         return mathSymbol(match).unicode;
255 }
256
257
258 void GuiDelimiter::updateTeXCode(int size)
259 {
260         bool const bigsize = size != 0;
261
262         QString left_str = fix_name(leftLW->currentItem()->toolTip(), bigsize);
263         QString right_str = fix_name(rightLW->currentItem()->toolTip(), bigsize);
264
265         if (!bigsize)
266                 tex_code_ = left_str + ' ' + right_str;
267         else {
268                 tex_code_ = bigleft[size] + ' '
269                         + left_str + ' '
270                         + bigright[size] + ' '
271                         + right_str;
272         }
273
274         // Generate TeX-code for GUI display.
275         // FIXME: Instead of reconstructing the TeX code it would be nice to
276         // FIXME: retrieve the LateX code directly from mathed.
277         // In all cases, we want the '\' prefix if needed, so we pass 'true'
278         // to fix_name.
279         left_str = fix_name(leftLW->currentItem()->toolTip(), true);
280         right_str = fix_name(rightLW->currentItem()->toolTip(), true);
281         QString code_str;
282         if (!bigsize)
283                 code_str = "\\left" + left_str + " \\right" + right_str;
284         else {
285                 // There should be nothing in the TeX-code when the delimiter is "None".
286                 if (left_str != ".")
287                         code_str = "\\" + bigleft[size] + left_str + ' ';
288                 if (right_str != ".")
289                         code_str += "\\" + bigright[size] + right_str;
290         }
291
292         texCodeL->setText(qt_("TeX Code: ") + code_str);
293 }
294
295
296 void GuiDelimiter::on_insertPB_clicked()
297 {
298         if (sizeCO->currentIndex() == 0)
299                 dispatch(FuncRequest(LFUN_MATH_DELIM, fromqstr(tex_code_)));
300         else {
301                 QString command = '"' + tex_code_ + '"';
302                 command.replace(' ', "\" \"");
303                 dispatch(FuncRequest(LFUN_MATH_BIGDELIM, fromqstr(command)));
304         }
305  }
306
307
308 void GuiDelimiter::on_sizeCO_activated(int index)
309 {
310         updateTeXCode(index);
311 }
312
313
314 void GuiDelimiter::on_leftLW_itemActivated(QListWidgetItem *)
315 {
316         // do not auto-apply if !matchCB->isChecked()
317         if (!matchCB->isChecked())
318                 return;
319         on_insertPB_clicked();
320         accept();
321 }
322
323
324 void GuiDelimiter::on_rightLW_itemActivated(QListWidgetItem *)
325 {
326         // do not auto-apply if !matchCB->isChecked()
327         if (!matchCB->isChecked())
328                 return;
329         on_insertPB_clicked();
330         accept();
331 }
332
333
334 void GuiDelimiter::on_leftLW_currentRowChanged(int item)
335 {
336         if (matchCB->isChecked())
337                 rightLW->setCurrentRow(item);
338
339         updateTeXCode(sizeCO->currentIndex());
340 }
341
342
343 void GuiDelimiter::on_rightLW_currentRowChanged(int item)
344 {
345         if (matchCB->isChecked())
346                 leftLW->setCurrentRow(item);
347
348         updateTeXCode(sizeCO->currentIndex());
349 }
350
351
352 void GuiDelimiter::on_matchCB_stateChanged(int state)
353 {
354         if (state == Qt::Checked)
355                 on_leftLW_currentRowChanged(leftLW->currentRow());
356
357         updateTeXCode(sizeCO->currentIndex());
358 }
359
360
361 Dialog * createGuiDelimiter(GuiView & lv) { return new GuiDelimiter(lv); }
362
363
364 } // namespace frontend
365 } // namespace lyx
366
367 #include "moc_GuiDelimiter.cpp"