src/frontends/qt4/Toolbars.cpp

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