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