mirror of
https://git.lyx.org/repos/lyx.git
synced 2024-12-25 14:04:25 +00:00
5ae54ddafb
git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@19409 a592a061-630c-0410-9148-cb99ea01b6c8
349 lines
7.5 KiB
C++
349 lines
7.5 KiB
C++
/**
|
|
* \file ToolbarBackend.cpp
|
|
* This file is part of LyX, the document processor.
|
|
* Licence details can be found in the file COPYING.
|
|
*
|
|
* \author Jean-Marc Lasgouttes
|
|
* \author John Levon
|
|
*
|
|
* Full author contact details are available in file CREDITS.
|
|
*/
|
|
|
|
#include <config.h>
|
|
|
|
#include "ToolbarBackend.h"
|
|
#include "FuncRequest.h"
|
|
#include "Lexer.h"
|
|
#include "debug.h"
|
|
#include "gettext.h"
|
|
#include "LyXAction.h"
|
|
#include "support/lstrings.h"
|
|
|
|
#include <boost/bind.hpp>
|
|
#include <algorithm>
|
|
|
|
#include "frontends/controllers/ControlMath.h"
|
|
|
|
namespace lyx {
|
|
|
|
using support::compare_ascii_no_case;
|
|
using support::getVectorFromString;
|
|
|
|
using std::endl;
|
|
using std::make_pair;
|
|
using std::string;
|
|
using std::vector;
|
|
using std::find_if;
|
|
|
|
|
|
namespace {
|
|
|
|
class ToolbarNamesEqual : public std::unary_function<ToolbarInfo, bool> {
|
|
public:
|
|
ToolbarNamesEqual(string const & name)
|
|
: name_(name) {}
|
|
bool operator()(ToolbarInfo const & tbinfo) const
|
|
{
|
|
return tbinfo.name == name_;
|
|
}
|
|
private:
|
|
string name_;
|
|
};
|
|
|
|
} // namespace anon
|
|
|
|
|
|
ToolbarBackend toolbarbackend;
|
|
|
|
|
|
ToolbarItem::ToolbarItem(Type type, FuncRequest const & func, docstring const & label)
|
|
: type_(type), func_(func), label_(label)
|
|
{
|
|
}
|
|
|
|
|
|
ToolbarItem::ToolbarItem(Type type, string const & name, docstring const & label)
|
|
: type_(type), label_(label), name_(name)
|
|
{
|
|
}
|
|
|
|
|
|
ToolbarItem::~ToolbarItem()
|
|
{}
|
|
|
|
|
|
void ToolbarInfo::add(ToolbarItem const & item)
|
|
{
|
|
items.push_back(item);
|
|
items.back().func_.origin = FuncRequest::TOOLBAR;
|
|
}
|
|
|
|
|
|
ToolbarInfo & ToolbarInfo::read(Lexer & lex)
|
|
{
|
|
enum tooltags {
|
|
TO_COMMAND = 1,
|
|
TO_ENDTOOLBAR,
|
|
TO_SEPARATOR,
|
|
TO_LAYOUTS,
|
|
TO_MINIBUFFER,
|
|
TO_TABLEINSERT,
|
|
TO_POPUPMENU,
|
|
TO_ICONPALETTE,
|
|
TO_LAST
|
|
};
|
|
|
|
struct keyword_item toolTags[TO_LAST - 1] = {
|
|
{ "end", TO_ENDTOOLBAR },
|
|
{ "iconpalette", TO_ICONPALETTE },
|
|
{ "item", TO_COMMAND },
|
|
{ "layouts", TO_LAYOUTS },
|
|
{ "minibuffer", TO_MINIBUFFER },
|
|
{ "popupmenu", TO_POPUPMENU },
|
|
{ "separator", TO_SEPARATOR },
|
|
{ "tableinsert", TO_TABLEINSERT }
|
|
};
|
|
|
|
//consistency check
|
|
if (compare_ascii_no_case(lex.getString(), "toolbar")) {
|
|
lyxerr << "ToolbarInfo::read: ERROR wrong token:`"
|
|
<< lex.getString() << '\'' << endl;
|
|
}
|
|
|
|
lex.next(true);
|
|
name = lex.getString();
|
|
|
|
lex.next(true);
|
|
gui_name = lex.getString();
|
|
|
|
// FIXME what to do here?
|
|
if (!lex) {
|
|
lyxerr << "ToolbarInfo::read: Malformed toolbar "
|
|
"description " << lex.getString() << endl;
|
|
return *this;
|
|
}
|
|
|
|
bool quit = false;
|
|
|
|
lex.pushTable(toolTags, TO_LAST - 1);
|
|
|
|
if (lyxerr.debugging(Debug::PARSER))
|
|
lex.printTable(lyxerr);
|
|
|
|
while (lex.isOK() && !quit) {
|
|
switch (lex.lex()) {
|
|
case TO_COMMAND:
|
|
if (lex.next(true)) {
|
|
docstring const tooltip = translateIfPossible(lex.getDocString());
|
|
lex.next(true);
|
|
string const func_arg = lex.getString();
|
|
LYXERR(Debug::PARSER)
|
|
<< "ToolbarInfo::read TO_COMMAND func: `"
|
|
<< func_arg << '\'' << endl;
|
|
|
|
FuncRequest func =
|
|
lyxaction.lookupFunc(func_arg);
|
|
add(ToolbarItem(ToolbarItem::COMMAND, func, tooltip));
|
|
}
|
|
break;
|
|
|
|
case TO_MINIBUFFER:
|
|
add(ToolbarItem(ToolbarItem::MINIBUFFER,
|
|
FuncRequest(kb_action(ToolbarItem::MINIBUFFER))));
|
|
break;
|
|
|
|
case TO_SEPARATOR:
|
|
add(ToolbarItem(ToolbarItem::SEPARATOR,
|
|
FuncRequest(kb_action(ToolbarItem::SEPARATOR))));
|
|
break;
|
|
|
|
case TO_POPUPMENU:
|
|
if (lex.next(true)) {
|
|
string const name = lex.getString();
|
|
lex.next(true);
|
|
docstring const label = lex.getDocString();
|
|
add(ToolbarItem(ToolbarItem::POPUPMENU, name, label));
|
|
}
|
|
break;
|
|
|
|
case TO_ICONPALETTE:
|
|
if (lex.next(true)) {
|
|
string const name = lex.getString();
|
|
lex.next(true);
|
|
docstring const label = lex.getDocString();
|
|
add(ToolbarItem(ToolbarItem::ICONPALETTE, name, label));
|
|
}
|
|
break;
|
|
|
|
case TO_LAYOUTS:
|
|
add(ToolbarItem(ToolbarItem::LAYOUTS,
|
|
FuncRequest(kb_action(ToolbarItem::LAYOUTS))));
|
|
break;
|
|
|
|
case TO_TABLEINSERT:
|
|
if (lex.next(true)) {
|
|
docstring const tooltip = lex.getDocString();
|
|
add(ToolbarItem(ToolbarItem::TABLEINSERT,
|
|
FuncRequest(kb_action(ToolbarItem::TABLEINSERT)), tooltip));
|
|
}
|
|
break;
|
|
|
|
case TO_ENDTOOLBAR:
|
|
quit = true;
|
|
break;
|
|
|
|
default:
|
|
lex.printError("ToolbarInfo::read: "
|
|
"Unknown toolbar tag: `$$Token'");
|
|
break;
|
|
}
|
|
}
|
|
|
|
lex.popTable();
|
|
return *this;
|
|
}
|
|
|
|
|
|
|
|
|
|
ToolbarBackend::ToolbarBackend()
|
|
{
|
|
}
|
|
|
|
|
|
void ToolbarBackend::readToolbars(Lexer & lex)
|
|
{
|
|
enum tooltags {
|
|
TO_TOOLBAR = 1,
|
|
TO_ENDTOOLBARSET,
|
|
TO_LAST
|
|
};
|
|
|
|
struct keyword_item toolTags[TO_LAST - 1] = {
|
|
{ "end", TO_ENDTOOLBARSET },
|
|
{ "toolbar", TO_TOOLBAR }
|
|
};
|
|
|
|
//consistency check
|
|
if (compare_ascii_no_case(lex.getString(), "toolbarset")) {
|
|
lyxerr << "ToolbarBackend::readToolbars: ERROR wrong token:`"
|
|
<< lex.getString() << '\'' << endl;
|
|
}
|
|
|
|
lex.pushTable(toolTags, TO_LAST - 1);
|
|
|
|
if (lyxerr.debugging(Debug::PARSER))
|
|
lex.printTable(lyxerr);
|
|
|
|
bool quit = false;
|
|
while (lex.isOK() && !quit) {
|
|
switch (lex.lex()) {
|
|
case TO_TOOLBAR: {
|
|
ToolbarInfo tbinfo;
|
|
tbinfo.read(lex);
|
|
toolbars.push_back(tbinfo);
|
|
break;
|
|
}
|
|
case TO_ENDTOOLBARSET:
|
|
quit = true;
|
|
break;
|
|
default:
|
|
lex.printError("ToolbarBackend::readToolbars: "
|
|
"Unknown toolbar tag: `$$Token'");
|
|
break;
|
|
}
|
|
}
|
|
|
|
lex.popTable();
|
|
}
|
|
|
|
|
|
void ToolbarBackend::readToolbarSettings(Lexer & lex)
|
|
{
|
|
//consistency check
|
|
if (compare_ascii_no_case(lex.getString(), "toolbars")) {
|
|
lyxerr << "ToolbarBackend::readToolbarSettings: ERROR wrong token:`"
|
|
<< lex.getString() << '\'' << endl;
|
|
}
|
|
|
|
lex.next(true);
|
|
|
|
while (lex.isOK()) {
|
|
string name = lex.getString();
|
|
lex.next(true);
|
|
|
|
if (!compare_ascii_no_case(name, "end"))
|
|
return;
|
|
|
|
Toolbars::iterator tcit = toolbars.begin();
|
|
Toolbars::iterator tend = toolbars.end();
|
|
for (; tcit != tend; ++tcit) {
|
|
if (tcit->name == name)
|
|
break;
|
|
}
|
|
|
|
if (tcit == tend) {
|
|
lyxerr << "ToolbarBackend: undefined toolbar "
|
|
<< name << endl;
|
|
return;
|
|
}
|
|
|
|
tcit->flags = static_cast<ToolbarInfo::Flags>(0);
|
|
string flagstr = lex.getString();
|
|
lex.next(true);
|
|
vector<string> flags = getVectorFromString(flagstr);
|
|
|
|
vector<string>::const_iterator cit = flags.begin();
|
|
vector<string>::const_iterator end = flags.end();
|
|
|
|
for (; cit != end; ++cit) {
|
|
int flag = 0;
|
|
if (!compare_ascii_no_case(*cit, "off"))
|
|
flag = ToolbarInfo::OFF;
|
|
else if (!compare_ascii_no_case(*cit, "on"))
|
|
flag = ToolbarInfo::ON;
|
|
else if (!compare_ascii_no_case(*cit, "math"))
|
|
flag = ToolbarInfo::MATH;
|
|
else if (!compare_ascii_no_case(*cit, "table"))
|
|
flag = ToolbarInfo::TABLE;
|
|
else if (!compare_ascii_no_case(*cit, "review"))
|
|
flag = ToolbarInfo::REVIEW;
|
|
else if (!compare_ascii_no_case(*cit, "top"))
|
|
flag = ToolbarInfo::TOP;
|
|
else if (!compare_ascii_no_case(*cit, "bottom"))
|
|
flag = ToolbarInfo::BOTTOM;
|
|
else if (!compare_ascii_no_case(*cit, "left"))
|
|
flag = ToolbarInfo::LEFT;
|
|
else if (!compare_ascii_no_case(*cit, "right"))
|
|
flag = ToolbarInfo::RIGHT;
|
|
else {
|
|
lyxerr << "ToolbarBackend::readToolbarSettings: unrecognised token:`"
|
|
<< *cit << '\'' << endl;
|
|
}
|
|
tcit->flags = static_cast<ToolbarInfo::Flags>(tcit->flags | flag);
|
|
}
|
|
|
|
usedtoolbars.push_back(*tcit);
|
|
}
|
|
}
|
|
|
|
|
|
ToolbarInfo const * ToolbarBackend::getDefinedToolbarInfo(string const & name) const
|
|
{
|
|
Toolbars::const_iterator it = find_if(toolbars.begin(), toolbars.end(), ToolbarNamesEqual(name));
|
|
if (it == toolbars.end())
|
|
return 0;
|
|
return &(*it);
|
|
}
|
|
|
|
|
|
ToolbarInfo * ToolbarBackend::getUsedToolbarInfo(string const &name)
|
|
{
|
|
Toolbars::iterator it = find_if(usedtoolbars.begin(), usedtoolbars.end(), ToolbarNamesEqual(name));
|
|
if (it == usedtoolbars.end())
|
|
return 0;
|
|
return &(*it);
|
|
}
|
|
|
|
} // namespace lyx
|