mirror of
https://git.lyx.org/repos/lyx.git
synced 2024-09-21 15:18:45 +00:00
6130fe1aa5
git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@366 a592a061-630c-0410-9148-cb99ea01b6c8
638 lines
14 KiB
C
638 lines
14 KiB
C
/* This file is part of
|
|
* ======================================================
|
|
*
|
|
* LyX, The Document Processor
|
|
*
|
|
* Copyright 1995 Matthias Ettrich
|
|
* Copyright 1995-1999 The LyX Team.
|
|
*
|
|
* This file is Copyright 1996-1998
|
|
* Lars Gullik Bjønnes
|
|
*
|
|
* ====================================================== */
|
|
|
|
// Added pseudo-action handling, asierra 180296
|
|
|
|
#include <config.h>
|
|
|
|
#ifdef __GNUG__
|
|
#pragma implementation "toolbar.h"
|
|
#endif
|
|
|
|
#include "lyx_main.h"
|
|
#include "lyx_gui_misc.h"
|
|
#include "lyx.h"
|
|
#include "toolbar.h"
|
|
#include "lyxfunc.h"
|
|
#include "lyxlex.h"
|
|
#include "debug.h"
|
|
#include "combox.h"
|
|
#include "lyx_cb.h"
|
|
#include "LyXView.h"
|
|
#include "LyXAction.h"
|
|
#include "support/lstrings.h"
|
|
|
|
#ifdef TWO_COLOR_ICONS
|
|
#include "cut_bw.xpm"
|
|
#include "emph_bw.xpm"
|
|
#include "fig_bw.xpm"
|
|
#include "foot_bw.xpm"
|
|
#include "math_bw.xpm"
|
|
#include "depth_bw.xpm"
|
|
#include "margin_bw.xpm"
|
|
#include "melt_bw.xpm"
|
|
#include "copy_bw.xpm"
|
|
#include "noun_bw.xpm"
|
|
#include "paste_bw.xpm"
|
|
#include "free_bw.xpm"
|
|
#include "tab_bw.xpm"
|
|
#include "tex_bw.xpm"
|
|
#include "open_bw.xpm"
|
|
#include "close_bw.xpm"
|
|
#include "save_bw.xpm"
|
|
#include "print1_bw.xpm"
|
|
#include "quit_bw.xpm"
|
|
#include "typeset_ps_bw.xpm"
|
|
#include "unknown_bw.xpm"
|
|
#else
|
|
#include "cut.xpm"
|
|
#include "emph.xpm"
|
|
#include "fig.xpm"
|
|
#include "foot.xpm"
|
|
#include "math.xpm"
|
|
#include "depth.xpm"
|
|
#include "margin.xpm"
|
|
#include "melt.xpm"
|
|
#include "copy.xpm"
|
|
#include "noun.xpm"
|
|
#include "paste.xpm"
|
|
#include "free.xpm"
|
|
#include "tab.xpm"
|
|
#include "tex.xpm"
|
|
#include "open.xpm"
|
|
#include "close.xpm"
|
|
#include "save.xpm"
|
|
#include "print1.xpm"
|
|
#include "quit.xpm"
|
|
#include "typeset_ps.xpm"
|
|
#include "unknown.xpm"
|
|
#endif
|
|
|
|
// These pixmaps are the same regardless of color:
|
|
#include "bold_bw.xpm"
|
|
#include "make_ascii_bw.xpm"
|
|
#include "make_latex_bw.xpm"
|
|
#include "run_latex_bw.xpm"
|
|
#include "sans_bw.xpm"
|
|
#include "view_dvi_bw.xpm"
|
|
#include "view_ps_bw.xpm"
|
|
#include "layout_code.xpm"
|
|
#include "layout_latex.xpm"
|
|
#include "layout_scrap.xpm"
|
|
#include "layout_sec.xpm"
|
|
#include "layout_std.xpm"
|
|
#include "build.xpm"
|
|
|
|
// this one is not "C" because combox callbacks are really C++ %-|
|
|
extern void LayoutsCB(int, void*);
|
|
extern char const ** get_pixmap_from_symbol(char const * arg, int, int);
|
|
extern LyXAction lyxaction;
|
|
|
|
|
|
enum _tooltags {
|
|
TO_ADD = 1,
|
|
TO_ENDTOOLBAR,
|
|
TO_SEPARATOR,
|
|
TO_LAYOUTS,
|
|
TO_NEWLINE,
|
|
TO_LAST
|
|
};
|
|
|
|
|
|
struct keyword_item toolTags[TO_LAST-1] = {
|
|
{ "\\add", TO_ADD },
|
|
{ "\\end_toolbar", TO_ENDTOOLBAR },
|
|
{ "\\layouts", TO_LAYOUTS },
|
|
{ "\\newline", TO_NEWLINE },
|
|
{ "\\separator", TO_SEPARATOR }
|
|
};
|
|
|
|
|
|
Toolbar::Toolbar(Toolbar const &rct, LyXView *o, int x, int y)
|
|
: owner(o), sxpos(x), sypos(y)
|
|
{
|
|
combox = 0;
|
|
bubble_timer = 0;
|
|
reset();
|
|
|
|
// extracts the toolbar struct form rct.
|
|
toolbarItem *tmplist = rct.toollist;
|
|
while (tmplist != 0) {
|
|
add(tmplist->action);
|
|
lyxerr[Debug::TOOLBAR] << "tool action: "
|
|
<< tmplist->action << endl;
|
|
tmplist= tmplist->next;
|
|
}
|
|
}
|
|
|
|
|
|
// timer-cb for bubble-help (Matthias)
|
|
void Toolbar::BubbleTimerCB(FL_OBJECT *, long data)
|
|
{
|
|
FL_OBJECT * ob = reinterpret_cast<FL_OBJECT*>(data);
|
|
char* help = static_cast<char*>(ob->u_vdata);
|
|
fl_show_oneliner(help, ob->form->x + ob->x,
|
|
ob->form->y + ob->y + ob->h);
|
|
}
|
|
|
|
|
|
extern "C" void C_Toolbar_BubbleTimerCB(FL_OBJECT * ob, long data)
|
|
{
|
|
Toolbar::BubbleTimerCB(ob, data);
|
|
}
|
|
|
|
|
|
// post_handler for bubble-help (Matthias)
|
|
int Toolbar::BubblePost(FL_OBJECT *ob, int event,
|
|
FL_Coord /*mx*/, FL_Coord /*my*/, int /*key*/, void */*xev*/)
|
|
{
|
|
string help = static_cast<char *>(ob->u_vdata);
|
|
Toolbar * t = reinterpret_cast<Toolbar*>(ob->u_ldata);
|
|
|
|
if(event == FL_ENTER && !help.empty()){
|
|
fl_set_object_callback(t->bubble_timer,
|
|
C_Toolbar_BubbleTimerCB,
|
|
reinterpret_cast<long>(ob));
|
|
fl_set_timer(t->bubble_timer, 1);
|
|
}
|
|
else if(event != FL_MOTION){
|
|
fl_set_timer(t->bubble_timer, 0);
|
|
fl_hide_oneliner();
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
extern "C" int C_Toolbar_BubblePost(FL_OBJECT * ob, int event,
|
|
FL_Coord /*mx*/, FL_Coord /*my*/,
|
|
int key, void * xev)
|
|
{
|
|
return Toolbar::BubblePost(ob, event, 0, 0, key, xev);
|
|
}
|
|
|
|
|
|
void Toolbar::activate()
|
|
{
|
|
toolbarItem * tmp= 0;
|
|
toolbarItem * item = toollist;
|
|
while(item){
|
|
tmp = item->next;
|
|
if (item->icon) {
|
|
fl_activate_object(item->icon);
|
|
}
|
|
item = tmp;
|
|
}
|
|
}
|
|
|
|
|
|
void Toolbar::deactivate()
|
|
{
|
|
toolbarItem * tmp= 0;
|
|
toolbarItem * item = toollist;
|
|
while(item){
|
|
tmp = item->next;
|
|
if (item->icon) {
|
|
fl_deactivate_object(item->icon);
|
|
}
|
|
item = tmp;
|
|
}
|
|
}
|
|
|
|
|
|
void Toolbar::ToolbarCB(FL_OBJECT * ob, long ac)
|
|
{
|
|
Toolbar * t = reinterpret_cast<Toolbar*>(ob->u_ldata);
|
|
|
|
string res = t->owner->getLyXFunc()->Dispatch(int(ac));
|
|
if(!res.empty())
|
|
lyxerr[Debug::TOOLBAR] << res << endl;
|
|
}
|
|
|
|
|
|
extern "C" void C_Toolbar_ToolbarCB(FL_OBJECT * ob, long data)
|
|
{
|
|
Toolbar::ToolbarCB(ob, data);
|
|
}
|
|
|
|
|
|
int Toolbar::get_toolbar_func(string const & func)
|
|
{
|
|
int action = lyxaction.LookupFunc(func.c_str());
|
|
if (action == -1) {
|
|
if (func == "separator"){
|
|
action = TOOL_SEPARATOR;
|
|
} else if (func == "layouts"){
|
|
action = TOOL_LAYOUTS;
|
|
} else action = 0;
|
|
}
|
|
return action;
|
|
}
|
|
|
|
|
|
void Toolbar::init()
|
|
{
|
|
add(TOOL_LAYOUTS);
|
|
add(LFUN_MENUOPEN);
|
|
//add(LFUN_CLOSEBUFFER);
|
|
add(LFUN_MENUWRITE);
|
|
add(LFUN_MENUPRINT);
|
|
add(TOOL_SEPARATOR);
|
|
|
|
add(LFUN_CUT);
|
|
add(LFUN_COPY);
|
|
add(LFUN_PASTE);
|
|
add(TOOL_SEPARATOR);
|
|
|
|
add(LFUN_EMPH);
|
|
add(LFUN_NOUN);
|
|
add(LFUN_FREE);
|
|
add(TOOL_SEPARATOR);
|
|
|
|
add(LFUN_FOOTMELT);
|
|
add(LFUN_MARGINMELT);
|
|
add(LFUN_DEPTH);
|
|
add(TOOL_SEPARATOR);
|
|
|
|
add(LFUN_TEX);
|
|
add(LFUN_MATH_MODE);
|
|
add(TOOL_SEPARATOR);
|
|
|
|
add(LFUN_FIGURE);
|
|
add(LFUN_TABLE);
|
|
//add(LFUN_MELT);
|
|
}
|
|
|
|
|
|
void Toolbar::set(bool doingmain)
|
|
{
|
|
// we shouldn't set if we have not cleaned
|
|
if (!cleaned) return;
|
|
|
|
FL_OBJECT * obj;
|
|
toolbarItem * item = toollist;
|
|
|
|
if (!doingmain) {
|
|
fl_freeze_form(owner->getForm());
|
|
fl_addto_form(owner->getForm());
|
|
}
|
|
|
|
#if FL_REVISION <86
|
|
// Ensure borderwidth is 2 to get visual feedback
|
|
int bw = fl_get_border_width();
|
|
fl_set_border_width(-2);
|
|
#endif
|
|
|
|
// add the time if it don't exist
|
|
if (bubble_timer == 0)
|
|
bubble_timer = fl_add_timer(FL_HIDDEN_TIMER,
|
|
xpos, ypos, 0, 0, "Timer");
|
|
|
|
while(item != 0) {
|
|
switch(item->action){
|
|
case TOOL_SEPARATOR:
|
|
xpos += sepspace;
|
|
item = item->next;
|
|
break;
|
|
case TOOL_LAYOUTS:
|
|
xpos += standardspacing;
|
|
if (!combox)
|
|
combox = new Combox(FL_COMBOX_DROPLIST);
|
|
combox->add(xpos, ypos, 135, height, 300);
|
|
combox->setcallback(LayoutsCB);
|
|
combox->resize(FL_RESIZE_ALL);
|
|
combox->gravity(NorthWestGravity, NorthWestGravity);
|
|
item = item->next;
|
|
xpos += 135;
|
|
break;
|
|
default:
|
|
xpos += standardspacing;
|
|
item->icon = obj =
|
|
fl_add_pixmapbutton(FL_NORMAL_BUTTON,
|
|
xpos, ypos,
|
|
buttonwidth,
|
|
height, "");
|
|
fl_set_object_boxtype(obj, FL_UP_BOX);
|
|
fl_set_object_color(obj, FL_MCOL, FL_BLUE);
|
|
fl_set_object_resize(obj, FL_RESIZE_ALL);
|
|
fl_set_object_gravity(obj,
|
|
NorthWestGravity,
|
|
NorthWestGravity);
|
|
fl_set_object_callback(obj, C_Toolbar_ToolbarCB,
|
|
static_cast<long>(item->action));
|
|
#if FL_REVISION >85
|
|
// Remove the blue feedback rectangle
|
|
fl_set_pixmapbutton_focus_outline(obj, 0);
|
|
#endif
|
|
|
|
// set the bubble-help (Matthias)
|
|
#warning This is dangerous!
|
|
obj->u_vdata = const_cast<char*>(item->help.c_str());
|
|
// we need to know what toolbar this item
|
|
// belongs too. (Lgb)
|
|
obj->u_ldata = reinterpret_cast<long>(this);
|
|
|
|
fl_set_object_posthandler(obj, C_Toolbar_BubblePost);
|
|
|
|
fl_set_pixmapbutton_data(obj, const_cast<char**>(item->pixmap));
|
|
item = item->next;
|
|
// we must remember to update the positions
|
|
xpos += buttonwidth;
|
|
// ypos is constant
|
|
/* Here will come a check to see if the new
|
|
* pos is within the bounds of the main frame,
|
|
* and perhaps wrap the toolbar if not.
|
|
*/
|
|
break;
|
|
}
|
|
}
|
|
#if FL_REVISION <86
|
|
// Reset borderwidth to its default value.
|
|
fl_set_border_width(bw);
|
|
#endif
|
|
if (!doingmain) {
|
|
fl_end_form();
|
|
fl_unfreeze_form(owner->getForm());
|
|
// Should be safe to do this here.
|
|
owner->updateLayoutChoice();
|
|
}
|
|
|
|
cleaned = false;
|
|
}
|
|
|
|
|
|
char const **Toolbar::getPixmap(kb_action action, string const & arg)
|
|
{
|
|
char const ** pixmap = unknown_xpm; //0
|
|
switch(action){
|
|
case LFUN_MENUOPEN: pixmap = open_xpm; break;
|
|
case LFUN_CLOSEBUFFER: pixmap = close_xpm; break;
|
|
case LFUN_MENUPRINT: pixmap = print1_xpm; break;
|
|
case LFUN_MENUWRITE: pixmap = save_xpm; break;
|
|
case LFUN_EMPH: pixmap = emph_xpm; break;
|
|
case LFUN_NOUN: pixmap = noun_xpm; break;
|
|
case LFUN_FREE: pixmap = free_xpm; break;
|
|
case LFUN_FOOTMELT: pixmap = foot_xpm; break;
|
|
case LFUN_DEPTH: pixmap = depth_xpm; break;
|
|
case LFUN_COPY: pixmap = copy_xpm; break;
|
|
case LFUN_CUT: pixmap = cut_xpm; break;
|
|
case LFUN_PASTE: pixmap = paste_xpm; break;
|
|
case LFUN_TEX: pixmap = tex_xpm; break;
|
|
case LFUN_MATH_MODE: pixmap = math_xpm; break;
|
|
case LFUN_MARGINMELT: pixmap = margin_xpm; break;
|
|
case LFUN_FIGURE: pixmap = fig_xpm; break;
|
|
case LFUN_TABLE: pixmap = tab_xpm; break;
|
|
case LFUN_MELT: pixmap = melt_xpm; break;
|
|
case LFUN_QUIT: pixmap = quit_xpm; break;
|
|
case LFUN_RUNDVIPS: pixmap = update_ps_xpm; break;
|
|
case LFUN_EXPORT:
|
|
{
|
|
if (arg == "ascii")
|
|
pixmap = make_ascii_xpm;
|
|
else if (arg == "latex")
|
|
pixmap = make_latex_xpm;
|
|
}
|
|
break;
|
|
case LFUN_LAYOUT:
|
|
{
|
|
if (arg == "Section")
|
|
pixmap = layout_sec_xpm;
|
|
else if (arg == "LaTeX")
|
|
pixmap = layout_latex_xpm;
|
|
else if (arg == "LyX-Code")
|
|
pixmap = layout_code_xpm;
|
|
else if (arg == "Scrap")
|
|
pixmap = layout_scrap_xpm;
|
|
else
|
|
pixmap = layout_std_xpm;
|
|
}
|
|
break;
|
|
|
|
case LFUN_BOLD : pixmap = bold_xpm; break;
|
|
case LFUN_SANS: pixmap = sans_xpm; break;
|
|
case LFUN_RUNLATEX: pixmap = run_latex_xpm; break;
|
|
case LFUN_BUILDPROG: pixmap = build_xpm; break;
|
|
case LFUN_PREVIEWPS: pixmap = view_ps_xpm; break;
|
|
case LFUN_PREVIEW: pixmap = view_dvi_xpm; break;
|
|
case LFUN_INSERT_MATH:
|
|
{
|
|
if (!arg.empty())
|
|
pixmap = get_pixmap_from_symbol(arg.c_str(),
|
|
buttonwidth,
|
|
height);
|
|
}
|
|
break;
|
|
default:
|
|
//pixmap = unknown_xpm;
|
|
break;
|
|
}
|
|
return pixmap;
|
|
}
|
|
|
|
|
|
void Toolbar::add(int action, bool doclean)
|
|
{
|
|
if (doclean && !cleaned) clean();
|
|
|
|
// this is what we do if we want to add to an existing
|
|
// toolbar.
|
|
if (!doclean && owner) {
|
|
// first «hide» the toolbar buttons. This is not a real hide
|
|
// actually it deletes and frees the button altogether.
|
|
lyxerr << "Toolbar::add: «hide» the toolbar buttons." << endl;
|
|
toolbarItem * tmp= 0;
|
|
toolbarItem * item = toollist;
|
|
|
|
lightReset();
|
|
|
|
fl_freeze_form(owner->getForm());
|
|
while(item){
|
|
tmp = item->next;
|
|
if (item->icon) {
|
|
fl_delete_object(item->icon);
|
|
fl_free_object(item->icon);
|
|
}
|
|
item = tmp;
|
|
}
|
|
if (combox) {
|
|
delete combox;
|
|
combox = 0;
|
|
}
|
|
fl_unfreeze_form(owner->getForm());
|
|
cleaned = true; // this is not completely true, but OK anyway
|
|
}
|
|
|
|
// there exist some special actions not part of
|
|
// kb_action: SEPARATOR, LAYOUTS
|
|
char const ** pixmap = 0;
|
|
string help;
|
|
|
|
toolbarItem * newItem, * tmp;
|
|
|
|
if (lyxaction.isPseudoAction(action)) {
|
|
string arg;
|
|
kb_action act = static_cast<kb_action>(lyxaction.retrieveActionArg(action, arg));
|
|
pixmap = getPixmap(act, arg);
|
|
help = lyxaction.helpText(act);
|
|
help += " ";
|
|
help += arg;
|
|
lyxerr.debug() << "Pseudo action " << action << endl;
|
|
} else {
|
|
pixmap = getPixmap(static_cast<kb_action>(action));
|
|
help = lyxaction.helpText(static_cast<kb_action>(action));
|
|
}
|
|
|
|
// adds an item to the list
|
|
if (pixmap != 0
|
|
|| action == TOOL_SEPARATOR
|
|
|| action == TOOL_LAYOUTS)
|
|
{
|
|
newItem = new toolbarItem;
|
|
newItem->action = action;
|
|
newItem->pixmap = pixmap;
|
|
newItem->help = help;
|
|
// the new item is placed at the end of the list
|
|
tmp = toollist;
|
|
if (tmp != 0){
|
|
while(tmp->next != 0)
|
|
tmp = tmp->next;
|
|
// here is tmp->next == 0
|
|
tmp->next = newItem;
|
|
} else
|
|
toollist = newItem;
|
|
}
|
|
//if (action == TOOL_LAYOUTS) {
|
|
// combox = new Combox(FL_COMBOX_DROPLIST);
|
|
//}
|
|
}
|
|
|
|
|
|
void Toolbar::add(string const & func, bool doclean)
|
|
{
|
|
int tf = lyxaction.LookupFunc(func.c_str());
|
|
|
|
if (tf == -1){
|
|
lyxerr << "Toolbar::add: no LyX command called`"
|
|
<< func << "'exists!" << endl;
|
|
} else {
|
|
add(tf, doclean);
|
|
}
|
|
}
|
|
|
|
|
|
void Toolbar::clean()
|
|
{
|
|
toolbarItem * tmp = 0;
|
|
toolbarItem * item = toollist;
|
|
|
|
reset();
|
|
|
|
//now delete all the objects..
|
|
if (owner)
|
|
fl_freeze_form(owner->getForm());
|
|
while (item) {
|
|
tmp = item->next;
|
|
delete item;
|
|
item = tmp;
|
|
}
|
|
lyxerr[Debug::TOOLBAR] << "Combox: " << combox << endl;
|
|
if (combox) {
|
|
delete combox;
|
|
combox = 0;
|
|
}
|
|
if (owner)
|
|
fl_unfreeze_form(owner->getForm());
|
|
lyxerr[Debug::TOOLBAR] << "toolbar cleaned" << endl;
|
|
cleaned = true;
|
|
}
|
|
|
|
|
|
void Toolbar::push(int nth)
|
|
{
|
|
lyxerr[Debug::TOOLBAR] << "Toolbar::push: trying to trigger no `"
|
|
<< nth << '\'' << endl;
|
|
|
|
if (nth == 0) return;
|
|
|
|
int count = 0;
|
|
toolbarItem * tmp = toollist;
|
|
while (tmp) {
|
|
count++;
|
|
if (count == nth) {
|
|
fl_trigger_object(tmp->icon);
|
|
return;
|
|
}
|
|
tmp = tmp->next;
|
|
}
|
|
// item nth not found...
|
|
LyXBell();
|
|
}
|
|
|
|
|
|
void Toolbar::read(LyXLex & lex)
|
|
{
|
|
//consistency check
|
|
if (lex.GetString() != "\\begin_toolbar")
|
|
lyxerr << "Toolbar::read: ERROR wrong token:`"
|
|
<< lex.GetString() << '\'' << endl;
|
|
|
|
clean();
|
|
string func;
|
|
bool quit = false;
|
|
|
|
lex.pushTable(toolTags, TO_LAST - 1);
|
|
|
|
if (lyxerr.debugging(Debug::PARSER))
|
|
lex.printTable();
|
|
|
|
while (lex.IsOK() && !quit) {
|
|
|
|
lyxerr[Debug::TOOLBAR] << "Toolbar::read: current lex text: `"
|
|
<< lex.GetString() << '\'' << endl;
|
|
|
|
switch(lex.lex()) {
|
|
case TO_ADD:
|
|
if (lex.EatLine()) {
|
|
func = lex.GetString();
|
|
lyxerr[Debug::TOOLBAR]
|
|
<< "Toolbar::read TO_ADD func: `"
|
|
<< func << "'" << endl;
|
|
add(func);
|
|
}
|
|
break;
|
|
|
|
case TO_SEPARATOR:
|
|
add(TOOL_SEPARATOR);
|
|
break;
|
|
|
|
case TO_LAYOUTS:
|
|
add(TOOL_LAYOUTS);
|
|
break;
|
|
|
|
case TO_NEWLINE:
|
|
add(TOOL_NEWLINE);
|
|
break;
|
|
|
|
case TO_ENDTOOLBAR:
|
|
// should not set automatically
|
|
//set();
|
|
quit = true;
|
|
break;
|
|
default:
|
|
lex.printError("Toolbar::read: "
|
|
"Unknown toolbar tag: `$$Token'");
|
|
break;
|
|
}
|
|
}
|
|
lex.popTable();
|
|
}
|