src/ToolbarBackend.C

   1 /**
   2  * \file ToolbarBackend.C
   3  * This file is part of LyX, the document processor.
   4  * Licence details can be found in the file COPYING.
   5  *
   6  * \author Jean-Marc Lasgouttes
   7  * \author John Levon
   8  *
   9  * Full author contact details are available in file CREDITS.
  10  */
  11
  12 #include <config.h>
  13
  14 #include "ToolbarBackend.h"
  15 #include "funcrequest.h"
  16 #include "lyxlex.h"
  17 #include "debug.h"
  18 #include "gettext.h"
  19 #include "LyXAction.h"
  20 #include "support/lstrings.h"
  21
  22 #include <boost/bind.hpp>
  23
  24 #include "frontends/controllers/ControlMath.h"
  25
  26 namespace lyx {
  27
  28 using support::compare_ascii_no_case;
  29 using support::getVectorFromString;
  30
  31 using std::endl;
  32 using std::make_pair;
  33 using std::string;
  34 using std::vector;
  35 using std::find_if;
  36
  37
  38 namespace {
  39
  40 class ToolbarNamesEqual : public std::unary_function<ToolbarInfo, bool> {
  41 public:
  42         ToolbarNamesEqual(string const & name)
  43                 : name_(name) {}
  44         bool operator()(ToolbarInfo const & tb) const
  45         {
  46                 return tb.name == name_;
  47         }
  48 private:
  49         string name_;
  50 };
  51
  52 } // namespace anon
  53
  54
  55 ToolbarBackend toolbarbackend;
  56
  57
  58 ToolbarItem::ToolbarItem(Type type, FuncRequest const & func, docstring const & label)
  59         : type_(type), func_(func), label_(label)
  60 {
  61 }
  62
  63
  64 ToolbarItem::ToolbarItem(Type type, string const & name, docstring const & label)
  65         : type_(type), name_(name), label_(label)
  66 {
  67 }
  68
  69
  70 ToolbarItem::~ToolbarItem()
  71 {}
  72
  73
  74 void ToolbarInfo::add(ToolbarItem const & item)
  75 {
  76         items.push_back(item);
  77         items.back().func_.origin = FuncRequest::TOOLBAR;
  78 }
  79
  80
  81 ToolbarInfo & ToolbarInfo::read(LyXLex & lex)
  82 {
  83         enum tooltags {
  84                 TO_COMMAND = 1,
  85                 TO_ENDTOOLBAR,
  86                 TO_SEPARATOR,
  87                 TO_LAYOUTS,
  88                 TO_MINIBUFFER,
  89                 TO_TABLEINSERT,
  90                 TO_LAST
  91         };
  92
  93         struct keyword_item toolTags[TO_LAST - 1] = {
  94                 { "end", TO_ENDTOOLBAR },
  95                 { "item", TO_COMMAND },
  96                 { "layouts", TO_LAYOUTS },
  97                 { "minibuffer", TO_MINIBUFFER },
  98                 { "separator", TO_SEPARATOR },
  99                 { "tableinsert", TO_TABLEINSERT }
 100         };
 101
 102         //consistency check
 103         if (compare_ascii_no_case(lex.getString(), "toolbar")) {
 104                 lyxerr << "ToolbarInfo::read: ERROR wrong token:`"
 105                        << lex.getString() << '\'' << endl;
 106         }
 107
 108         lex.next(true);
 109         name = lex.getString();
 110
 111         lex.next(true);
 112         gui_name = lex.getString();
 113
 114         // FIXME what to do here?
 115         if (!lex) {
 116                 lyxerr << "ToolbarInfo::read: Malformed toolbar "
 117                         "description " <<  lex.getString() << endl;
 118                 return *this;
 119         }
 120
 121         bool quit = false;
 122
 123         lex.pushTable(toolTags, TO_LAST - 1);
 124
 125         if (lyxerr.debugging(Debug::PARSER))
 126                 lex.printTable(lyxerr);
 127
 128         while (lex.isOK() && !quit) {
 129                 switch (lex.lex()) {
 130                 case TO_COMMAND:
 131                         if (lex.next(true)) {
 132                                 docstring const tooltip = translateIfPossible(lex.getDocString());
 133                                 lex.next(true);
 134                                 string const func_arg = lex.getString();
 135                                 LYXERR(Debug::PARSER)
 136                                         << "ToolbarInfo::read TO_COMMAND func: `"
 137                                         << func_arg << '\'' << endl;
 138
 139                                 FuncRequest func =
 140                                         lyxaction.lookupFunc(func_arg);
 141                                 add(ToolbarItem(ToolbarItem::COMMAND, func, tooltip));
 142                         }
 143                         break;
 144
 145                 case TO_MINIBUFFER:
 146                         add(ToolbarItem(ToolbarItem::MINIBUFFER,
 147                                 FuncRequest(kb_action(ToolbarItem::MINIBUFFER))));
 148                         break;
 149
 150                 case TO_SEPARATOR:
 151                         add(ToolbarItem(ToolbarItem::SEPARATOR,
 152                                 FuncRequest(kb_action(ToolbarItem::SEPARATOR))));
 153                         break;
 154
 155                 case TO_LAYOUTS:
 156                         add(ToolbarItem(ToolbarItem::LAYOUTS,
 157                                 FuncRequest(kb_action(ToolbarItem::LAYOUTS))));
 158                         break;
 159
 160                 case TO_TABLEINSERT:
 161                         add(ToolbarItem(ToolbarItem::TABLEINSERT,
 162                                 FuncRequest(kb_action(ToolbarItem::TABLEINSERT))));
 163                         break;
 164
 165                 case TO_ENDTOOLBAR:
 166                         quit = true;
 167                         break;
 168
 169                 default:
 170                         lex.printError("ToolbarInfo::read: "
 171                                        "Unknown toolbar tag: `$$Token'");
 172                         break;
 173                 }
 174         }
 175
 176         lex.popTable();
 177         return *this;
 178 }
 179
 180
 181
 182
 183 ToolbarBackend::ToolbarBackend()
 184 {
 185 }
 186
 187
 188 void ToolbarBackend::readToolbars(LyXLex & lex)
 189 {
 190         enum tooltags {
 191                 TO_TOOLBAR = 1,
 192                 TO_ENDTOOLBARSET,
 193                 TO_LAST
 194         };
 195
 196         struct keyword_item toolTags[TO_LAST - 1] = {
 197                 { "end", TO_ENDTOOLBARSET },
 198                 { "toolbar", TO_TOOLBAR }
 199         };
 200
 201         //consistency check
 202         if (compare_ascii_no_case(lex.getString(), "toolbarset")) {
 203                 lyxerr << "ToolbarBackend::readToolbars: ERROR wrong token:`"
 204                        << lex.getString() << '\'' << endl;
 205         }
 206
 207         lex.pushTable(toolTags, TO_LAST - 1);
 208
 209         if (lyxerr.debugging(Debug::PARSER))
 210                 lex.printTable(lyxerr);
 211
 212         bool quit = false;
 213         while (lex.isOK() && !quit) {
 214                 switch (lex.lex()) {
 215                 case TO_TOOLBAR: {
 216                         ToolbarInfo tb;
 217                         tb.read(lex);
 218                         toolbars.push_back(tb);
 219                         break;
 220                         }
 221                 case TO_ENDTOOLBARSET:
 222                         quit = true;
 223                         break;
 224                 default:
 225                         lex.printError("ToolbarBackend::readToolbars: "
 226                                        "Unknown toolbar tag: `$$Token'");
 227                         break;
 228                 }
 229         }
 230
 231         lex.popTable();
 232 }
 233
 234
 235 void ToolbarBackend::readToolbarSettings(LyXLex & lex)
 236 {
 237         //consistency check
 238         if (compare_ascii_no_case(lex.getString(), "toolbars")) {
 239                 lyxerr << "ToolbarBackend::readToolbarSettings: ERROR wrong token:`"
 240                        << lex.getString() << '\'' << endl;
 241         }
 242
 243         lex.next(true);
 244
 245         while (lex.isOK()) {
 246                 string name = lex.getString();
 247                 lex.next(true);
 248
 249                 if (!compare_ascii_no_case(name, "end"))
 250                         return;
 251
 252                 Toolbars::iterator tcit = toolbars.begin();
 253                 Toolbars::iterator tend = toolbars.end();
 254                 for (; tcit != tend; ++tcit) {
 255                         if (tcit->name == name)
 256                                 break;
 257                 }
 258
 259                 if (tcit == tend) {
 260                         lyxerr << "ToolbarBackend: undefined toolbar "
 261                                 << name << endl;
 262                         return;
 263                 }
 264
 265                 tcit->flags = static_cast<ToolbarInfo::Flags>(0);
 266                 string flagstr = lex.getString();
 267                 lex.next(true);
 268                 vector<string> flags = getVectorFromString(flagstr);
 269
 270                 vector<string>::const_iterator cit = flags.begin();
 271                 vector<string>::const_iterator end = flags.end();
 272
 273                 for (; cit != end; ++cit) {
 274                         int flag = 0;
 275                         if (!compare_ascii_no_case(*cit, "off"))
 276                                 flag = ToolbarInfo::OFF;
 277                         else if (!compare_ascii_no_case(*cit, "on"))
 278                                 flag = ToolbarInfo::ON;
 279                         else if (!compare_ascii_no_case(*cit, "math"))
 280                                 flag = ToolbarInfo::MATH;
 281                         else if (!compare_ascii_no_case(*cit, "table"))
 282                                 flag = ToolbarInfo::TABLE;
 283                         else if (!compare_ascii_no_case(*cit, "review"))
 284                                 flag = ToolbarInfo::REVIEW;
 285                         else if (!compare_ascii_no_case(*cit, "top"))
 286                                 flag = ToolbarInfo::TOP;
 287                         else if (!compare_ascii_no_case(*cit, "bottom"))
 288                                 flag = ToolbarInfo::BOTTOM;
 289                         else if (!compare_ascii_no_case(*cit, "left"))
 290                                 flag = ToolbarInfo::LEFT;
 291                         else if (!compare_ascii_no_case(*cit, "right"))
 292                                 flag = ToolbarInfo::RIGHT;
 293                         else {
 294                                 lyxerr << "ToolbarBackend::readToolbarSettings: unrecognised token:`"
 295                                        << *cit << '\'' << endl;
 296                         }
 297                         tcit->flags = static_cast<ToolbarInfo::Flags>(tcit->flags | flag);
 298                 }
 299
 300                 usedtoolbars.push_back(*tcit);
 301         }
 302 }
 303
 304
 305 ToolbarInfo const & ToolbarBackend::getToolbar(string const & name) const
 306 {
 307         Toolbars::const_iterator cit = find_if(toolbars.begin(), toolbars.end(), ToolbarNamesEqual(name));
 308         if (cit == toolbars.end())
 309                 lyxerr << "No toolbar named " << name << endl;
 310         BOOST_ASSERT(cit != toolbars.end());
 311         return (*cit);
 312 }
 313
 314
 315 ToolbarInfo & ToolbarBackend::getToolbar(string const & name)
 316 {
 317         Toolbars::iterator it = find_if(toolbars.begin(), toolbars.end(), ToolbarNamesEqual(name));
 318         if (it == toolbars.end())
 319                 lyxerr << "No toolbar named " << name << endl;
 320         BOOST_ASSERT(it != toolbars.end());
 321         return (*it);
 322 }
 323
 324
 325 } // namespace lyx