src/ToolbarBackend.cpp

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