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