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