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