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