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 /////////////////////////////////////////////////////////////////////////
  53 //
  54 // ToolbarItem
  55 //
  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), label_(label), name_(name)
  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(Lexer & lex)
  82 {
  83         enum {
  84                 TO_COMMAND = 1,
  85                 TO_ENDTOOLBAR,
  86                 TO_SEPARATOR,
  87                 TO_LAYOUTS,
  88                 TO_MINIBUFFER,
  89                 TO_TABLEINSERT,
  90                 TO_POPUPMENU,
  91                 TO_ICONPALETTE,
  92         };
  93
  94         struct LexerKeyword toolTags[] = {
  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                 LYXERR0("ToolbarInfo::read: ERROR wrong token:`"
 108                        << lex.getString() << '\'');
 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                 LYXERR0("ToolbarInfo::read: Malformed toolbar "
 120                         "description " <<  lex.getString());
 121                 return *this;
 122         }
 123
 124         bool quit = false;
 125
 126         lex.pushTable(toolTags);
 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(FuncCode(ToolbarItem::MINIBUFFER))));
 150                         break;
 151
 152                 case TO_SEPARATOR:
 153                         add(ToolbarItem(ToolbarItem::SEPARATOR,
 154                                 FuncRequest(FuncCode(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(FuncCode(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(FuncCode(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 //
 207 // ToolbarBackend
 208 //
 209 /////////////////////////////////////////////////////////////////////////
 210
 211
 212 ToolbarBackend::ToolbarBackend()
 213 {
 214         fullScreenWindows = 0;
 215 }
 216
 217
 218 void ToolbarBackend::readToolbars(Lexer & lex)
 219 {
 220         enum {
 221                 TO_TOOLBAR = 1,
 222                 TO_ENDTOOLBARSET,
 223         };
 224
 225         struct LexerKeyword toolTags[] = {
 226                 { "end", TO_ENDTOOLBARSET },
 227                 { "toolbar", TO_TOOLBAR }
 228         };
 229
 230         //consistency check
 231         if (compare_ascii_no_case(lex.getString(), "toolbarset")) {
 232                 LYXERR0("ToolbarBackend::readToolbars: ERROR wrong token:`"
 233                        << lex.getString() << '\'');
 234         }
 235
 236         lex.pushTable(toolTags);
 237
 238         if (lyxerr.debugging(Debug::PARSER))
 239                 lex.printTable(lyxerr);
 240
 241         bool quit = false;
 242         while (lex.isOK() && !quit) {
 243                 switch (lex.lex()) {
 244                 case TO_TOOLBAR: {
 245                         ToolbarInfo tbinfo;
 246                         tbinfo.read(lex);
 247                         toolbars.push_back(tbinfo);
 248                         break;
 249                         }
 250                 case TO_ENDTOOLBARSET:
 251                         quit = true;
 252                         break;
 253                 default:
 254                         lex.printError("ToolbarBackend::readToolbars: "
 255                                        "Unknown toolbar tag: `$$Token'");
 256                         break;
 257                 }
 258         }
 259
 260         lex.popTable();
 261 }
 262
 263
 264 void ToolbarBackend::readToolbarSettings(Lexer & lex)
 265 {
 266         //consistency check
 267         if (compare_ascii_no_case(lex.getString(), "toolbars")) {
 268                 LYXERR0("ToolbarBackend::readToolbarSettings: ERROR wrong token:`"
 269                        << lex.getString() << '\'');
 270         }
 271
 272         lex.next(true);
 273
 274         while (lex.isOK()) {
 275                 string name = lex.getString();
 276                 lex.next(true);
 277
 278                 if (!compare_ascii_no_case(name, "end"))
 279                         return;
 280
 281                 Toolbars::iterator tcit = toolbars.begin();
 282                 Toolbars::iterator tend = toolbars.end();
 283                 for (; tcit != tend; ++tcit) {
 284                         if (tcit->name == name)
 285                                 break;
 286                 }
 287
 288                 if (tcit == tend) {
 289                         LYXERR0("ToolbarBackend: undefined toolbar " << name);
 290                         return;
 291                 }
 292
 293                 tcit->flags = static_cast<ToolbarInfo::Flags>(0);
 294                 string flagstr = lex.getString();
 295                 lex.next(true);
 296                 vector<string> flags = getVectorFromString(flagstr);
 297
 298                 vector<string>::const_iterator cit = flags.begin();
 299                 vector<string>::const_iterator end = flags.end();
 300
 301                 for (; cit != end; ++cit) {
 302                         int flag = 0;
 303                         if (!compare_ascii_no_case(*cit, "off"))
 304                                 flag = ToolbarInfo::OFF;
 305                         else if (!compare_ascii_no_case(*cit, "on"))
 306                                 flag = ToolbarInfo::ON;
 307                         else if (!compare_ascii_no_case(*cit, "math"))
 308                                 flag = ToolbarInfo::MATH;
 309                         else if (!compare_ascii_no_case(*cit, "table"))
 310                                 flag = ToolbarInfo::TABLE;
 311                         else if (!compare_ascii_no_case(*cit, "mathmacrotemplate"))
 312                                 flag = ToolbarInfo::MATHMACROTEMPLATE;
 313                         else if (!compare_ascii_no_case(*cit, "review"))
 314                                 flag = ToolbarInfo::REVIEW;
 315                         else if (!compare_ascii_no_case(*cit, "top"))
 316                                 flag = ToolbarInfo::TOP;
 317                         else if (!compare_ascii_no_case(*cit, "bottom"))
 318                                 flag = ToolbarInfo::BOTTOM;
 319                         else if (!compare_ascii_no_case(*cit, "left"))
 320                                 flag = ToolbarInfo::LEFT;
 321                         else if (!compare_ascii_no_case(*cit, "right"))
 322                                 flag = ToolbarInfo::RIGHT;
 323                         else if (!compare_ascii_no_case(*cit, "auto"))
 324                                 flag = ToolbarInfo::AUTO;
 325                         else {
 326                                 LYXERR(Debug::ANY,
 327                                         "ToolbarBackend::readToolbarSettings: unrecognised token:`"
 328                                         << *cit << '\'');
 329                         }
 330                         tcit->flags = static_cast<ToolbarInfo::Flags>(tcit->flags | flag);
 331                 }
 332
 333                 usedtoolbars.push_back(*tcit);
 334         }
 335 }
 336
 337
 338 ToolbarInfo const * ToolbarBackend::getDefinedToolbarInfo(string const & name) const
 339 {
 340         Toolbars::const_iterator it = find_if(toolbars.begin(), toolbars.end(), ToolbarNamesEqual(name));
 341         if (it == toolbars.end())
 342                 return 0;
 343         return &(*it);
 344 }
 345
 346
 347 ToolbarInfo * ToolbarBackend::getUsedToolbarInfo(string const &name)
 348 {
 349         Toolbars::iterator it = find_if(usedtoolbars.begin(), usedtoolbars.end(), ToolbarNamesEqual(name));
 350         if (it == usedtoolbars.end())
 351                 return 0;
 352         return &(*it);
 353 }
 354
 355 } // namespace lyx