src/lyxfunc.C

   1 /* This file is part of
   2  * ======================================================
   3  *
   4  *           LyX, The Document Processor
   5  *
   6  *          Copyright 1995 Matthias Ettrich
   7  *          Copyright 1995-2000 The LyX Team.
   8  *
   9  * ====================================================== */
  10
  11 #include <config.h>
  12
  13 #ifdef HAVE_SSTREAM
  14 #include <sstream>
  15 using std::istringstream;
  16 #else
  17 #include <strstream>
  18 #endif
  19
  20 #include <time.h>
  21 #include <locale.h>
  22
  23 #include <cstdlib>
  24 #include <cctype>
  25 #include <cstring>
  26
  27 #ifdef __GNUG__
  28 #pragma implementation
  29 #endif
  30
  31 #include "version.h"
  32 #include "lyxlookup.h"
  33 #include "kbmap.h"
  34 #include "lyxfunc.h"
  35 #include "bufferlist.h"
  36 #include "ColorHandler.h"
  37 #include "lyxserver.h"
  38 #include "lyx.h"
  39 #include "intl.h"
  40 #include "lyx_main.h"
  41 #include "lyx_cb.h"
  42 #include "LyXAction.h"
  43 #include "insets/inseturl.h"
  44 #include "insets/insetlatexaccent.h"
  45 #include "insets/insettoc.h"
  46 #include "insets/insetref.h"
  47 #include "insets/insetparent.h"
  48 #include "insets/insetindex.h"
  49 #include "insets/insetinclude.h"
  50 #include "insets/insetbib.h"
  51 #include "insets/insetcite.h"
  52 #include "insets/insettext.h"
  53 #include "insets/insetert.h"
  54 #include "insets/insetexternal.h"
  55 #include "insets/insetgraphics.h"
  56 #include "insets/insetfoot.h"
  57 #include "insets/insetmarginal.h"
  58 #include "insets/insetminipage.h"
  59 #include "insets/insetfloat.h"
  60 #include "insets/insetlist.h"
  61 #include "insets/insettabular.h"
  62 #include "insets/insettheorem.h"
  63 #include "insets/insetcaption.h"
  64 #include "mathed/formulamacro.h"
  65 #include "spellchecker.h" // RVDK_PATCH_5
  66 #include "minibuffer.h"
  67 #include "vspace.h"
  68 #include "LyXView.h"
  69 #include "filedlg.h"
  70 #include "lyx_gui_misc.h"
  71 #include "support/filetools.h"
  72 #include "support/FileInfo.h"
  73 #include "support/syscall.h"
  74 #include "support/lstrings.h"
  75 #include "support/path.h"
  76 #include "debug.h"
  77 #include "lyxrc.h"
  78 #include "lyxtext.h"
  79 #include "gettext.h"
  80 #include "trans_mgr.h"
  81 #include "ImportLaTeX.h"
  82 #include "ImportNoweb.h"
  83 #include "layout.h"
  84 #include "WorkArea.h"
  85 #include "lyxfr1.h"
  86 #include "bufferview_funcs.h"
  87 #include "frontends/Dialogs.h"
  88 #include "frontends/Toolbar.h"
  89 #ifdef NEW_MENUBAR
  90 #include "frontends/Menubar.h"
  91 #else
  92 #include "menus.h"
  93 #endif
  94 #include "FloatList.h"
  95 #include "exporter.h"
  96 #include "FontLoader.h"
  97 #include "TextCache.h"
  98
  99 using std::pair;
 100 using std::endl;
 101
 102 extern bool cursor_follows_scrollbar;
 103
 104 extern void InsertAsciiFile(BufferView *, string const &, bool);
 105 extern void math_insert_symbol(char const *);
 106 extern bool math_insert_greek(char);
 107 extern BufferList bufferlist;
 108 extern LyXServer * lyxserver;
 109 extern int greek_kb_flag;
 110 extern bool selection_possible;
 111
 112 extern kb_keymap * toplevel_keymap;
 113
 114 extern bool MenuWrite(Buffer *);
 115 extern bool MenuWriteAs(Buffer *);
 116 #ifdef NEW_MENUBAR
 117 extern int  MenuRunLaTeX(Buffer *);
 118 #endif
 119 extern int  MenuBuildProg(Buffer *);
 120 extern int  MenuRunChktex(Buffer *);
 121 #ifndef NEW_EXPORT
 122 extern bool CreatePostscript(Buffer *, bool);
 123 #endif
 124 extern void MenuPrint(Buffer *);
 125 extern void MenuSendto();
 126 extern void QuitLyX();
 127 extern void MenuFax(Buffer *);
 128 #ifndef NEW_EXPORT
 129 extern void MenuExport(Buffer *, string const &);
 130 #endif
 131 extern void show_symbols_form(LyXFunc *);
 132
 133 extern LyXAction lyxaction;
 134 // (alkis)
 135 extern tex_accent_struct get_accent(kb_action action);
 136
 137 extern void AutoSave(BufferView *);
 138 #ifndef NEW_EXPORT
 139 extern bool PreviewDVI(Buffer *);
 140 extern bool PreviewPostscript(Buffer *);
 141 #endif
 142 extern void MenuInsertLabel(char const *);
 143 extern void MenuLayoutCharacter();
 144 extern void MenuLayoutParagraph();
 145 extern void MenuLayoutDocument();
 146 extern void MenuLayoutPaper();
 147 extern void MenuLayoutTable(int flag);
 148 extern void MenuLayoutQuotes();
 149 extern void MenuLayoutPreamble();
 150 extern void MenuLayoutSave();
 151 extern void bulletForm();
 152
 153 extern Buffer * NewLyxFile(string const &);
 154 extern void LoadLyXFile(string const &);
 155 extern void Reconfigure(BufferView *);
 156
 157 extern LyXTextClass::size_type current_layout;
 158 extern int getISOCodeFromLaTeX(char *);
 159
 160 extern void ShowLatexLog();
 161
 162 /* === globals =========================================================== */
 163
 164 bool LyXFunc::show_sc = true;
 165
 166
 167 LyXFunc::LyXFunc(LyXView * o)
 168         : owner(o)
 169 {
 170         meta_fake_bit = 0;
 171         lyx_dead_action = LFUN_NOACTION;
 172         lyx_calling_dead_action = LFUN_NOACTION;
 173         setupLocalKeymap();
 174 }
 175
 176
 177 // I changed this func slightly. I commented out the ...FinishUndo(),
 178 // this means that all places that used to have a moveCursorUpdate, now
 179 // have a ...FinishUndo() as the preceeding statement. I have also added
 180 // a moveCursorUpdate to some of the functions that updated the cursor, but
 181 // that did not show its new position.
 182 inline
 183 void LyXFunc::moveCursorUpdate(bool selecting)
 184 {
 185         if (selecting || owner->view()->text->mark_set) {
 186                 owner->view()->text->SetSelection();
 187                 owner->view()->toggleToggle();
 188         }
 189         owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
 190         owner->view()->showCursor();
 191
 192         /* ---> Everytime the cursor is moved, show the current font state. */
 193         // should this too me moved out of this func?
 194         //owner->showState();
 195         owner->view()->setState();
 196 }
 197
 198
 199 int LyXFunc::processKeySym(KeySym keysym, unsigned int state)
 200 {
 201         string argument;
 202
 203         if (lyxerr.debugging(Debug::KEY)) {
 204                 char * tmp = XKeysymToString(keysym);
 205                 string stm = (tmp ? tmp : "");
 206                 lyxerr << "KeySym is "
 207                        << stm
 208                        << "["
 209                        << keysym << "]"
 210                        << endl;
 211         }
 212         // Do nothing if we have nothing (JMarc)
 213         if (keysym == NoSymbol) {
 214                 lyxerr[Debug::KEY] << "Empty kbd action (probably composing)"
 215                                    << endl;
 216                 //return 0;
 217                 return FL_PREEMPT;
 218         }
 219
 220         // this function should be used always [asierra060396]
 221         UpdatableInset * tli = owner->view()->the_locking_inset;
 222         if (owner->view()->available() && tli && (keysym == XK_Escape)) {
 223                 if (tli == tli->GetLockingInset()) {
 224                         owner->view()->unlockInset(tli);
 225                         owner->view()->text->CursorRight(owner->view());
 226                         moveCursorUpdate(false);
 227                         owner->showState();
 228                 } else {
 229                         tli->UnlockInsetInInset(owner->view(),
 230                                                 tli->GetLockingInset(),true);
 231                 }
 232                 //return 0;
 233                 return FL_PREEMPT;
 234         }
 235
 236         // Can we be sure that this will work for all X-Windows
 237         // implementations? (Lgb)
 238         // This code snippet makes lyx ignore some keys. Perhaps
 239         // all of them should be explictly mentioned?
 240         if((keysym >= XK_Shift_L && keysym <= XK_Hyper_R)
 241            || keysym == XK_Mode_switch || keysym == 0x0)
 242                 return 0;
 243
 244         // Do a one-deep top-level lookup for
 245         // cancel and meta-fake keys. RVDK_PATCH_5
 246         cancel_meta_seq.reset();
 247
 248         int action = cancel_meta_seq.addkey(keysym, state
 249                                             &(ShiftMask|ControlMask
 250                                               |Mod1Mask));
 251
 252         // When not cancel or meta-fake, do the normal lookup.
 253         // Note how the meta_fake Mod1 bit is OR-ed in and reset afterwards.
 254         // Mostly, meta_fake_bit = 0. RVDK_PATCH_5.
 255         if ( (action != LFUN_CANCEL) && (action != LFUN_META_FAKE) ) {
 256
 257                 // remove Caps Lock and Mod2 as a modifiers
 258                 action = keyseq.addkey(keysym,
 259                                        (state | meta_fake_bit)
 260                                        &(ShiftMask|ControlMask
 261                                          |Mod1Mask));
 262         }
 263         // Dont remove this unless you know what you are doing.
 264         meta_fake_bit = 0;
 265
 266         if (action == 0) action = LFUN_PREFIX;
 267
 268         if (lyxerr.debugging(Debug::KEY)) {
 269                 string buf;
 270                 keyseq.print(buf);
 271                 lyxerr << "Key ["
 272                        << action << "]["
 273                        << buf << "]"
 274                        << endl;
 275         }
 276
 277         // already here we know if it any point in going further
 278         // why not return already here if action == -1 and
 279         // num_bytes == 0? (Lgb)
 280
 281         if(keyseq.length > 1 || keyseq.length < -1) {
 282                 string buf;
 283                 keyseq.print(buf);
 284                 owner->getMiniBuffer()->Set(buf);
 285         }
 286
 287         if (action == -1) {
 288                 if (keyseq.length < -1) { // unknown key sequence...
 289                         string buf;
 290                         LyXBell();
 291                         keyseq.print(buf);
 292                         owner->getMiniBuffer()->Set(_("Unknown sequence:"), buf);
 293                         return 0;
 294                 }
 295
 296                 char isochar = keyseq.getiso();
 297                 if (!(state & ControlMask) &&
 298                     !(state & Mod1Mask) &&
 299                     (isochar && keysym < 0xF000)) {
 300                         argument += isochar;
 301                 }
 302                 if (argument.empty()) {
 303                         lyxerr.debug() << "Empty argument!" << endl;
 304                         // This can`t possibly be of any use
 305                         // so we`ll skip the dispatch.
 306                         return 0;
 307                 }
 308         }
 309
 310         bool tmp_sc = show_sc;
 311         show_sc = false;
 312         Dispatch(action, argument.c_str());
 313         show_sc = tmp_sc;
 314
 315         return 0;
 316 }
 317
 318
 319 #if 0
 320 int LyXFunc::processKeyEvent(XEvent * ev)
 321 {
 322         char s_r[10];
 323         KeySym keysym_return = 0;
 324         string argument;
 325         XKeyEvent * keyevent = &ev->xkey;
 326         int num_bytes = LyXLookupString(ev, s_r, 10, &keysym_return);
 327         s_r[num_bytes] = '\0';
 328
 329         if (lyxerr.debugging(Debug::KEY)) {
 330                 char * tmp = XKeysymToString(keysym_return);
 331                 string stm = (tmp ? tmp : "");
 332                 lyxerr << "KeySym is "
 333                        << stm
 334                        << "["
 335                        << keysym_return << "]"
 336                        << " and num_bytes is "
 337                        << num_bytes
 338                        << " the string returned is \""
 339                        << s_r << '\"'
 340                        << endl;
 341         }
 342         // Do nothing if we have nothing (JMarc)
 343         if (num_bytes == 0 && keysym_return == NoSymbol) {
 344                 lyxerr[Debug::KEY] << "Empty kbd action (probably composing)"
 345                                    << endl;
 346                 return 0;
 347         }
 348
 349         // this function should be used always [asierra060396]
 350         UpdatableInset * tli = owner->view()->the_locking_inset;
 351         if (owner->view()->available() && tli && (keysym_return==XK_Escape)) {
 352                 if (tli == tli->GetLockingInset()) {
 353                         owner->view()->unlockInset(tli);
 354                         owner->view()->text->CursorRight(owner->view());
 355                         moveCursorUpdate(false);
 356                         owner->showState();
 357                 } else {
 358                         tli->UnlockInsetInInset(owner->view(),
 359                                                 tli->GetLockingInset(),true);
 360                 }
 361                 return 0;
 362         }
 363
 364         // Can we be sure that this will work for all X-Windows
 365         // implementations? (Lgb)
 366         // This code snippet makes lyx ignore some keys. Perhaps
 367         // all of them should be explictly mentioned?
 368         if((keysym_return >= XK_Shift_L && keysym_return <= XK_Hyper_R)
 369            || keysym_return == XK_Mode_switch || keysym_return == 0x0)
 370                 return 0;
 371
 372         // Do a one-deep top-level lookup for
 373         // cancel and meta-fake keys. RVDK_PATCH_5
 374         cancel_meta_seq.reset();
 375
 376         int action = cancel_meta_seq.addkey(keysym_return, keyevent->state
 377                                             &(ShiftMask|ControlMask
 378                                               |Mod1Mask));
 379
 380         // When not cancel or meta-fake, do the normal lookup.
 381         // Note how the meta_fake Mod1 bit is OR-ed in and reset afterwards.
 382         // Mostly, meta_fake_bit = 0. RVDK_PATCH_5.
 383         if ( (action != LFUN_CANCEL) && (action != LFUN_META_FAKE) ) {
 384
 385                 // remove Caps Lock and Mod2 as a modifiers
 386                 action = keyseq.addkey(keysym_return,
 387                                        (keyevent->state | meta_fake_bit)
 388                                        &(ShiftMask|ControlMask
 389                                          |Mod1Mask));
 390         }
 391         // Dont remove this unless you know what you are doing.
 392         meta_fake_bit = 0;
 393
 394         if (action == 0) action = LFUN_PREFIX;
 395
 396         if (lyxerr.debugging(Debug::KEY)) {
 397                 string buf;
 398                 keyseq.print(buf);
 399                 lyxerr << "Key ["
 400                        << action << "]["
 401                        << buf << "]"
 402                        << "["
 403                        << num_bytes << "]"
 404                        << endl;
 405         }
 406
 407         // already here we know if it any point in going further
 408         // why not return already here if action == -1 and
 409         // num_bytes == 0? (Lgb)
 410
 411         if(keyseq.length > 1 || keyseq.length < -1) {
 412                 string buf;
 413                 keyseq.print(buf);
 414                 owner->getMiniBuffer()->Set(buf);
 415         }
 416
 417         if (action == -1) {
 418                 if (keyseq.length < -1) { // unknown key sequence...
 419                         string buf;
 420                         LyXBell();
 421                         keyseq.print(buf);
 422                         owner->getMiniBuffer()->Set(_("Unknown sequence:"), buf);
 423                         return 0;
 424                 }
 425
 426                 char isochar = keyseq.getiso();
 427                 if (!(keyevent->state&ControlMask) &&
 428                     !(keyevent->state&Mod1Mask) &&
 429                     (isochar && keysym_return < 0xF000)) {
 430                         argument += isochar;
 431                 }
 432                 if (argument.empty()) {
 433                         lyxerr.debug() << "Empty argument!" << endl;
 434                         // This can`t possibly be of any use
 435                         // so we`ll skip the dispatch.
 436                         return 0;
 437                 }
 438         }
 439         else
 440                 if (action == LFUN_SELFINSERT) {
 441                         argument = s_r[0];
 442                 }
 443
 444         bool tmp_sc = show_sc;
 445         show_sc = false;
 446         Dispatch(action, argument.c_str());
 447         show_sc = tmp_sc;
 448
 449         return 0;
 450 }
 451 #endif
 452
 453
 454 LyXFunc::func_status LyXFunc::getStatus(int ac) const
 455 {
 456         kb_action action;
 457         func_status flag = LyXFunc::OK;
 458         string argument;
 459         Buffer * buf = owner->buffer();
 460
 461         if (lyxaction.isPseudoAction(ac))
 462                 action = lyxaction.retrieveActionArg(ac, argument);
 463         else
 464                 action = static_cast<kb_action>(ac);
 465
 466         if (action == LFUN_UNKNOWN_ACTION) {
 467                 setErrorMessage(N_("Unknown action"));
 468                 return LyXFunc::Unknown;
 469         }
 470
 471         // Check whether we need a buffer
 472         if (!lyxaction.funcHasFlag(action, LyXAction::NoBuffer)) {
 473                 // Yes we need a buffer, do we have one?
 474                 if (buf) {
 475                         // yes
 476                         // Can we use a readonly buffer?
 477                         if (buf->isReadonly() &&
 478                             !lyxaction.funcHasFlag(action,
 479                                                    LyXAction::ReadOnly)) {
 480                                 // no
 481                                 setErrorMessage(N_("Document is read-only"));
 482                                 flag |= LyXFunc::Disabled;
 483                         }
 484                 } else {
 485                         // no
 486                         setErrorMessage(N_("Command not allowed with"
 487                                            "out any document open"));
 488                         flag |= LyXFunc::Disabled;
 489                         return flag;
 490                 }
 491         }
 492
 493         // I would really like to avoid having this switch and rather try to
 494         // encode this in the function itself.
 495         static bool noLaTeX = lyxrc.latex_command == "none";
 496         bool disable = false;
 497         switch (action) {
 498 #ifndef NEW_EXPORT
 499         case LFUN_PREVIEW:
 500                 disable = noLaTeX || lyxrc.view_dvi_command == "none";
 501                 break;
 502         case LFUN_PREVIEWPS:
 503                 disable = noLaTeX || lyxrc.view_ps_command == "none";
 504                 break;
 505         case LFUN_RUNLATEX:
 506         case LFUN_RUNDVIPS:
 507                 disable = noLaTeX;
 508                 break;
 509 #endif
 510         case LFUN_MENUPRINT:
 511                 disable = noLaTeX || lyxrc.print_command == "none";
 512                 break;
 513         case LFUN_FAX:
 514                 disable = noLaTeX || lyxrc.fax_command == "none";
 515                 break;
 516         case LFUN_IMPORT:
 517                 if (argument == "latex" || argument == "noweb")
 518                         disable = lyxrc.relyx_command == "none";
 519                 else if (argument == "linuxdoc")
 520                         disable = lyxrc.linuxdoc_to_lyx_command == "none";
 521                 break;
 522 #ifndef NEW_EXPORT
 523         case LFUN_EXPORT:
 524                 if (argument == "latex")
 525                         disable = (! buf->isLatex() && ! buf->isLiterate()) ;
 526                 else if (argument == "linuxdoc")
 527                         disable = ! buf->isLinuxDoc();
 528                 else if (argument == "docbook")
 529                         disable = ! buf->isDocBook();
 530                 else if (argument == "dvi" || argument == "postscript")
 531                         disable = noLaTeX;
 532                 else if (argument == "html")
 533                         disable = (buf->isLinuxDoc()
 534                                    && lyxrc.linuxdoc_to_html_command == "none")
 535                                 || (buf->isDocBook()
 536                                     && lyxrc.docbook_to_html_command == "none")
 537                                 || (! buf->isLinuxDoc() && ! buf->isDocBook()
 538                                     && lyxrc.html_command == "none");
 539                 else if (argument == "custom")
 540                         disable = (! buf->isLatex() && ! buf->isLiterate());
 541                 break;
 542 #endif
 543         case LFUN_UNDO:
 544                 disable = buf->undostack.empty();
 545                 break;
 546         case LFUN_REDO:
 547                 disable = buf->redostack.empty();
 548                 break;
 549         case LFUN_SPELLCHECK:
 550                 disable = lyxrc.isp_command == "none";
 551                 break;
 552         case LFUN_RUNCHKTEX:
 553                 disable = lyxrc.chktex_command == "none";
 554                 break;
 555         case LFUN_BUILDPROG:
 556                 disable = (lyxrc.literate_command == "none"
 557                            || ! buf->isLiterate());
 558                 break;
 559
 560 #ifndef NEW_TABULAR
 561         case LFUN_LAYOUT_TABLE:
 562                 disable = ! owner->view()->text->cursor.par()->table;
 563                 break;
 564 #endif
 565         case LFUN_LAYOUT_TABULAR:
 566                 disable = true;
 567                 if (owner->view()->the_locking_inset) {
 568                         disable = (owner->view()->the_locking_inset->LyxCode() != Inset::TABULAR_CODE) &&
 569                                 !owner->view()->the_locking_inset->GetFirstLockingInsetOfType(Inset::TABULAR_CODE);
 570                 }
 571                 break;
 572
 573         case LFUN_TABULAR_FEATURE:
 574                 disable = true;
 575                 if (owner->view()->the_locking_inset) {
 576                         func_status ret = LyXFunc::Disabled;
 577                         if (owner->view()->the_locking_inset->LyxCode() == Inset::TABULAR_CODE) {
 578                                 ret = static_cast<InsetTabular *>
 579                                         (owner->view()->the_locking_inset)->
 580                                         getStatus(argument);
 581                         } else if (owner->view()->the_locking_inset->GetFirstLockingInsetOfType(Inset::TABULAR_CODE)) {
 582                                 ret = static_cast<InsetTabular *>
 583                                         (owner->view()->the_locking_inset->
 584                                         GetFirstLockingInsetOfType(Inset::TABULAR_CODE))->
 585                                         getStatus(argument);
 586                         }
 587                         flag |= ret;
 588                         disable = false;
 589                 } else {
 590                     static InsetTabular inset(owner->buffer(), 1, 1);
 591                     func_status ret;
 592
 593                     disable = true;
 594                     ret = inset.getStatus(argument);
 595                     if ((ret & LyXFunc::ToggleOn) ||
 596                         (ret & LyXFunc::ToggleOff))
 597                         flag |= LyXFunc::ToggleOff;
 598                 }
 599                 break;
 600
 601         case LFUN_VC_REGISTER:
 602                 disable = buf->lyxvc.inUse();
 603                 break;
 604         case LFUN_VC_CHECKIN:
 605                 disable = !buf->lyxvc.inUse() || buf->isReadonly();
 606                 break;
 607         case LFUN_VC_CHECKOUT:
 608                 disable = !buf->lyxvc.inUse() || !buf->isReadonly();
 609                 break;
 610         case LFUN_VC_REVERT:
 611         case LFUN_VC_UNDO:
 612         case LFUN_VC_HISTORY:
 613                 disable = !buf->lyxvc.inUse();
 614                 break;
 615         case LFUN_REF_BACK:
 616                 disable = owner->view()->NoSavedPositions();
 617                 break;
 618         default:
 619                 break;
 620         }
 621         if (disable)
 622                 flag |= LyXFunc::Disabled;
 623
 624         if (buf) {
 625                 func_status box = LyXFunc::ToggleOff;
 626                 LyXFont font;
 627                 if (owner->view()->the_locking_inset &&
 628                     owner->view()->the_locking_inset->getLyXText(owner->view()))
 629                     font = owner->view()->the_locking_inset->
 630                         getLyXText(owner->view())->real_current_font;
 631                 else
 632                     font = owner->view()->text->real_current_font;
 633                 switch (action) {
 634                 case LFUN_EMPH:
 635                         if (font.emph() == LyXFont::ON)
 636                                 box = LyXFunc::ToggleOn;
 637                         break;
 638                 case LFUN_NOUN:
 639                         if (font.noun() == LyXFont::ON)
 640                                 box = LyXFunc::ToggleOn;
 641                         break;
 642                 case LFUN_BOLD:
 643                         if (font.series() == LyXFont::BOLD_SERIES)
 644                                 box = LyXFunc::ToggleOn;
 645                         break;
 646                 case LFUN_TEX:
 647                         if (font.latex() == LyXFont::ON)
 648                                 box = LyXFunc::ToggleOn;
 649                         break;
 650                 default:
 651                         box = LyXFunc::OK;
 652                         break;
 653                 }
 654                 flag |= box;
 655         }
 656
 657         return flag;
 658 }
 659
 660
 661 string LyXFunc::Dispatch(string const & s)
 662 {
 663         // Split command string into command and argument
 664         string cmd, line = frontStrip(s);
 665         string arg = strip(frontStrip(split(line, cmd, ' ')));
 666
 667         return Dispatch(lyxaction.LookupFunc(cmd.c_str()), arg.c_str());
 668 }
 669
 670
 671 string LyXFunc::Dispatch(int ac,
 672                          char const * do_not_use_this_arg)
 673 {
 674         string argument;
 675         kb_action action;
 676
 677         // we have not done anything wrong yet.
 678         errorstat = false;
 679         dispatch_buffer.erase();
 680
 681         // if action is a pseudo-action, we need the real action
 682         if (lyxaction.isPseudoAction(ac)) {
 683                 string tmparg;
 684                 action = static_cast<kb_action>
 685                         (lyxaction.retrieveActionArg(ac, tmparg));
 686                 if (!tmparg.empty())
 687                         argument = tmparg;
 688         } else {
 689                 action = static_cast<kb_action>(ac);
 690                 if (do_not_use_this_arg)
 691                         argument = do_not_use_this_arg; // except here
 692         }
 693
 694         selection_possible = false;
 695
 696         if (owner->view()->available())
 697                 owner->view()->hideCursor();
 698
 699         // We cannot use this function here
 700         if (getStatus(ac) & Disabled)
 701                 goto exit_with_message;
 702
 703         commandshortcut.erase();
 704
 705         if (lyxrc.display_shortcuts && show_sc) {
 706                 if (action != LFUN_SELFINSERT) {
 707                         // Put name of command and list of shortcuts
 708                         // for it in minibuffer
 709                         string comname = lyxaction.getActionName(action);
 710
 711                         int pseudoaction = action;
 712                         bool argsadded = false;
 713
 714                         if (!argument.empty()) {
 715                                 // If we have the command with argument,
 716                                 // this is better
 717                                 pseudoaction =
 718                                         lyxaction.searchActionArg(action,
 719                                                                   argument.c_str());
 720
 721                                 if (pseudoaction == -1) {
 722                                         pseudoaction = action;
 723                                 } else {
 724                                         comname += " " + argument;
 725                                         argsadded = true;
 726                                 }
 727                         }
 728
 729                         string shortcuts = toplevel_keymap->findbinding(pseudoaction);
 730
 731                         if (!shortcuts.empty()) {
 732                                 comname += ": " + shortcuts;
 733                         } else if (!argsadded) {
 734                                 comname += " " + argument;
 735                         }
 736
 737                         if (!comname.empty()) {
 738                                 comname = strip(comname);
 739                                 commandshortcut = "(" + comname + ')';
 740                                 owner->getMiniBuffer()->Set(commandshortcut);
 741                                 // Here we could even add a small pause,
 742                                 // to annoy the user and make him learn
 743                                 // the shortcuts.
 744                                 // No! That will just annoy, not teach
 745                                 // anything. The user will read the messages
 746                                 // if they are interested. (Asger)
 747                         }
 748                 }
 749         }
 750
 751         // If in math mode pass the control to
 752         // the math inset [asierra060396]
 753         if (owner->view()->available() &&
 754             owner->view()->the_locking_inset) {
 755                 UpdatableInset::RESULT result;
 756                 if ((action > 1) || ((action == LFUN_UNKNOWN_ACTION) &&
 757                                      (keyseq.length >= -1)))
 758                 {
 759                         if ((action==LFUN_UNKNOWN_ACTION) && argument.empty()){
 760                                 argument = keyseq.getiso();
 761                         }
 762                         // Undo/Redo pre 0.13 is a bit tricky for insets.
 763                         if (action == LFUN_UNDO) {
 764                                 int slx, sly;
 765                                 UpdatableInset * inset =
 766                                         owner->view()->the_locking_inset;
 767                                 inset->GetCursorPos(owner->view(), slx, sly);
 768                                 owner->view()->unlockInset(inset);
 769                                 owner->view()->menuUndo();
 770                                 if (owner->view()->text->cursor.par()->
 771                                     IsInset(owner->view()->text->cursor.pos())) {
 772                                         inset = static_cast<UpdatableInset*>(
 773                                                 owner->view()->text->cursor.par()->
 774                                                 GetInset(owner->view()->text->
 775                                                          cursor.pos()));
 776                                 } else {
 777                                         inset = 0;
 778                                 }
 779                                 if (inset)
 780                                         inset->Edit(owner->view(),slx,sly,0);
 781                                 return string();
 782                         } else if (action == LFUN_REDO) {
 783                                 int slx, sly;
 784                                 UpdatableInset * inset = owner->view()->
 785                                         the_locking_inset;
 786                                 inset->GetCursorPos(owner->view(), slx, sly);
 787                                 owner->view()->unlockInset(inset);
 788                                 owner->view()->menuRedo();
 789                                 inset = static_cast<UpdatableInset*>(
 790                                         owner->view()->text->cursor.par()->
 791                                         GetInset(owner->view()->text->
 792                                                  cursor.pos()));
 793                                 if (inset)
 794                                         inset->Edit(owner->view(),slx,sly,0);
 795                                 return string();
 796                         } else if (((result=owner->view()->the_locking_inset->
 797                                    LocalDispatch(owner->view(), action,
 798                                                  argument)) ==
 799                                    UpdatableInset::DISPATCHED) ||
 800                                    (result == UpdatableInset::DISPATCHED_NOUPDATE))
 801                                 return string();
 802                         else {
 803                                 setMessage(N_("Text mode"));
 804                                 switch(action) {
 805                                 case LFUN_UNKNOWN_ACTION:
 806                                 case LFUN_BREAKPARAGRAPH:
 807                                 case LFUN_BREAKLINE:
 808                                         owner->view()->text->CursorRight(owner->view());
 809                                         owner->view()->setState();
 810                                         owner->showState();
 811                                         break;
 812                                 case LFUN_RIGHT:
 813                                         if (!owner->view()->text->cursor.par()->isRightToLeftPar(owner->buffer()->params)) {
 814                                                 owner->view()->text->CursorRight(owner->view());
 815                                                 moveCursorUpdate(false);
 816                                                 owner->showState();
 817                                         }
 818                                         return string();
 819                                 case LFUN_LEFT:
 820                                         if (owner->view()->text->cursor.par()->isRightToLeftPar(owner->buffer()->params)) {
 821                                                 owner->view()->text->CursorRight(owner->view());
 822                                                 moveCursorUpdate(false);
 823                                                 owner->showState();
 824                                         }
 825                                         return string();
 826                                 case LFUN_DOWN:
 827                                         owner->view()->text->CursorDown(owner->view());
 828                                         moveCursorUpdate(false);
 829                                         owner->showState();
 830                                         return string();
 831                                 default:
 832                                         break;
 833                                 }
 834                         }
 835                 }
 836         }
 837
 838         switch(action) {
 839                 // --- Misc -------------------------------------------
 840         case LFUN_WORDFINDFORWARD  :
 841         case LFUN_WORDFINDBACKWARD : {
 842                 static string last_search;
 843                 string searched_string;
 844
 845                 if (!argument.empty()) {
 846                         last_search = argument;
 847                         searched_string = argument;
 848                 } else {
 849                         searched_string = last_search;
 850                 }
 851
 852                 LyXText * ltCur = owner->view()->text ;
 853
 854                 if (!searched_string.empty() &&
 855                     ((action == LFUN_WORDFINDBACKWARD) ?
 856                      ltCur->SearchBackward(owner->view(), searched_string.c_str()) :
 857                      ltCur->SearchForward(owner->view(), searched_string.c_str()))) {
 858
 859                         // ??? What is that ???
 860                         owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
 861
 862                         // ??? Needed ???
 863                         // clear the selection (if there is any)
 864                         owner->view()->toggleSelection();
 865                         owner->view()->text->ClearSelection();
 866
 867                         // Move cursor so that successive C-s 's will not stand in place.
 868                         if( action == LFUN_WORDFINDFORWARD )
 869                                 owner->view()->text->CursorRightOneWord(owner->view());
 870                         owner->view()->text->FinishUndo();
 871                         moveCursorUpdate(false);
 872
 873                         // ??? Needed ???
 874                         // set the new selection
 875                         // SetSelectionOverLenChars(owner->view()->currentBuffer()->text, iLenSelected);
 876                         owner->view()->toggleSelection(false);
 877                 } else
 878                         LyXBell();
 879
 880                 // REMOVED : if (owner->view()->getWorkArea()->focus)
 881                 owner->view()->showCursor();
 882         }
 883         break;
 884
 885         case LFUN_PREFIX:
 886         {
 887                 if (owner->view()->available()) {
 888                         owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
 889                 }
 890                 string buf;
 891                 keyseq.print(buf, true);
 892                 owner->getMiniBuffer()->Set(buf, string(), string(), 1);
 893         }
 894         break;
 895
 896         // --- Misc -------------------------------------------
 897         case LFUN_EXEC_COMMAND:
 898                 owner->getMiniBuffer()->ExecCommand();
 899                 break;
 900
 901         case LFUN_CANCEL:                   // RVDK_PATCH_5
 902                 keyseq.reset();
 903                 meta_fake_bit = 0;
 904                 if(owner->view()->available())
 905                         // cancel any selection
 906                         Dispatch(LFUN_MARK_OFF, 0);
 907                 setMessage(N_("Cancel"));
 908                 break;
 909
 910         case LFUN_META_FAKE:                                 // RVDK_PATCH_5
 911         {
 912                 meta_fake_bit = Mod1Mask;
 913                 string buf;
 914                 keyseq.print(buf, true);
 915                 string res = string("M-") + buf;
 916                 setMessage(buf); // RVDK_PATCH_5
 917         }
 918         break;
 919
 920         case LFUN_READ_ONLY_TOGGLE:
 921                 if (owner->buffer()->lyxvc.inUse()) {
 922                         owner->buffer()->lyxvc.toggleReadOnly();
 923                 } else {
 924                         owner->buffer()->setReadonly(
 925                                 !owner->buffer()->isReadonly());
 926                 }
 927                 break;
 928
 929         case LFUN_CENTER: // this is center and redraw.
 930                 owner->view()->center();
 931                 break;
 932
 933         case LFUN_APPENDIX:
 934                 if (owner->view()->available()) {
 935                         owner->view()->text->toggleAppendix(owner->view());
 936                         owner->view()->update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
 937                 }
 938                 break;
 939
 940                 // --- Menus -----------------------------------------------
 941         case LFUN_MENUNEW:
 942                 MenuNew(false);
 943                 break;
 944
 945         case LFUN_MENUNEWTMPLT:
 946                 MenuNew(true);
 947                 break;
 948
 949         case LFUN_MENUOPEN:
 950                 MenuOpen();
 951                 break;
 952
 953         case LFUN_CLOSEBUFFER:
 954                 CloseBuffer();
 955                 break;
 956
 957         case LFUN_MENUWRITE:
 958                 if (!owner->buffer()->isUnnamed()) {
 959                         owner->getMiniBuffer()->Set(_("Saving document"),
 960                                                     MakeDisplayPath(owner->buffer()->fileName()),
 961                                                     "...");
 962                         MenuWrite(owner->buffer());
 963                         //owner->getMiniBuffer()-> {
 964                         //      Set(_("Document saved as"),
 965                         //          MakeDisplayPath(owner->buffer()->fileName()));
 966                         //} else {
 967                         //owner->getMiniBuffer()->Set(_("Save failed!"));
 968                         //}
 969                 } else {
 970                         MenuWriteAs(owner->buffer());
 971                 }
 972                 break;
 973
 974         case LFUN_MENUWRITEAS:
 975                 MenuWriteAs(owner->buffer());
 976                 break;
 977
 978         case LFUN_MENURELOAD:
 979                 reloadBuffer();
 980                 break;
 981
 982 #ifdef NEW_EXPORT
 983         case LFUN_UPDATE:
 984                 Exporter::Export(owner->buffer(), argument, true);
 985                 break;
 986
 987         case LFUN_PREVIEW:
 988                 Exporter::Preview(owner->buffer(), argument);
 989                 break;
 990 #else
 991         case LFUN_PREVIEW:
 992                 PreviewDVI(owner->buffer());
 993                 break;
 994
 995         case LFUN_PREVIEWPS:
 996                 PreviewPostscript(owner->buffer());
 997                 break;
 998
 999         case LFUN_RUNLATEX:
1000                 MenuRunLaTeX(owner->buffer());
1001                 break;
1002
1003         case LFUN_RUNDVIPS:
1004                 CreatePostscript(owner->buffer(), false);
1005                 break;
1006 #endif
1007
1008         case LFUN_BUILDPROG:
1009                 MenuBuildProg(owner->buffer());
1010                 break;
1011
1012         case LFUN_RUNCHKTEX:
1013                 MenuRunChktex(owner->buffer());
1014                 break;
1015
1016         case LFUN_MENUPRINT:
1017                 owner->getDialogs()->showPrint();
1018                 break;
1019
1020         case LFUN_FAX:
1021                 MenuFax(owner->buffer());
1022                 break;
1023
1024         case LFUN_EXPORT:
1025 #ifdef NEW_EXPORT
1026                 Exporter::Export(owner->buffer(), argument, false);
1027 #else
1028                 MenuExport(owner->buffer(), argument);
1029 #endif
1030                 break;
1031
1032         case LFUN_IMPORT:
1033                 doImport(argument);
1034                 break;
1035
1036         case LFUN_QUIT:
1037                 QuitLyX();
1038                 break;
1039
1040         case LFUN_TOCVIEW:
1041         case LFUN_LOFVIEW:
1042         case LFUN_LOTVIEW:
1043         case LFUN_LOAVIEW:
1044         {
1045                 InsetCommandParams p;
1046
1047                 if( action == LFUN_TOCVIEW )
1048                         p.setCmdName( "tableofcontents" );
1049                 else if( action == LFUN_LOAVIEW )
1050                         p.setCmdName( "listofalgorithms" );
1051                 else if( action == LFUN_LOFVIEW )
1052                         p.setCmdName( "listoffigures" );
1053                 else
1054                         p.setCmdName( "listoftables" );
1055
1056                 owner->getDialogs()->createTOC( p.getAsString() );
1057                 break;
1058         }
1059
1060         case LFUN_TOC_INSERT:
1061         case LFUN_LOA_INSERT:
1062         case LFUN_LOF_INSERT:
1063         case LFUN_LOT_INSERT:
1064         {
1065                 InsetCommandParams p;
1066
1067                 if( action == LFUN_TOC_INSERT )
1068                         p.setCmdName( "tableofcontents" );
1069                 else if( action == LFUN_LOA_INSERT )
1070                         p.setCmdName( "listofalgorithms" );
1071                 else if( action == LFUN_LOF_INSERT )
1072                         p.setCmdName( "listoffigures" );
1073                 else
1074                         p.setCmdName( "listoftables" );
1075
1076                 Inset * inset = new InsetTOC( p );
1077                 if( !owner->view()->insertInset( inset, "Standard", true ) )
1078                         delete inset;
1079                 break;
1080         }
1081
1082         case LFUN_DIALOG_TABULAR_INSERT:
1083 #ifndef NEW_TABULAR
1084                 Table();
1085 #else
1086                 owner->getDialogs()->showTabularCreate();
1087 #endif
1088                 break;
1089
1090         case LFUN_TABULAR_FEATURE:
1091         case LFUN_SCROLL_INSET:
1092                 // this is not handled here as this funktion is only aktive
1093                 // if we have a locking_inset and that one is (or contains)
1094                 // a tabular-inset
1095                 break;
1096
1097         case LFUN_FIGURE:
1098                 Figure();
1099                 break;
1100
1101         case LFUN_INSET_GRAPHICS:
1102         {
1103                 Inset * new_inset = new InsetGraphics;
1104                 if (!owner->view()->insertInset(new_inset)) {
1105                         delete new_inset;
1106                 } else {
1107                         // this is need because you don't use a inset->Edit()
1108                         owner->view()->updateInset(new_inset, true);
1109                         new_inset->Edit(owner->view(), 0, 0, 0);
1110                 }
1111                 break;
1112         }
1113
1114         case LFUN_AUTOSAVE:
1115                 AutoSave(owner->view());
1116                 break;
1117
1118         case LFUN_UNDO:
1119                 owner->view()->menuUndo();
1120                 break;
1121
1122         case LFUN_REDO:
1123                 owner->view()->menuRedo();
1124                 break;
1125
1126         case LFUN_MENUSEARCH:
1127         {
1128                 // Ok this is one _very_ bad solution, but I think that some
1129                 // of this will be rewritten as part of GUI indep anyway.
1130                 // Lgb
1131                 static LyXFindReplace FR_;
1132                 FR_.StartSearch(owner->view());
1133         }
1134         break;
1135
1136         case LFUN_PASTE:
1137                 owner->view()->paste();
1138                 owner->view()->setState();
1139                 break;
1140
1141         case LFUN_PASTESELECTION:
1142         {
1143                 bool asPara = false;
1144                 if (argument == "paragraph") asPara = true;
1145                 owner->view()->pasteClipboard(asPara);
1146         }
1147         break;
1148
1149         case LFUN_CUT:
1150                 owner->view()->cut();
1151                 break;
1152
1153         case LFUN_COPY:
1154                 owner->view()->copy();
1155                 break;
1156
1157         case LFUN_LAYOUT_COPY:
1158                 owner->view()->copyEnvironment();
1159                 break;
1160
1161         case LFUN_LAYOUT_PASTE:
1162                 owner->view()->pasteEnvironment();
1163                 owner->view()->setState();
1164                 break;
1165
1166         case LFUN_GOTOERROR:
1167                 owner->view()->gotoError();
1168                 break;
1169
1170         case LFUN_REMOVEERRORS:
1171                 if (owner->view()->removeAutoInsets()) {
1172                         owner->view()->redraw();
1173                         owner->view()->fitCursor();
1174                         //owner->view()->updateScrollbar();
1175                 }
1176                 break;
1177
1178         case LFUN_GOTONOTE:
1179                 owner->view()->gotoNote();
1180                 break;
1181
1182 #ifndef NEW_INSETS
1183         case LFUN_OPENSTUFF:
1184                 owner->view()->openStuff();
1185                 break;
1186 #endif
1187
1188         case LFUN_HYPHENATION:
1189                 owner->view()->hyphenationPoint();
1190                 break;
1191
1192         case LFUN_LDOTS:
1193                 owner->view()->ldots();
1194                 break;
1195
1196         case LFUN_END_OF_SENTENCE:
1197                 owner->view()->endOfSentenceDot();
1198                 break;
1199
1200         case LFUN_MENU_SEPARATOR:
1201                 owner->view()->menuSeparator();
1202                 break;
1203
1204         case LFUN_HFILL:
1205                 owner->view()->hfill();
1206                 break;
1207
1208         case LFUN_DEPTH:
1209                 changeDepth(owner->view(), 0);
1210                 break;
1211
1212         case LFUN_DEPTH_MIN:
1213                 changeDepth(owner->view(), -1);
1214                 break;
1215
1216         case LFUN_DEPTH_PLUS:
1217                 changeDepth(owner->view(), 1);
1218                 break;
1219
1220         case LFUN_FREE:
1221                 Free(owner->view());
1222                 owner->view()->setState();
1223                 owner->showState();
1224                 break;
1225
1226         case LFUN_TEX:
1227                 Tex(owner->view());
1228                 owner->view()->setState();
1229                 owner->showState();
1230                 break;
1231 #ifndef NEW_INSETS
1232         case LFUN_MELT:
1233                 Melt(owner->view());
1234                 break;
1235 #endif
1236         case LFUN_RECONFIGURE:
1237                 Reconfigure(owner->view());
1238                 break;
1239 #ifndef NEW_INSETS
1240         case LFUN_FOOTMELT:
1241                 if (owner->view()->available()
1242                     && !owner->view()->text->selection
1243                     && owner->view()->text->cursor.par()->footnoteflag
1244                     != LyXParagraph::NO_FOOTNOTE)
1245                         { // only melt footnotes with FOOTMELT, not margins etc
1246                                 if(owner->view()->text->cursor.par()->footnotekind == LyXParagraph::FOOTNOTE)
1247                                         Melt(owner->view());
1248                         }
1249                 else
1250                         Foot(owner->view());
1251                 owner->view()->setState();
1252                 break;
1253
1254         case LFUN_MARGINMELT:
1255                 if (owner->view()->available()
1256                     && !owner->view()->text->selection
1257                     && owner->view()->text->cursor.par()->footnoteflag
1258                     != LyXParagraph::NO_FOOTNOTE) {
1259                         // only melt margins
1260                         if(owner->view()->text->cursor.par()->footnotekind == LyXParagraph::MARGIN)
1261                                 Melt(owner->view());
1262                 } else
1263                         Margin(owner->view());
1264                 owner->view()->setState();
1265                 break;
1266 #endif
1267         case LFUN_HELP_COPYRIGHT:
1268                 owner->getDialogs()->showCopyright();
1269                 break;
1270
1271         case LFUN_HELP_CREDITS:
1272                 owner->getDialogs()->showCredits();
1273                 break;
1274
1275         case LFUN_HELP_OPEN: {
1276                 string arg = argument;
1277                 if (arg.empty()) {
1278                         setErrorMessage(N_("Missing argument"));
1279                         break;
1280                 }
1281                 ProhibitInput(owner->view());
1282                 string fname = i18nLibFileSearch("doc", arg, "lyx");
1283                 if (fname.empty()) {
1284                         lyxerr << "LyX: unable to find documentation file `"
1285                                << arg << "'. Bad installation?" << endl;
1286                         AllowInput(owner->view());
1287                         break;
1288                 }
1289                 owner->getMiniBuffer()->Set(_("Opening help file"),
1290                                             MakeDisplayPath(fname),"...");
1291                 owner->view()->buffer(bufferlist.loadLyXFile(fname,false));
1292                 AllowInput(owner->view());
1293                 break;
1294         }
1295
1296         case LFUN_HELP_VERSION:
1297                 ProhibitInput(owner->view());
1298                 fl_show_message((string(_("LyX Version ")) + LYX_VERSION
1299                                  + _(" of ") + LYX_RELEASE).c_str(),
1300                                 (_("Library directory: ")
1301                                  + MakeDisplayPath(system_lyxdir)).c_str(),
1302                                 (_("User directory: ")
1303                                  + MakeDisplayPath(user_lyxdir)).c_str());
1304                 AllowInput(owner->view());
1305                 break;
1306
1307                 // --- version control -------------------------------
1308         case LFUN_VC_REGISTER:
1309         {
1310                 if (!owner->buffer()->lyxvc.inUse())
1311                         owner->buffer()->lyxvc.registrer();
1312         }
1313         break;
1314
1315         case LFUN_VC_CHECKIN:
1316         {
1317                 if (owner->buffer()->lyxvc.inUse()
1318                     && !owner->buffer()->isReadonly())
1319                         owner->buffer()->lyxvc.checkIn();
1320         }
1321         break;
1322
1323         case LFUN_VC_CHECKOUT:
1324         {
1325                 if (owner->buffer()->lyxvc.inUse()
1326                     && owner->buffer()->isReadonly())
1327                         owner->buffer()->lyxvc.checkOut();
1328         }
1329         break;
1330
1331         case LFUN_VC_REVERT:
1332         {
1333                 owner->buffer()->lyxvc.revert();
1334         }
1335         break;
1336
1337         case LFUN_VC_UNDO:
1338         {
1339                 owner->buffer()->lyxvc.undoLast();
1340         }
1341         break;
1342
1343         case LFUN_VC_HISTORY:
1344         {
1345                 owner->buffer()->lyxvc.showLog();
1346                 break;
1347         }
1348
1349         // --- buffers ----------------------------------------
1350
1351         case LFUN_SWITCHBUFFER:
1352                 owner->view()->buffer(bufferlist.getBuffer(argument));
1353                 break;
1354
1355
1356         case LFUN_FILE_INSERT:
1357         {
1358                 MenuInsertLyXFile(argument);
1359         }
1360         break;
1361
1362         case LFUN_FILE_INSERT_ASCII:
1363         {
1364                 bool asPara = (argument == "paragraph");
1365                 InsertAsciiFile(owner->view(), string(), asPara);
1366         }
1367         break;
1368
1369         case LFUN_FILE_NEW:
1370         {
1371                 // servercmd: argument must be <file>:<template>
1372                 Buffer * tmpbuf = NewLyxFile(argument);
1373                 if (tmpbuf)
1374                         owner->view()->buffer(tmpbuf);
1375         }
1376         break;
1377
1378         case LFUN_FILE_OPEN:
1379                 owner->view()->buffer(bufferlist.loadLyXFile(argument));
1380                 break;
1381
1382         case LFUN_LATEX_LOG:
1383                 ShowLatexLog();
1384                 break;
1385
1386         case LFUN_LAYOUTNO:
1387         {
1388                 lyxerr.debug() << "LFUN_LAYOUTNO: (arg) " << argument << endl;
1389                 int sel = strToInt(argument);
1390                 lyxerr.debug() << "LFUN_LAYOUTNO: (sel) "<< sel << endl;
1391
1392                 // Should this give a setMessage instead?
1393                 if (sel == 0)
1394                         return string(); // illegal argument
1395
1396                 --sel; // sel 1..., but layout 0...
1397
1398                 // Pretend we got the name instead.
1399                 Dispatch(int(LFUN_LAYOUT),
1400                          textclasslist.NameOfLayout(owner->view()
1401                                                     ->buffer()->params.textclass,
1402                                                     sel).c_str());
1403                 return string();
1404         }
1405
1406         case LFUN_LAYOUT:
1407         {
1408                 lyxerr.debug() << "LFUN_LAYOUT: (arg) "
1409                                << argument << endl;
1410
1411                 // Derive layout number from given argument (string)
1412                 // and current buffer's textclass (number). */
1413                 LyXTextClassList::ClassList::size_type tclass =
1414                         owner->view()->buffer()->params.textclass;
1415                 pair <bool, LyXTextClass::size_type> layout =
1416                         textclasslist.NumberOfLayout(tclass, argument);
1417
1418                 // If the entry is obsolete, use the new one instead.
1419                 if (layout.first) {
1420                         string obs = textclasslist.Style(tclass,layout.second)
1421                               .obsoleted_by();
1422                         if (!obs.empty())
1423                                 layout =
1424                                   textclasslist.NumberOfLayout(tclass, obs);
1425                 }
1426
1427                 // see if we found the layout number:
1428                 if (!layout.first) {
1429                         setErrorMessage(string(N_("Layout ")) + argument +
1430                                         N_(" not known"));
1431                         break;
1432                 }
1433
1434                 if (current_layout != layout.second) {
1435                         owner->view()->hideCursor();
1436                         current_layout = layout.second;
1437                         owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
1438                         owner->view()->text->
1439                                 SetLayout(owner->view(), layout.second);
1440                         owner->setLayout(layout.second);
1441                         owner->view()->update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
1442                         owner->view()->setState();
1443                 }
1444         }
1445         break;
1446
1447         case LFUN_LAYOUT_DOCUMENT:
1448 #ifdef USE_OLD_DOCUMENT_LAYOUT
1449                 MenuLayoutDocument();
1450 #else
1451                 owner->getDialogs()->showLayoutDocument();
1452 #endif
1453                 break;
1454
1455         case LFUN_LAYOUT_PARAGRAPH:
1456                 MenuLayoutParagraph();
1457                 break;
1458
1459         case LFUN_LAYOUT_CHARACTER:
1460                 MenuLayoutCharacter();
1461                 break;
1462
1463         case LFUN_LAYOUT_TABLE:
1464         {
1465                 int flag = 0;
1466                 if (argument == "true") flag = 1;
1467                 MenuLayoutTable(flag);
1468         }
1469         break;
1470
1471         case LFUN_LAYOUT_TABULAR:
1472             if (owner->view()->the_locking_inset) {
1473                 if (owner->view()->the_locking_inset->LyxCode()==Inset::TABULAR_CODE) {
1474                     InsetTabular * inset = static_cast<InsetTabular *>
1475                         (owner->view()->the_locking_inset);
1476                     inset->OpenLayoutDialog(owner->view());
1477                 } else if (owner->view()->the_locking_inset->
1478                            GetFirstLockingInsetOfType(Inset::TABULAR_CODE)!=0) {
1479                     InsetTabular * inset = static_cast<InsetTabular *>(
1480                         owner->view()->the_locking_inset->GetFirstLockingInsetOfType(Inset::TABULAR_CODE));
1481                     inset->OpenLayoutDialog(owner->view());
1482                 }
1483             }
1484             break;
1485
1486         case LFUN_LAYOUT_PAPER:
1487 #ifdef USE_OLD_DOCUMENT_LAYOUT
1488                 MenuLayoutPaper();
1489 #endif
1490                 break;
1491
1492         case LFUN_LAYOUT_QUOTES:
1493 #ifdef USE_OLD_DOCUMENT_LAYOUT
1494                 MenuLayoutQuotes();
1495 #endif
1496                 break;
1497
1498         case LFUN_LAYOUT_PREAMBLE:
1499                 MenuLayoutPreamble();
1500                 break;
1501
1502         case LFUN_LAYOUT_SAVE_DEFAULT:
1503                 MenuLayoutSave();
1504                 break;
1505
1506         case LFUN_DROP_LAYOUTS_CHOICE:
1507                 owner->getToolbar()->openLayoutList();
1508                 break;
1509
1510         case LFUN_LANGUAGE:
1511                 Lang(owner->view(), argument);
1512                 owner->view()->setState();
1513                 owner->showState();
1514                 break;
1515
1516         case LFUN_EMPH:
1517                 Emph(owner->view());
1518                 owner->showState();
1519                 break;
1520
1521         case LFUN_BOLD:
1522                 Bold(owner->view());
1523                 owner->showState();
1524                 break;
1525
1526         case LFUN_NOUN:
1527                 Noun(owner->view());
1528                 owner->showState();
1529                 break;
1530
1531         case LFUN_CODE:
1532                 Code(owner->view());
1533                 owner->showState();
1534                 break;
1535
1536         case LFUN_SANS:
1537                 Sans(owner->view());
1538                 owner->showState();
1539                 break;
1540
1541         case LFUN_ROMAN:
1542                 Roman(owner->view());
1543                 owner->showState();
1544                 break;
1545
1546         case LFUN_DEFAULT:
1547                 StyleReset(owner->view());
1548                 owner->showState();
1549                 break;
1550
1551         case LFUN_UNDERLINE:
1552                 Underline(owner->view());
1553                 owner->showState();
1554                 break;
1555
1556         case LFUN_FONT_SIZE:
1557                 FontSize(owner->view(), argument);
1558                 owner->showState();
1559                 break;
1560
1561         case LFUN_FONT_STATE:
1562                 setMessage(CurrentState(owner->view()));
1563                 break;
1564
1565         case LFUN_UPCASE_WORD:
1566                 owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
1567                 owner->view()->text->ChangeWordCase(owner->view(),
1568                                                     LyXText::text_uppercase);
1569                 owner->view()->update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
1570                 break;
1571
1572         case LFUN_LOWCASE_WORD:
1573                 owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
1574                 owner->view()->text->ChangeWordCase(owner->view(),
1575                                                     LyXText::text_lowercase);
1576                 owner->view()->update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
1577                 break;
1578
1579         case LFUN_CAPITALIZE_WORD:
1580                 owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
1581                 owner->view()->text->ChangeWordCase(owner->view(),
1582                                                     LyXText::text_capitalization);
1583                 owner->view()->update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
1584                 break;
1585
1586         case LFUN_INSERT_LABEL:
1587                 MenuInsertLabel(argument.c_str());
1588                 break;
1589
1590         case LFUN_REF_INSERT:
1591                 if (argument.empty()) {
1592                         InsetCommandParams p("ref");
1593                 owner->getDialogs()->createRef(p.getAsString());
1594                 } else {
1595                         InsetCommandParams p;
1596                         p.setFromString(argument);
1597
1598                         InsetRef * inset = new InsetRef(p);
1599                         if (!owner->view()->insertInset(inset))
1600                                 delete inset;
1601                         else
1602                                 owner->view()->updateInset(inset, true);
1603                 }
1604                 break;
1605
1606         case LFUN_REF_BACK:
1607         {
1608                 owner->view()->restorePosition();
1609         }
1610         break;
1611
1612         case LFUN_REF_GOTO:
1613         {
1614                 string label(argument);
1615                 if (label.empty()) {
1616                         InsetRef * inset =
1617                                 static_cast<InsetRef*>(getInsetByCode(Inset::REF_CODE));
1618                         if (inset)
1619                                 label = inset->getContents();
1620                 }
1621
1622                 if (!label.empty()) {
1623                         owner->view()->savePosition();
1624                         if (!owner->view()->gotoLabel(label))
1625                                 WriteAlert(_("Error"),
1626                                            _("Couldn't find this label"),
1627                                            _("in current document."));
1628                 }
1629         }
1630         break;
1631
1632         case LFUN_MENU_OPEN_BY_NAME:
1633 #ifdef NEW_MENUBAR
1634                 owner->getMenubar()->openByName(argument);
1635 #else
1636                 owner->getMenus()->openByName(argument);
1637 #endif
1638                 break; // RVDK_PATCH_5
1639
1640         case LFUN_SPELLCHECK:
1641                 if (lyxrc.isp_command != "none")
1642                         ShowSpellChecker(owner->view());
1643                 break; // RVDK_PATCH_5
1644
1645                 // --- Cursor Movements -----------------------------
1646         case LFUN_RIGHT:
1647         {
1648                 LyXText * tmptext = owner->view()->text;
1649                 bool is_rtl = tmptext->cursor.par()->isRightToLeftPar(owner->buffer()->params);
1650                 if(!tmptext->mark_set)
1651                         owner->view()->beforeChange();
1652                 owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
1653                 if (is_rtl)
1654                         tmptext->CursorLeft(owner->view(), false);
1655                 if (tmptext->cursor.pos() < tmptext->cursor.par()->Last()
1656                     && tmptext->cursor.par()->GetChar(tmptext->cursor.pos())
1657                     == LyXParagraph::META_INSET
1658                     && tmptext->cursor.par()->GetInset(tmptext->cursor.pos())
1659                     && tmptext->cursor.par()->GetInset(tmptext->cursor.pos())->Editable() == Inset::HIGHLY_EDITABLE){
1660                         Inset * tmpinset = tmptext->cursor.par()->GetInset(tmptext->cursor.pos());
1661                         setMessage(tmpinset->EditMessage());
1662                         tmpinset->Edit(owner->view(), 0, 0, 0);
1663                         break;
1664                 }
1665                 if (!is_rtl)
1666                         tmptext->CursorRight(owner->view(), false);
1667                 owner->view()->text->FinishUndo();
1668                 moveCursorUpdate(false);
1669                 owner->showState();
1670         }
1671         break;
1672
1673         case LFUN_LEFT:
1674         {
1675                 // This is soooo ugly. Isn`t it possible to make
1676                 // it simpler? (Lgb)
1677                 LyXText * txt = owner->view()->text;
1678                 bool is_rtl = txt->cursor.par()->isRightToLeftPar(owner->buffer()->params);
1679                 if(!txt->mark_set) owner->view()->beforeChange();
1680                 owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
1681                 if (!is_rtl)
1682                         txt->CursorLeft(owner->view(), false);
1683                 if (txt->cursor.pos() < txt->cursor.par()->Last()
1684                     && txt->cursor.par()->GetChar(txt->cursor.pos())
1685                     == LyXParagraph::META_INSET
1686                     && txt->cursor.par()->GetInset(txt->cursor.pos())
1687                     && txt->cursor.par()->GetInset(txt->cursor.pos())->Editable() == Inset::HIGHLY_EDITABLE) {
1688                         Inset * tmpinset = txt->cursor.par()->GetInset(txt->cursor.pos());
1689                         setMessage(tmpinset->EditMessage());
1690                         LyXFont font = txt->GetFont(owner->view()->buffer(),
1691                                                     txt->cursor.par(),
1692                                                     txt->cursor.pos());
1693                         tmpinset->Edit(owner->view(),
1694                                        tmpinset->x() +
1695                                        tmpinset->width(owner->view(),font),
1696                                        tmpinset->descent(owner->view(),font),
1697                                        0);
1698                         break;
1699                 }
1700                 if  (is_rtl)
1701                         txt->CursorRight(owner->view(), false);
1702
1703                 owner->view()->text->FinishUndo();
1704                 moveCursorUpdate(false);
1705                 owner->showState();
1706         }
1707         break;
1708
1709         case LFUN_UP:
1710                 if(!owner->view()->text->mark_set) owner->view()->beforeChange();
1711                 owner->view()->update(BufferView::UPDATE);
1712                 owner->view()->text->CursorUp(owner->view());
1713                 owner->view()->text->FinishUndo();
1714                 moveCursorUpdate(false);
1715                 owner->showState();
1716                 break;
1717
1718         case LFUN_DOWN:
1719                 if(!owner->view()->text->mark_set)
1720                         owner->view()->beforeChange();
1721                 owner->view()->update(BufferView::UPDATE);
1722                 owner->view()->text->CursorDown(owner->view());
1723                 owner->view()->text->FinishUndo();
1724                 moveCursorUpdate(false);
1725                 owner->showState();
1726                 break;
1727
1728         case LFUN_UP_PARAGRAPH:
1729                 if(!owner->view()->text->mark_set)
1730                         owner->view()->beforeChange();
1731                 owner->view()->update(BufferView::UPDATE);
1732                 owner->view()->text->CursorUpParagraph(owner->view());
1733                 owner->view()->text->FinishUndo();
1734                 moveCursorUpdate(false);
1735                 owner->showState();
1736                 break;
1737
1738         case LFUN_DOWN_PARAGRAPH:
1739                 if(!owner->view()->text->mark_set)
1740                         owner->view()->beforeChange();
1741                 owner->view()->update(BufferView::UPDATE);
1742                 owner->view()->text->CursorDownParagraph(owner->view());
1743                 owner->view()->text->FinishUndo();
1744                 moveCursorUpdate(false);
1745                 owner->showState();
1746                 break;
1747
1748         case LFUN_PRIOR:
1749                 if(!owner->view()->text->mark_set)
1750                         owner->view()->beforeChange();
1751                 owner->view()->update(BufferView::UPDATE);
1752                 owner->view()->cursorPrevious();
1753                 owner->view()->text->FinishUndo();
1754                 moveCursorUpdate(false);
1755                 owner->showState();
1756                 break;
1757
1758         case LFUN_NEXT:
1759                 if(!owner->view()->text->mark_set)
1760                         owner->view()->beforeChange();
1761                 owner->view()->update(BufferView::UPDATE);
1762                 owner->view()->cursorNext();
1763                 owner->view()->text->FinishUndo();
1764                 moveCursorUpdate(false);
1765                 owner->showState();
1766                 break;
1767
1768         case LFUN_HOME:
1769                 if(!owner->view()->text->mark_set)
1770                         owner->view()->beforeChange();
1771                 owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
1772                 owner->view()->text->CursorHome(owner->view());
1773                 owner->view()->text->FinishUndo();
1774                 moveCursorUpdate(false);
1775                 owner->showState();
1776                 break;
1777
1778         case LFUN_END:
1779                 if(!owner->view()->text->mark_set)
1780                         owner->view()->beforeChange();
1781                 owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
1782                 owner->view()->text->CursorEnd(owner->view());
1783                 owner->view()->text->FinishUndo();
1784                 moveCursorUpdate(false);
1785                 owner->showState();
1786                 break;
1787
1788         case LFUN_SHIFT_TAB:
1789         case LFUN_TAB:
1790                 if(!owner->view()->text->mark_set)
1791                         owner->view()->beforeChange();
1792                 owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
1793                 owner->view()->text->CursorTab(owner->view());
1794                 owner->view()->text->FinishUndo();
1795                 moveCursorUpdate(false);
1796                 owner->showState();
1797                 break;
1798
1799         case LFUN_WORDRIGHT:
1800                 if(!owner->view()->text->mark_set)
1801                         owner->view()->beforeChange();
1802                 owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
1803                 if (owner->view()->text->cursor.par()->isRightToLeftPar(owner->buffer()->params))
1804                         owner->view()->text->CursorLeftOneWord(owner->view());
1805                 else
1806                         owner->view()->text->CursorRightOneWord(owner->view());
1807                 owner->view()->text->FinishUndo();
1808                 moveCursorUpdate(false);
1809                 owner->showState();
1810                 break;
1811
1812         case LFUN_WORDLEFT:
1813                 if(!owner->view()->text->mark_set)
1814                         owner->view()->beforeChange();
1815                 owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
1816                 if (owner->view()->text->cursor.par()->isRightToLeftPar(owner->buffer()->params))
1817                         owner->view()->text->CursorRightOneWord(owner->view());
1818                 else
1819                         owner->view()->text->CursorLeftOneWord(owner->view());
1820                 owner->view()->text->FinishUndo();
1821                 moveCursorUpdate(false);
1822                 owner->showState();
1823                 break;
1824
1825         case LFUN_BEGINNINGBUF:
1826                 if(!owner->view()->text->mark_set)
1827                         owner->view()->beforeChange();
1828                 owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
1829                 owner->view()->text->CursorTop(owner->view());
1830                 owner->view()->text->FinishUndo();
1831                 moveCursorUpdate(false);
1832                 owner->showState();
1833                 break;
1834
1835         case LFUN_ENDBUF:
1836                 if(!owner->view()->text->mark_set)
1837                         owner->view()->beforeChange();
1838                 owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
1839                 owner->view()->text->CursorBottom(owner->view());
1840                 owner->view()->text->FinishUndo();
1841                 moveCursorUpdate(false);
1842                 owner->showState();
1843                 break;
1844
1845
1846                 /* cursor selection ---------------------------- */
1847         case LFUN_RIGHTSEL:
1848                 owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
1849                 if (owner->view()->text->cursor.par()->isRightToLeftPar(owner->buffer()->params))
1850                         owner->view()->text->CursorLeft(owner->view());
1851                 else
1852                         owner->view()->text->CursorRight(owner->view());
1853                 owner->view()->text->FinishUndo();
1854                 moveCursorUpdate(true);
1855                 owner->showState();
1856                 break;
1857
1858         case LFUN_LEFTSEL:
1859                 owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
1860                 if (owner->view()->text->cursor.par()->isRightToLeftPar(owner->buffer()->params))
1861                         owner->view()->text->CursorRight(owner->view());
1862                 else
1863                         owner->view()->text->CursorLeft(owner->view());
1864                 owner->view()->text->FinishUndo();
1865                 moveCursorUpdate(true);
1866                 owner->showState();
1867                 break;
1868
1869         case LFUN_UPSEL:
1870                 owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
1871                 owner->view()->text->CursorUp(owner->view());
1872                 owner->view()->text->FinishUndo();
1873                 moveCursorUpdate(true);
1874                 owner->showState();
1875                 break;
1876
1877         case LFUN_DOWNSEL:
1878                 owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
1879                 owner->view()->text->CursorDown(owner->view());
1880                 owner->view()->text->FinishUndo();
1881                 moveCursorUpdate(true);
1882                 owner->showState();
1883                 break;
1884
1885         case LFUN_UP_PARAGRAPHSEL:
1886                 owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
1887                 owner->view()->text->CursorUpParagraph(owner->view());
1888                 owner->view()->text->FinishUndo();
1889                 moveCursorUpdate(true);
1890                 owner->showState();
1891                 break;
1892
1893         case LFUN_DOWN_PARAGRAPHSEL:
1894                 owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
1895                 owner->view()->text->CursorDownParagraph(owner->view());
1896                 owner->view()->text->FinishUndo();
1897                 moveCursorUpdate(true);
1898                 owner->showState();
1899                 break;
1900
1901         case LFUN_PRIORSEL:
1902                 owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
1903                 owner->view()->cursorPrevious();
1904                 owner->view()->text->FinishUndo();
1905                 moveCursorUpdate(true);
1906                 owner->showState();
1907                 break;
1908
1909         case LFUN_NEXTSEL:
1910                 owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
1911                 owner->view()->cursorNext();
1912                 owner->view()->text->FinishUndo();
1913                 moveCursorUpdate(true);
1914                 owner->showState();
1915                 break;
1916
1917         case LFUN_HOMESEL:
1918                 owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
1919                 owner->view()->text->CursorHome(owner->view());
1920                 owner->view()->text->FinishUndo();
1921                 moveCursorUpdate(true);
1922                 owner->showState();
1923                 break;
1924
1925         case LFUN_ENDSEL:
1926                 owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
1927                 owner->view()->text->CursorEnd(owner->view());
1928                 owner->view()->text->FinishUndo();
1929                 moveCursorUpdate(true);
1930                 owner->showState();
1931                 break;
1932
1933         case LFUN_WORDRIGHTSEL:
1934                 owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
1935                 if (owner->view()->text->cursor.par()->isRightToLeftPar(owner->buffer()->params))
1936                         owner->view()->text->CursorLeftOneWord(owner->view());
1937                 else
1938                         owner->view()->text->CursorRightOneWord(owner->view());
1939                 owner->view()->text->FinishUndo();
1940                 moveCursorUpdate(true);
1941                 owner->showState();
1942                 break;
1943
1944         case LFUN_WORDLEFTSEL:
1945                 owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
1946                 if (owner->view()->text->cursor.par()->isRightToLeftPar(owner->buffer()->params))
1947                         owner->view()->text->CursorRightOneWord(owner->view());
1948                 else
1949                         owner->view()->text->CursorLeftOneWord(owner->view());
1950                 owner->view()->text->FinishUndo();
1951                 moveCursorUpdate(true);
1952                 owner->showState();
1953                 break;
1954
1955         case LFUN_BEGINNINGBUFSEL:
1956                 owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
1957                 owner->view()->text->CursorTop(owner->view());
1958                 owner->view()->text->FinishUndo();
1959                 moveCursorUpdate(true);
1960                 owner->showState();
1961                 break;
1962
1963         case LFUN_ENDBUFSEL:
1964                 owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
1965                 owner->view()->text->CursorBottom(owner->view());
1966                 owner->view()->text->FinishUndo();
1967                 moveCursorUpdate(true);
1968                 owner->showState();
1969                 break;
1970
1971                 // --- text changing commands ------------------------
1972         case LFUN_BREAKLINE:
1973                 owner->view()->beforeChange();
1974                 owner->view()->text->InsertChar(owner->view(), LyXParagraph::META_NEWLINE);
1975                 owner->view()->update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
1976                 moveCursorUpdate(false);
1977                 break;
1978
1979         case LFUN_PROTECTEDSPACE:
1980         {
1981                 LyXLayout const & style =
1982                         textclasslist.Style(owner->view()->buffer()->params.textclass,
1983                                             owner->view()->text->cursor.par()->GetLayout());
1984
1985                 if (style.free_spacing) {
1986                         owner->view()->text->InsertChar(owner->view(), ' ');
1987                         owner->view()->update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
1988                 } else {
1989                         owner->view()->protectedBlank();
1990                 }
1991                 moveCursorUpdate(false);
1992         }
1993         break;
1994
1995         case LFUN_SETMARK:
1996                 if(owner->view()->text->mark_set) {
1997                         owner->view()->beforeChange();
1998                         owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
1999                         setMessage(N_("Mark removed"));
2000                 } else {
2001                         owner->view()->beforeChange();
2002                         owner->view()->text->mark_set = 1;
2003                         owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
2004                         setMessage(N_("Mark set"));
2005                 }
2006                 owner->view()->text->sel_cursor =
2007                         owner->view()->text->cursor;
2008                 break;
2009
2010         case LFUN_DELETE:
2011                 if (!owner->view()->text->selection) {
2012                         owner->view()->text->Delete(owner->view());
2013                         owner->view()->text->sel_cursor =
2014                                 owner->view()->text->cursor;
2015                         owner->view()->update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
2016                         // It is possible to make it a lot faster still
2017                         // just comment out the lone below...
2018                         owner->view()->showCursor();
2019                 } else {
2020                         owner->view()->cut();
2021                 }
2022                 moveCursorUpdate(false);
2023                 owner->showState();
2024                 owner->view()->setState();
2025                 break;
2026
2027         case LFUN_DELETE_SKIP:
2028         {
2029                 // Reverse the effect of LFUN_BREAKPARAGRAPH_SKIP.
2030
2031                 LyXCursor cursor = owner->view()->text->cursor;
2032
2033                 if (!owner->view()->text->selection) {
2034                         if (cursor.pos() == cursor.par()->Last()) {
2035                                 owner->view()->text->CursorRight(owner->view());
2036                                 cursor = owner->view()->text->cursor;
2037                                 if (cursor.pos() == 0
2038                                     && !(cursor.par()->added_space_top
2039                                          == VSpace (VSpace::NONE))) {
2040                                         owner->view()->text->SetParagraph
2041                                                 (owner->view(),
2042                                                  cursor.par()->line_top,
2043                                                  cursor.par()->line_bottom,
2044                                                  cursor.par()->pagebreak_top,
2045                                                  cursor.par()->pagebreak_bottom,
2046                                                  VSpace(VSpace::NONE),
2047                                                  cursor.par()->added_space_bottom,
2048                                                  cursor.par()->align,
2049                                                  cursor.par()->labelwidthstring, 0);
2050                                         owner->view()->text->CursorLeft(owner->view());
2051                                         owner->view()->update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
2052                                 } else {
2053                                         owner->view()->text->CursorLeft(owner->view());
2054                                         owner->view()->text->Delete(owner->view());
2055                                         owner->view()->text->sel_cursor =
2056                                                 owner->view()->text->cursor;
2057                                         owner->view()->update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
2058                                 }
2059                         } else {
2060                                 owner->view()->text->Delete(owner->view());
2061                                 owner->view()->text->sel_cursor =
2062                                         owner->view()->text->cursor;
2063                                 owner->view()->update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
2064                         }
2065                 } else {
2066                         owner->view()->cut();
2067                 }
2068         }
2069         break;
2070
2071         /* -------> Delete word forward. */
2072         case LFUN_DELETE_WORD_FORWARD:
2073                 owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
2074                 owner->view()->text->DeleteWordForward(owner->view());
2075                 owner->view()->update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
2076                 moveCursorUpdate(false);
2077                 owner->showState();
2078                 break;
2079
2080                 /* -------> Delete word backward. */
2081         case LFUN_DELETE_WORD_BACKWARD:
2082                 owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
2083                 owner->view()->text->DeleteWordBackward(owner->view());
2084                 owner->view()->update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
2085                 moveCursorUpdate(false);
2086                 owner->showState();
2087                 break;
2088
2089                 /* -------> Kill to end of line. */
2090         case LFUN_DELETE_LINE_FORWARD:
2091                 owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
2092                 owner->view()->text->DeleteLineForward(owner->view());
2093                 owner->view()->update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
2094                 moveCursorUpdate(false);
2095                 break;
2096
2097                 /* -------> Set mark off. */
2098         case LFUN_MARK_OFF:
2099                 owner->view()->beforeChange();
2100                 owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
2101                 owner->view()->text->sel_cursor =
2102                         owner->view()->text->cursor;
2103                 setMessage(N_("Mark off"));
2104                 break;
2105
2106                 /* -------> Set mark on. */
2107         case LFUN_MARK_ON:
2108                 owner->view()->beforeChange();
2109                 owner->view()->text->mark_set = 1;
2110                 owner->view()->update(BufferView::SELECT|BufferView::FITCUR);
2111                 owner->view()->text->sel_cursor =
2112                         owner->view()->text->cursor;
2113                 setMessage(N_("Mark on"));
2114                 break;
2115
2116         case LFUN_BACKSPACE:
2117         {
2118                 if (!owner->view()->text->selection) {
2119                         if (owner->getIntl()->getTrans()->backspace()) {
2120                                 owner->view()->text->Backspace(owner->view());
2121                                 owner->view()->text->sel_cursor =
2122                                         owner->view()->text->cursor;
2123                                 owner->view()->update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
2124                                 // It is possible to make it a lot faster still
2125                                 // just comment out the lone below...
2126                                 owner->view()->showCursor();
2127                         }
2128                 } else {
2129                         owner->view()->cut();
2130                 }
2131                 owner->showState();
2132                 owner->view()->setState();
2133         }
2134         break;
2135
2136         case LFUN_BACKSPACE_SKIP:
2137         {
2138                 // Reverse the effect of LFUN_BREAKPARAGRAPH_SKIP.
2139
2140                 LyXCursor cursor = owner->view()->text->cursor;
2141
2142                 if (!owner->view()->text->selection) {
2143                         if (cursor.pos() == 0
2144                             && !(cursor.par()->added_space_top
2145                                  == VSpace (VSpace::NONE))) {
2146                                 owner->view()->text->SetParagraph
2147                                         (owner->view(),
2148                                          cursor.par()->line_top,
2149                                          cursor.par()->line_bottom,
2150                                          cursor.par()->pagebreak_top,
2151                                          cursor.par()->pagebreak_bottom,
2152                                          VSpace(VSpace::NONE), cursor.par()->added_space_bottom,
2153                                          cursor.par()->align,
2154                                          cursor.par()->labelwidthstring, 0);
2155                                 owner->view()->update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
2156                         } else {
2157                                 owner->view()->text->Backspace(owner->view());
2158                                 owner->view()->text->sel_cursor
2159                                         = cursor;
2160                                 owner->view()->update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
2161                         }
2162                 } else
2163                         owner->view()->cut();
2164         }
2165         break;
2166
2167         case LFUN_BREAKPARAGRAPH:
2168         {
2169                 owner->view()->beforeChange();
2170                 owner->view()->text->BreakParagraph(owner->view(), 0);
2171                 owner->view()->update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
2172                 owner->view()->text->sel_cursor =
2173                         owner->view()->text->cursor;
2174                 owner->view()->setState();
2175                 owner->showState();
2176                 break;
2177         }
2178
2179         case LFUN_BREAKPARAGRAPHKEEPLAYOUT:
2180         {
2181                 owner->view()->beforeChange();
2182                 owner->view()->text->BreakParagraph(owner->view(), 1);
2183                 owner->view()->update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
2184                 owner->view()->text->sel_cursor =
2185                         owner->view()->text->cursor;
2186                 owner->view()->setState();
2187                 owner->showState();
2188                 break;
2189         }
2190
2191         case LFUN_BREAKPARAGRAPH_SKIP:
2192         {
2193                 // When at the beginning of a paragraph, remove
2194                 // indentation and add a "defskip" at the top.
2195                 // Otherwise, do the same as LFUN_BREAKPARAGRAPH.
2196
2197                 LyXCursor cursor = owner->view()->text->cursor;
2198
2199                 owner->view()->beforeChange();
2200                 if (cursor.pos() == 0) {
2201                         if (cursor.par()->added_space_top == VSpace(VSpace::NONE)) {
2202                                 owner->view()->text->SetParagraph
2203                                         (owner->view(),
2204                                          cursor.par()->line_top,
2205                                          cursor.par()->line_bottom,
2206                                          cursor.par()->pagebreak_top,
2207                                          cursor.par()->pagebreak_bottom,
2208                                          VSpace(VSpace::DEFSKIP), cursor.par()->added_space_bottom,
2209                                          cursor.par()->align,
2210                                          cursor.par()->labelwidthstring, 1);
2211                                 //owner->view()->update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
2212                         }
2213                 }
2214                 else {
2215                         owner->view()->text->BreakParagraph(owner->view(), 0);
2216                         //owner->view()->update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
2217                 }
2218
2219                 owner->view()->update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
2220                 owner->view()->text->sel_cursor = cursor;
2221                 owner->view()->setState();
2222                 owner->showState();
2223         }
2224         break;
2225
2226         case LFUN_PARAGRAPH_SPACING:
2227         {
2228                 LyXParagraph * par = owner->view()->text->cursor.par();
2229                 Spacing::Space cur_spacing = par->spacing.getSpace();
2230                 float cur_value = 1.0;
2231                 if (cur_spacing == Spacing::Other) {
2232                         cur_value = par->spacing.getValue();
2233                 }
2234
2235 #ifdef HAVE_SSTREAM
2236                 istringstream istr(argument);
2237 #else
2238                 istrstream istr(argument.c_str());
2239 #endif
2240                 string tmp;
2241                 istr >> tmp;
2242                 Spacing::Space new_spacing = cur_spacing;
2243                 float new_value = cur_value;
2244                 if (tmp.empty()) {
2245                         lyxerr << "Missing argument to `paragraph-spacing'"
2246                                << endl;
2247                 } else if (tmp == "single") {
2248                         new_spacing = Spacing::Single;
2249                 } else if (tmp == "onehalf") {
2250                         new_spacing = Spacing::Onehalf;
2251                 } else if (tmp == "double") {
2252                         new_spacing = Spacing::Double;
2253                 } else if (tmp == "other") {
2254                         new_spacing = Spacing::Other;
2255                         float tmpval = 0.0;
2256                         istr >> tmpval;
2257                         lyxerr << "new_value = " << tmpval << endl;
2258                         if (tmpval != 0.0)
2259                                 new_value = tmpval;
2260                 } else if (tmp == "default") {
2261                         new_spacing = Spacing::Default;
2262                 } else {
2263                         lyxerr << _("Unknown spacing argument: ")
2264                                << argument << endl;
2265                 }
2266                 if (cur_spacing != new_spacing || cur_value != new_value) {
2267                         par->spacing.set(new_spacing, new_value);
2268                         owner->view()->text->RedoParagraph(owner->view());
2269                         owner->view()->update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
2270                 }
2271         }
2272         break;
2273
2274         case LFUN_QUOTE:
2275                 owner->view()->beforeChange();
2276                 owner->view()->text->InsertChar(owner->view(), '\"');  // This " matches the single quote in the code
2277                 owner->view()->update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
2278                 moveCursorUpdate(false);
2279                 break;
2280
2281         case LFUN_HTMLURL:
2282         case LFUN_URL:
2283         {
2284                 InsetCommandParams p;
2285                 if (action == LFUN_HTMLURL)
2286                         p.setCmdName("htmlurl");
2287                 else
2288                         p.setCmdName("url");
2289                 owner->getDialogs()->createUrl( p.getAsString() );
2290         }
2291         break;
2292
2293         case LFUN_INSERT_URL:
2294         {
2295                 InsetCommandParams p;
2296                 p.setFromString( argument );
2297
2298                 InsetUrl * inset = new InsetUrl( p );
2299                 if (!owner->view()->insertInset(inset))
2300                         delete inset;
2301                 else
2302                         owner->view()->updateInset( inset, true );
2303         }
2304         break;
2305
2306         case LFUN_INSET_TEXT:
2307         {
2308                 InsetText * new_inset = new InsetText;
2309                 if (owner->view()->insertInset(new_inset))
2310                         new_inset->Edit(owner->view(), 0, 0, 0);
2311                 else
2312                         delete new_inset;
2313         }
2314         break;
2315
2316         case LFUN_INSET_ERT:
2317         {
2318                 InsetERT * new_inset = new InsetERT;
2319                 if (owner->view()->insertInset(new_inset))
2320                         new_inset->Edit(owner->view(), 0, 0, 0);
2321                 else
2322                         delete new_inset;
2323         }
2324         break;
2325
2326         case LFUN_INSET_EXTERNAL:
2327         {
2328                 InsetExternal * new_inset = new InsetExternal;
2329                 if (owner->view()->insertInset(new_inset))
2330                         new_inset->Edit(owner->view(), 0, 0, 0);
2331                 else
2332                         delete new_inset;
2333         }
2334         break;
2335
2336         case LFUN_INSET_FOOTNOTE:
2337         {
2338                 InsetFoot * new_inset = new InsetFoot;
2339                 if (owner->view()->insertInset(new_inset))
2340                         new_inset->Edit(owner->view(), 0, 0, 0);
2341                 else
2342                         delete new_inset;
2343         }
2344         break;
2345
2346         case LFUN_INSET_MARGINAL:
2347         {
2348                 InsetMarginal * new_inset = new InsetMarginal;
2349                 if (owner->view()->insertInset(new_inset))
2350                         new_inset->Edit(owner->view(), 0, 0, 0);
2351                 else
2352                         delete new_inset;
2353         }
2354         break;
2355
2356         case LFUN_INSET_MINIPAGE:
2357         {
2358                 InsetMinipage * new_inset = new InsetMinipage;
2359                 if (owner->view()->insertInset(new_inset))
2360                         new_inset->Edit(owner->view(), 0, 0, 0);
2361                 else
2362                         delete new_inset;
2363         }
2364         break;
2365
2366         case LFUN_INSET_FLOAT:
2367         {
2368                 // check if the float type exist
2369                 if (floatList.typeExist(argument)) {
2370                         InsetFloat * new_inset = new InsetFloat(argument);
2371                         if (owner->view()->insertInset(new_inset))
2372                                 new_inset->Edit(owner->view(), 0, 0, 0);
2373                         else
2374                                 delete new_inset;
2375                 } else {
2376                         lyxerr << "Non-existant float type: "
2377                                << argument << endl;
2378                 }
2379
2380         }
2381         break;
2382
2383         case LFUN_INSET_LIST:
2384         {
2385                 InsetList * new_inset = new InsetList;
2386                 if (owner->view()->insertInset(new_inset))
2387                         new_inset->Edit(owner->view(), 0, 0, 0);
2388                 else
2389                         delete new_inset;
2390         }
2391         break;
2392
2393         case LFUN_INSET_THEOREM:
2394         {
2395                 InsetTheorem * new_inset = new InsetTheorem;
2396                 if (owner->view()->insertInset(new_inset))
2397                         new_inset->Edit(owner->view(), 0, 0, 0);
2398                 else
2399                         delete new_inset;
2400         }
2401         break;
2402
2403         case LFUN_INSET_CAPTION:
2404         {
2405                 // Do we have a locking inset...
2406                 if (owner->view()->the_locking_inset) {
2407                         lyxerr << "Locking inset code: "
2408                                << static_cast<int>(owner->view()->the_locking_inset->LyxCode());
2409                         InsetCaption * new_inset = new InsetCaption;
2410                         new_inset->setOwner(owner->view()->the_locking_inset);
2411                         new_inset->SetAutoBreakRows(true);
2412                         new_inset->SetDrawFrame(0, InsetText::LOCKED);
2413                         new_inset->SetFrameColor(0, LColor::footnoteframe);
2414                         if (owner->view()->insertInset(new_inset))
2415                                 new_inset->Edit(owner->view(), 0, 0, 0);
2416                         else
2417                                 delete new_inset;
2418                 }
2419         }
2420         break;
2421
2422         case LFUN_INSET_TABULAR:
2423         {
2424                 int r = 2, c = 2;
2425                 if (!argument.empty())
2426                         sscanf(argument.c_str(),"%d%d", &r, &c);
2427                 InsetTabular * new_inset =
2428                         new InsetTabular(owner->buffer(), r, c);
2429                 if (owner->view()->insertInset(new_inset))
2430                         new_inset->Edit(owner->view(), 0, 0, 0);
2431                 else
2432                         delete new_inset;
2433         }
2434         break;
2435
2436         // --- lyxserver commands ----------------------------
2437
2438         case LFUN_CHARATCURSOR:
2439         {
2440                 LyXParagraph::size_type pos =
2441                         owner->view()->text->cursor.pos();
2442                 if(pos < owner->view()->text->cursor.par()->size())
2443                         //dispatch_buffer = owner->view()->text->
2444                         //      cursor.par()->text[pos];
2445                         dispatch_buffer =
2446                                 owner->view()->text->
2447                                 cursor.par()->GetChar(pos);
2448                 else
2449                         dispatch_buffer = "EOF";
2450         }
2451         break;
2452
2453         case LFUN_GETXY:
2454                 dispatch_buffer =
2455                         tostr(owner->view()->text->cursor.x()) + ' '
2456                         + tostr(owner->view()->text->cursor.y());
2457                 break;
2458
2459         case LFUN_SETXY:
2460         {
2461                 int  x;
2462                 long y;
2463                 sscanf(argument.c_str(), " %d %ld", &x, &y);
2464                 owner->view()->text->SetCursorFromCoordinates(owner->view(), x, y);
2465         }
2466         break;
2467
2468         case LFUN_GETLAYOUT:
2469                 dispatch_buffer =
2470                         tostr(owner->view()->text->cursor.par()->layout);
2471                 break;
2472
2473         case LFUN_GETFONT:
2474         {
2475                 LyXFont & font = owner->view()->text->current_font;
2476                 if(font.shape() == LyXFont::ITALIC_SHAPE)
2477                         dispatch_buffer = 'E';
2478                 else if(font.shape() == LyXFont::SMALLCAPS_SHAPE)
2479                         dispatch_buffer = 'N';
2480                 else
2481                         dispatch_buffer = '0';
2482
2483         }
2484         break;
2485
2486         case LFUN_GETLATEX:
2487         {
2488                 LyXFont & font = owner->view()->text->current_font;
2489                 if(font.latex() == LyXFont::ON)
2490                         dispatch_buffer = 'L';
2491                 else
2492                         dispatch_buffer = '0';
2493         }
2494         break;
2495
2496         case LFUN_GETNAME:
2497                 setMessage(owner->buffer()->fileName());
2498                 lyxerr.debug() << "FNAME["
2499                                << owner->buffer()->fileName()
2500                                << "] " << endl;
2501                 break;
2502
2503         case LFUN_NOTIFY:
2504         {
2505                 string buf;
2506                 keyseq.print(buf);
2507                 dispatch_buffer = buf;
2508                 lyxserver->notifyClient(dispatch_buffer);
2509         }
2510         break;
2511
2512         case LFUN_GOTOFILEROW:
2513         {
2514                 char file_name[100];
2515                 int  row;
2516                 sscanf(argument.c_str(), " %s %d", file_name, &row);
2517
2518                 // Must replace extension of the file to be .lyx and get full path
2519                 string s = ChangeExtension(string(file_name), ".lyx");
2520
2521                 // Either change buffer or load the file
2522                 if (bufferlist.exists(s))
2523                         owner->view()->buffer(bufferlist.getBuffer(s));
2524                 else
2525                         owner->view()->buffer(bufferlist.loadLyXFile(s));
2526
2527                 // Set the cursor
2528                 owner->view()->setCursorFromRow(row);
2529
2530                 // Recenter screen
2531                 owner->view()->center();
2532         }
2533         break;
2534
2535         case LFUN_GOTO_PARAGRAPH:
2536         {
2537 #ifdef HAVE_SSTREAM
2538                 istringstream istr(argument);
2539 #else
2540                 istrstream istr(argument.c_str());
2541 #endif
2542
2543                 int id;
2544                 istr >> id;
2545                 LyXParagraph * par = owner->view()->text->GetParFromID(id);
2546
2547                 // Set the cursor
2548                 owner->view()->text->SetCursor(owner->view(), par, 0);
2549                 owner->view()->setState();
2550                 owner->showState();
2551
2552                 // Recenter screen
2553                 owner->view()->center();
2554         }
2555         break;
2556
2557         case LFUN_APROPOS:
2558         case LFUN_GETTIP:
2559         {
2560                 int qa = lyxaction.LookupFunc(argument.c_str());
2561                 setMessage(lyxaction.helpText(static_cast<kb_action>(qa)));
2562         }
2563         break;
2564
2565         // --- accented characters ---------------------------
2566
2567         case LFUN_UMLAUT:
2568         case LFUN_CIRCUMFLEX:
2569         case LFUN_GRAVE:
2570         case LFUN_ACUTE:
2571         case LFUN_TILDE:
2572         case LFUN_CEDILLA:
2573         case LFUN_MACRON:
2574         case LFUN_DOT:
2575         case LFUN_UNDERDOT:
2576         case LFUN_UNDERBAR:
2577         case LFUN_CARON:
2578         case LFUN_SPECIAL_CARON:
2579         case LFUN_BREVE:
2580         case LFUN_TIE:
2581         case LFUN_HUNG_UMLAUT:
2582         case LFUN_CIRCLE:
2583         case LFUN_OGONEK:
2584         {
2585                 char c = 0;
2586
2587                 if (keyseq.length == -1 && keyseq.getiso() != 0)
2588                         c = keyseq.getiso();
2589
2590                 owner->getIntl()->getTrans()->
2591                         deadkey(c, get_accent(action).accent,
2592                                 owner->view()->text);
2593
2594                 // Need to reset, in case the minibuffer calls these
2595                 // actions
2596                 keyseq.reset();
2597                 keyseq.length = 0;
2598
2599                 // copied verbatim from do_accent_char
2600                 owner->view()->update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
2601
2602                 owner->view()->text->sel_cursor =
2603                         owner->view()->text->cursor;
2604         }
2605         break;
2606
2607         // --- toolbar ----------------------------------
2608         case LFUN_PUSH_TOOLBAR:
2609         {
2610                 int nth = strToInt(argument);
2611                 if (nth <= 0) {
2612                         setErrorMessage(N_("Push-toolbar needs argument > 0"));
2613                 } else {
2614                         owner->getToolbar()->push(nth);
2615                 }
2616         }
2617         break;
2618
2619         case LFUN_ADD_TO_TOOLBAR:
2620         {
2621                 if (lyxerr.debugging(Debug::GUI)) {
2622                         lyxerr << "LFUN_ADD_TO_TOOLBAR:"
2623                                 "argument = `" << argument << '\'' << endl;
2624                 }
2625                 string tmp(argument);
2626                 //lyxerr <<string("Argument: ") + argument);
2627                 //lyxerr <<string("Tmp     : ") + tmp);
2628                 if (tmp.empty()) {
2629                         setErrorMessage(N_("Usage: toolbar-add-to <LyX command>"));
2630                 } else {
2631                         owner->getToolbar()->add(argument, false);
2632                         owner->getToolbar()->set();
2633                 }
2634         }
2635         break;
2636
2637         // --- insert characters ----------------------------------------
2638
2639         // ---  Mathed stuff. If we are here, there is no locked inset yet.
2640
2641         // Greek mode
2642         case LFUN_GREEK:
2643         {
2644                 if (!greek_kb_flag) {
2645                         greek_kb_flag = 1;
2646                         setMessage(N_("Math greek mode on"));
2647                 } else
2648                         greek_kb_flag = 0;
2649         }
2650         break;
2651
2652         // Greek keyboard
2653         case LFUN_GREEK_TOGGLE:
2654         {
2655                 greek_kb_flag = greek_kb_flag ? 0 : 2;
2656                 if (greek_kb_flag) {
2657                         setMessage(N_("Math greek keyboard on"));
2658                 } else {
2659                         setMessage(N_("Math greek keyboard off"));
2660                 }
2661         }
2662         break;
2663
2664         case LFUN_MATH_DELIM:
2665         case LFUN_INSERT_MATRIX:
2666         {
2667                 if (owner->view()->available()) {
2668                         owner->view()->
2669                                 open_new_inset(new InsetFormula(false));
2670                         owner->view()
2671                                 ->the_locking_inset
2672                                 ->LocalDispatch(owner->view(),
2673                                                 action,
2674                                                 argument);
2675                 }
2676         }
2677         break;
2678
2679         case LFUN_INSERT_MATH:
2680         {
2681                 math_insert_symbol(argument.c_str());
2682         }
2683         break;
2684
2685         case LFUN_MATH_DISPLAY:
2686         {
2687                 if (owner->view()->available())
2688                         owner->view()->open_new_inset(new InsetFormula(true));
2689                 break;
2690         }
2691
2692         case LFUN_MATH_MACRO:
2693         {
2694                 if (owner->view()->available()) {
2695                         string s(argument);
2696                         if (s.empty())
2697                                 setErrorMessage(N_("Missing argument"));
2698                         else {
2699                                 string s1 = token(s, ' ', 1);
2700                                 int na = s1.empty() ? 0: atoi(s1.c_str());
2701                                 owner->view()->
2702                                         open_new_inset(new InsetFormulaMacro(token(s, ' ', 0), na));
2703                         }
2704                 }
2705         }
2706         break;
2707
2708         case LFUN_MATH_MODE:   // Open or create a math inset
2709         {
2710                 if (owner->view()->available())
2711                         owner->view()->open_new_inset(new InsetFormula);
2712                 setMessage(N_("Math editor mode"));
2713         }
2714         break;
2715
2716         case LFUN_MATH_NUMBER:
2717         case LFUN_MATH_LIMITS:
2718         {
2719                 setErrorMessage(N_("This is only allowed in math mode!"));
2720
2721         }
2722         break;
2723
2724         case LFUN_MATH_PANEL:
2725         {
2726                 show_symbols_form(this);
2727         }
2728         break;
2729
2730         case LFUN_CITATION_CREATE:
2731         {
2732                 // Should do this "at source"
2733                 InsetCommandParams p( "cite" );
2734
2735                 if (contains(argument, "|")) {
2736                         p.setContents( token(argument, '|', 0) );
2737                         p.setOptions(  token(argument, '|', 1) );
2738                 } else {
2739                         p.setContents( argument );
2740                 }
2741
2742                 owner->getDialogs()->createCitation( p.getAsString() );
2743         }
2744         break;
2745
2746         case LFUN_CITATION_INSERT:
2747         {
2748                 InsetCommandParams p;
2749                 p.setFromString( argument );
2750
2751                 InsetCitation * inset = new InsetCitation( p );
2752                 if (!owner->view()->insertInset(inset))
2753                         delete inset;
2754                 else
2755                         owner->view()->updateInset( inset, true );
2756         }
2757         break;
2758
2759         case LFUN_INSERT_BIBTEX:
2760         {
2761                 // ale970405+lasgoutt970425
2762                 // The argument can be up to two tokens separated
2763                 // by a space. The first one is the bibstyle.
2764                 string db       = token(argument, ' ', 0);
2765                 string bibstyle = token(argument, ' ', 1);
2766                 if (bibstyle.empty())
2767                         bibstyle = "plain";
2768
2769                 InsetCommandParams p( "BibTeX", db, bibstyle );
2770                 InsetBibtex * inset = new InsetBibtex(p, owner->buffer());
2771
2772                 if (owner->view()->insertInset(inset)) {
2773                         if (argument.empty())
2774                                 inset->Edit(owner->view(), 0, 0, 0);
2775                 } else
2776                         delete inset;
2777         }
2778         break;
2779
2780         // BibTeX data bases
2781         case LFUN_BIBDB_ADD:
2782         {
2783                 InsetBibtex * inset =
2784                         static_cast<InsetBibtex*>(getInsetByCode(Inset::BIBTEX_CODE));
2785                 if (inset) {
2786                         inset->addDatabase(argument);
2787                 }
2788         }
2789         break;
2790
2791         case LFUN_BIBDB_DEL:
2792         {
2793                 InsetBibtex * inset =
2794                         static_cast<InsetBibtex*>(getInsetByCode(Inset::BIBTEX_CODE));
2795                 if (inset) {
2796                         inset->delDatabase(argument);
2797                 }
2798         }
2799         break;
2800
2801         case LFUN_BIBTEX_STYLE:
2802         {
2803                 InsetBibtex * inset =
2804                         static_cast<InsetBibtex*>(getInsetByCode(Inset::BIBTEX_CODE));
2805                 if (inset) {
2806                         inset->setOptions(argument);
2807                 }
2808         }
2809         break;
2810
2811         case LFUN_INDEX_CREATE:
2812         {
2813                 InsetCommandParams p( "index" );
2814
2815                 if( argument.empty() ) {
2816                         // Get the word immediately preceding the cursor
2817                         LyXParagraph::size_type curpos =
2818                                 owner->view()->text->cursor.pos() - 1;
2819
2820                         string curstring;
2821                         if( curpos >= 0 )
2822                                 curstring = owner->view()->text
2823                                             ->cursor.par()->GetWord(curpos);
2824
2825                         p.setContents( curstring );
2826                 } else {
2827                         p.setContents( argument );
2828                 }
2829
2830                 owner->getDialogs()->createIndex( p.getAsString() );
2831         }
2832         break;
2833
2834         case LFUN_INDEX_INSERT:
2835         {
2836                 InsetCommandParams p;
2837                 p.setFromString( argument );
2838                 InsetIndex * inset = new InsetIndex( p );
2839
2840                 if (!owner->view()->insertInset(inset))
2841                         delete inset;
2842                 else
2843                         owner->view()->updateInset( inset, true );
2844         }
2845         break;
2846
2847         case LFUN_INDEX_INSERT_LAST:
2848         {
2849                 // Get word immediately preceding the cursor
2850                 LyXParagraph::size_type curpos =
2851                         owner->view()->text->cursor.pos() - 1;
2852                 // Can't do that at the beginning of a paragraph
2853                 if( curpos < 0 ) break;
2854
2855                 string curstring( owner->view()->text
2856                                   ->cursor.par()->GetWord(curpos) );
2857
2858                 InsetCommandParams p( "index", curstring );
2859                 InsetIndex * inset = new InsetIndex( p );
2860
2861                 if (!owner->view()->insertInset(inset))
2862                         delete inset;
2863                 else
2864                         owner->view()->updateInset( inset, true );
2865         }
2866         break;
2867
2868         case LFUN_INDEX_PRINT:
2869         {
2870                 InsetCommandParams p( "printindex" );
2871                 Inset * inset = new InsetPrintIndex(p);
2872                 if (!owner->view()->insertInset(inset, "Standard", true))
2873                         delete inset;
2874         }
2875         break;
2876
2877         case LFUN_PARENTINSERT:
2878         {
2879                 lyxerr << "arg " << argument << endl;
2880                 InsetCommandParams p( "lyxparent", argument );
2881                 Inset * inset = new InsetParent(p, owner->buffer());
2882                 if (!owner->view()->insertInset(inset, "Standard", true))
2883                         delete inset;
2884         }
2885         break;
2886
2887         case LFUN_CHILDINSERT:
2888         {
2889                 InsetCommandParams p( "Include", argument );
2890                 Inset * inset = new InsetInclude(p, owner->buffer());
2891                 if (owner->view()->insertInset(inset, "Standard", true))
2892                         inset->Edit(owner->view(), 0, 0, 0);
2893                 else
2894                         delete inset;
2895         }
2896         break;
2897
2898         case LFUN_CHILDOPEN:
2899         {
2900                 string filename =
2901                         MakeAbsPath(argument,
2902                                     OnlyPath(owner->buffer()->fileName()));
2903                 setMessage(N_("Opening child document ") +
2904                            MakeDisplayPath(filename) + "...");
2905                 owner->view()->savePosition();
2906                 if (bufferlist.exists(filename))
2907                         owner->view()->buffer(bufferlist.getBuffer(filename));
2908                 else
2909                         owner->view()->buffer(bufferlist.loadLyXFile(filename));
2910         }
2911         break;
2912
2913         case LFUN_INSERT_NOTE:
2914                 owner->view()->insertNote();
2915                 break;
2916 #ifndef NEW_INSETS
2917         case LFUN_INSERTFOOTNOTE:
2918         {
2919                 LyXParagraph::footnote_kind kind;
2920                 if (argument == "footnote")
2921                         { kind = LyXParagraph::FOOTNOTE; }
2922                 else if (argument == "margin")
2923                         { kind = LyXParagraph::MARGIN; }
2924                 else if (argument == "figure")
2925                         { kind = LyXParagraph::FIG; }
2926                 else if (argument == "table")
2927                         { kind = LyXParagraph::TAB; }
2928                 else if (argument == "wide-fig")
2929                         { kind = LyXParagraph::WIDE_FIG; }
2930                 else if (argument == "wide-tab")
2931                         { kind = LyXParagraph::WIDE_TAB; }
2932                 else if (argument == "algorithm")
2933                         { kind = LyXParagraph::ALGORITHM; }
2934                 else {
2935                         setErrorMessage(N_("Unknown kind of footnote"));
2936                         break;
2937                 }
2938                 owner->view()->text->InsertFootnoteEnvironment(owner->view(), kind);
2939                 owner->view()->update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
2940                 owner->view()->setState();
2941         }
2942         break;
2943 #endif
2944         case LFUN_BUFFERBULLETSSELECT:
2945                 bulletForm();
2946                 break;
2947
2948         case LFUN_TOGGLECURSORFOLLOW:
2949                 cursor_follows_scrollbar = !cursor_follows_scrollbar;
2950                 break;
2951
2952         case LFUN_KMAP_OFF:             // keymap off
2953                 owner->getIntl()->KeyMapOn(false);
2954                 break;
2955
2956         case LFUN_KMAP_PRIM:    // primary keymap
2957                 owner->getIntl()->KeyMapPrim();
2958                 break;
2959
2960         case LFUN_KMAP_SEC:             // secondary keymap
2961                 owner->getIntl()->KeyMapSec();
2962                 break;
2963
2964         case LFUN_KMAP_TOGGLE:  // toggle keymap
2965                 owner->getIntl()->ToggleKeyMap();
2966                 break;
2967
2968         case LFUN_SELFINSERT:
2969         {
2970                 for (string::size_type i = 0; i < argument.length(); ++i) {
2971                         owner->view()->text->InsertChar(owner->view(), argument[i]);
2972                         // This needs to be in the loop, or else we
2973                         // won't break lines correctly. (Asger)
2974                         owner->view()->update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
2975                 }
2976                 owner->view()->text->sel_cursor =
2977                         owner->view()->text->cursor;
2978                 moveCursorUpdate(false);
2979         }
2980         break;
2981
2982         case LFUN_SEQUENCE:
2983         {
2984                 // argument contains ';'-terminated commands
2985                 while (argument.find(';') != string::npos) {
2986                         string first;
2987                         argument = split(argument, first, ';');
2988                         Dispatch(first);
2989                 }
2990         }
2991         break;
2992
2993         case LFUN_DATE_INSERT:  // jdblair: date-insert cmd
2994         {
2995                 struct tm * now_tm;
2996
2997                 time_t now_time_t = time(NULL);
2998                 now_tm = localtime(&now_time_t);
2999                 setlocale(LC_TIME, "");
3000                 string arg;
3001                 if (!argument.empty())
3002                         arg = argument;
3003                 else
3004                         arg = lyxrc.date_insert_format;
3005                 char datetmp[32];
3006                 int datetmp_len = strftime(datetmp, 32, arg.c_str(), now_tm);
3007                 for (int i = 0; i < datetmp_len; i++) {
3008                         owner->view()->text->InsertChar(owner->view(), datetmp[i]);
3009                         owner->view()->update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
3010                 }
3011
3012                 owner->view()->text->sel_cursor = owner->view()->text->cursor;
3013                 moveCursorUpdate(false);
3014         }
3015         break;
3016
3017         case LFUN_DIALOG_PREFERENCES:
3018                 owner->getDialogs()->showPreferences();
3019                 break;
3020
3021         case LFUN_SAVEPREFERENCES:
3022         {
3023                 Path p(user_lyxdir);
3024                 lyxrc.write("preferences");
3025         }
3026         break;
3027
3028         case LFUN_SCREEN_FONT_UPDATE:
3029         {
3030                 // handle the screen font changes.
3031                 //
3032                 lyxrc.set_font_norm_type();
3033                 fontloader.update();
3034                 // Of course we should only do the resize and the textcache.clear
3035                 // if values really changed...but not very important right now. (Lgb)
3036                 // All buffers will need resize
3037                 bufferlist.resize();
3038                 // We also need to empty the textcache so that
3039                 // the buffer will be formatted correctly after
3040                 // a zoom change.
3041                 textcache.clear();
3042         }
3043
3044         case LFUN_SET_COLOR:
3045         {
3046                 string lyx_name, x11_name;
3047                 x11_name = split(argument, lyx_name, ' ');
3048                 if (lyx_name.empty() || x11_name.empty()) {
3049                         LyXBell();
3050                         setErrorMessage(N_("Syntax: set-color <lyx_name>"
3051                                                 " <x11_name>"));
3052                         break;
3053                         }
3054
3055                 if (!lcolor.setColor(lyx_name, x11_name)) {
3056                         static string err1 (N_("Set-color \""));
3057                         static string err2 (N_("\" failed - color is undefined "
3058                                                 "or may not be redefined"));
3059                         LyXBell();
3060                         setErrorMessage(err1 + lyx_name + err2);
3061                         break;
3062                 }
3063                 lyxColorHandler->updateColor(lcolor.getFromLyXName(lyx_name));
3064                 owner->view()->redraw();
3065                 break;
3066         }
3067
3068         case LFUN_UNKNOWN_ACTION:
3069         {
3070                 if(!owner->buffer()) {
3071                         LyXBell();
3072                         setErrorMessage(N_("No document open"));
3073                         break;
3074                 }
3075
3076                 if (owner->buffer()->isReadonly()) {
3077                         LyXBell();
3078                         setErrorMessage(N_("Document is read only"));
3079                         break;
3080                 }
3081
3082                 if (!argument.empty()) {
3083
3084                         /* Automatically delete the currently selected
3085                          * text and replace it with what is being
3086                          * typed in now. Depends on lyxrc settings
3087                          * "auto_region_delete", which defaults to
3088                          * true (on). */
3089
3090                         if ( lyxrc.auto_region_delete ) {
3091                                 if (owner->view()->text->selection){
3092                                         owner->view()->text->CutSelection(owner->view(), false);
3093                                         owner->view()->update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
3094                                 }
3095                         }
3096
3097                         owner->view()->beforeChange();
3098
3099                         for (string::size_type i = 0;
3100                              i < argument.length(); ++i) {
3101                                 if (greek_kb_flag) {
3102                                         if (!math_insert_greek(argument[i]))
3103                                                 owner->getIntl()->getTrans()->TranslateAndInsert(argument[i], owner->view()->text);
3104                                 } else
3105                                         owner->getIntl()->getTrans()->TranslateAndInsert(argument[i], owner->view()->text);
3106                         }
3107
3108                         owner->view()->update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
3109
3110                         owner->view()->text->sel_cursor =
3111                                 owner->view()->text->cursor;
3112                         moveCursorUpdate(false);
3113                         return string();
3114                 } else {
3115                         // why is an "Unknown action" with empty
3116                         // argument even dispatched in the first
3117                         // place? I`ll probably change that. (Lgb)
3118                         LyXBell();
3119                         setErrorMessage(N_("Unknown action"));
3120                 }
3121                 break;
3122         default:
3123                 lyxerr << "A truly unknown func!" << endl;
3124                 break;
3125         }
3126         } // end of switch
3127   exit_with_message:
3128
3129         string res = getMessage();
3130
3131         if (res.empty()) {
3132                 if (!commandshortcut.empty()) {
3133                         string newbuf = owner->getMiniBuffer()->GetText();
3134                         if (newbuf != commandshortcut) {
3135                                 owner->getMiniBuffer()->Set(newbuf
3136                                                             + " " +
3137                                                             commandshortcut);
3138                         }
3139                 }
3140         } else {
3141                 owner->getMiniBuffer()->Set(string(_(res.c_str()))
3142                                             + " " + commandshortcut);
3143         }
3144
3145         return res;
3146 }
3147
3148
3149 void LyXFunc::setupLocalKeymap()
3150 {
3151         keyseq.stdmap = keyseq.curmap = toplevel_keymap;
3152         cancel_meta_seq.stdmap = cancel_meta_seq.curmap = toplevel_keymap;
3153 }
3154
3155
3156 void LyXFunc::MenuNew(bool fromTemplate)
3157 {
3158         string fname, initpath = lyxrc.document_path;
3159         LyXFileDlg fileDlg;
3160
3161         if (owner->view()->available()) {
3162                 string trypath = owner->buffer()->filepath;
3163                 // If directory is writeable, use this as default.
3164                 if (IsDirWriteable(trypath) == 1)
3165                         initpath = trypath;
3166         }
3167
3168         static int newfile_number = 0;
3169         string s;
3170
3171         if (lyxrc.new_ask_filename) {
3172                 ProhibitInput(owner->view());
3173                 fileDlg.SetButton(0, _("Documents"), lyxrc.document_path);
3174                 fileDlg.SetButton(1, _("Templates"), lyxrc.template_path);
3175                 fname = fileDlg.Select(_("Enter Filename for new document"),
3176                                        initpath, "*.lyx", _("newfile"));
3177                 AllowInput(owner->view());
3178
3179                 if (fname.empty()) {
3180                         owner->getMiniBuffer()->Set(_("Canceled."));
3181                         lyxerr.debug() << "New Document Cancelled." << endl;
3182                         return;
3183                 }
3184
3185                 // get absolute path of file and make sure the filename ends
3186                 // with .lyx
3187                 s = MakeAbsPath(fname);
3188                 if (!IsLyXFilename(s))
3189                         s += ".lyx";
3190
3191                 // Check if the document already is open
3192                 if (bufferlist.exists(s)) {
3193                         switch(AskConfirmation(_("Document is already open:"),
3194                                                MakeDisplayPath(s, 50),
3195                                                _("Do you want to close that document now?\n"
3196                                                  "('No' will just switch to the open version)")))
3197                         {
3198                         case 1: // Yes: close the document
3199                                 if (!bufferlist.close(bufferlist.getBuffer(s)))
3200                                 // If close is canceled, we cancel here too.
3201                                         return;
3202                                 break;
3203                         case 2: // No: switch to the open document
3204                                 owner->view()->buffer(bufferlist.getBuffer(s));
3205                                 return;
3206                         case 3: // Cancel: Do nothing
3207                                 owner->getMiniBuffer()->Set(_("Canceled."));
3208                                 return;
3209                         }
3210                 }
3211                 // Check whether the file already exists
3212                 if (IsLyXFilename(s)) {
3213                         FileInfo fi(s);
3214                         if (fi.readable() &&
3215                             AskQuestion(_("File already exists:"),
3216                                         MakeDisplayPath(s, 50),
3217                                         _("Do you want to open the document?"))) {
3218                                 // loads document
3219                                 owner->getMiniBuffer()->Set(_("Opening document"),
3220                                                             MakeDisplayPath(s), "...");
3221                                 XFlush(fl_display);
3222                                 owner->view()->buffer(
3223                                         bufferlist.loadLyXFile(s));
3224                                 owner->getMiniBuffer()->Set(_("Document"),
3225                                                             MakeDisplayPath(s),
3226                                                             _("opened."));
3227                                 return;
3228                         }
3229                 }
3230         } else {
3231                 s = lyxrc.document_path + "newfile" + tostr(++newfile_number);
3232                 FileInfo fi(s);
3233                 while (bufferlist.exists(s) || fi.readable()) {
3234                         ++newfile_number;
3235                         s = lyxrc.document_path + "newfile" +
3236                                 tostr(newfile_number);
3237                         fi.newFile(s);
3238                 }
3239         }
3240
3241         // The template stuff
3242         string templname;
3243         if (fromTemplate) {
3244                 ProhibitInput(owner->view());
3245                 fname = fileDlg.Select(_("Choose template"),
3246                                        lyxrc.template_path,
3247                                        "*.lyx");
3248                 templname = fname;
3249                 AllowInput(owner->view());
3250         }
3251
3252         // find a free buffer
3253         lyxerr.debug() << "Find a free buffer." << endl;
3254         owner->view()->buffer(bufferlist.newFile(s, templname));
3255 }
3256
3257
3258 void LyXFunc::MenuOpen()
3259 {
3260         string initpath = lyxrc.document_path;
3261         LyXFileDlg fileDlg;
3262
3263         if (owner->view()->available()) {
3264                 string trypath = owner->buffer()->filepath;
3265                 // If directory is writeable, use this as default.
3266                 if (IsDirWriteable(trypath) == 1)
3267                         initpath = trypath;
3268         }
3269
3270         // launches dialog
3271         ProhibitInput(owner->view());
3272         fileDlg.SetButton(0, _("Documents"), lyxrc.document_path);
3273         fileDlg.SetButton(1, _("Examples"),
3274                           AddPath(system_lyxdir, "examples"));
3275         string filename = fileDlg.Select(_("Select Document to Open"),
3276                                          initpath, "*.lyx");
3277         AllowInput(owner->view());
3278
3279         // check selected filename
3280         if (filename.empty()) {
3281                 owner->getMiniBuffer()->Set(_("Canceled."));
3282                 return;
3283         }
3284
3285         // get absolute path of file and make sure the filename ends
3286         // with .lyx
3287         filename = MakeAbsPath(filename);
3288         if (!IsLyXFilename(filename))
3289                 filename += ".lyx";
3290
3291         // loads document
3292         owner->getMiniBuffer()->Set(_("Opening document"),
3293                                     MakeDisplayPath(filename), "...");
3294         Buffer * openbuf = bufferlist.loadLyXFile(filename);
3295         if (openbuf) {
3296                 owner->view()->buffer(openbuf);
3297                 owner->getMiniBuffer()->Set(_("Document"),
3298                                             MakeDisplayPath(filename),
3299                                             _("opened."));
3300         } else {
3301                 owner->getMiniBuffer()->Set(_("Could not open document"),
3302                                             MakeDisplayPath(filename));
3303         }
3304 }
3305
3306 // returns filename if file must be imported,
3307 // empty string if either file not found or already loaded
3308 // checks for running without gui are missing.
3309
3310 void LyXFunc::doImportHelper(
3311         string const & file,          // filename (possibly empty)
3312         string const & text,          // info when asking for filename
3313         string const & pattern,       // filetype
3314         bool func(BufferView *, string const &)     // the real import function
3315 )
3316 {
3317         string filename = file;
3318
3319         if (filename.empty()) { // need user interaction
3320                 string initpath = lyxrc.document_path;
3321                 LyXFileDlg fileDlg;
3322
3323                 if (owner->view()->available()) {
3324                         string trypath = owner->buffer()->filepath;
3325                         // If directory is writeable, use this as default.
3326                         if (IsDirWriteable(trypath) == 1)
3327                                 initpath = trypath;
3328                 }
3329
3330                 // launches dialog
3331                 ProhibitInput(owner->view());
3332                 fileDlg.SetButton(0, _("Documents"), lyxrc.document_path);
3333                 fileDlg.SetButton(1, _("Examples"),
3334                                         AddPath(system_lyxdir, "examples"));
3335                 filename = fileDlg.Select(text, initpath, pattern);
3336                 AllowInput(owner->view());
3337
3338                 // check selected filename
3339                 if (filename.empty())
3340                         owner->getMiniBuffer()->Set(_("Canceled."));
3341         }
3342
3343         // still no filename? abort
3344         if (filename.empty())
3345                 return;
3346
3347         // get absolute path of file
3348         filename = MakeAbsPath(filename);
3349
3350         string lyxfile = ChangeExtension(filename, ".lyx");
3351
3352         // Check if the document already is open
3353         if (bufferlist.exists(lyxfile)) {
3354                 switch(AskConfirmation(_("Document is already open:"),
3355                                        MakeDisplayPath(lyxfile, 50),
3356                                        _("Do you want to close that document now?\n"
3357                                          "('No' will just switch to the open version)")))
3358                         {
3359                         case 1: // Yes: close the document
3360                                 if (!bufferlist.close(bufferlist.getBuffer(lyxfile)))
3361                                 // If close is canceled, we cancel here too.
3362                                         return;
3363                                 break;
3364                         case 2: // No: switch to the open document
3365                                 owner->view()->buffer(bufferlist.getBuffer(lyxfile));
3366                                 return;
3367                         case 3: // Cancel: Do nothing
3368                                 owner->getMiniBuffer()->Set(_("Canceled."));
3369                                 return;
3370                         }
3371         }
3372
3373         // Check if a LyX document by the same root exists in filesystem
3374         FileInfo f(lyxfile, true);
3375         if (f.exist() && !AskQuestion(_("A document by the name"),
3376                                       MakeDisplayPath(lyxfile),
3377                                       _("already exists. Overwrite?"))) {
3378                 owner->getMiniBuffer()->Set(_("Canceled."));
3379                 return;
3380         }
3381         // filename should be valid now
3382
3383         // notify user of import ahead
3384         string displaypath = MakeDisplayPath(filename);
3385         owner->getMiniBuffer()->Set(_("Importing"), displaypath, "...");
3386
3387         // call real importer
3388         bool result = func(owner->view(), filename);
3389
3390         // we are done
3391         if (result)
3392                 owner->getMiniBuffer()->Set(displaypath, _("imported."));
3393         else
3394                 owner->getMiniBuffer()->Set(displaypath, _(": import failed."));
3395 }
3396
3397 static
3398 bool doImportASCIIasLines(BufferView * view, string const & filename)
3399 {
3400         view->buffer(bufferlist.newFile(filename, string()));
3401         InsertAsciiFile(view, filename, false);
3402         return true;
3403 }
3404
3405 static
3406 bool doImportASCIIasParagraphs(BufferView * view, string const & filename)
3407 {
3408         view->buffer(bufferlist.newFile(filename, string()));
3409         InsertAsciiFile(view, filename, true);
3410         return true;
3411 }
3412
3413 static
3414 bool doImportLaTeX(BufferView * view, string const & filename)
3415 {
3416         ImportLaTeX myImport(filename);
3417         Buffer * openbuf = myImport.run();
3418         if (openbuf) {
3419                 view->buffer(openbuf);
3420                 return true;
3421         }
3422         else
3423                 return false;
3424 }
3425
3426 static
3427 bool doImportNoweb(BufferView * view, string const & filename)
3428 {
3429         ImportNoweb myImport(filename);
3430         Buffer * openbuf = myImport.run();
3431         if (openbuf) {
3432                 view->buffer(openbuf);
3433                 return true;
3434         }
3435         else
3436                 return false;
3437 }
3438
3439 static
3440 bool doImportLinuxDoc(BufferView *, string const & filename)
3441 {
3442         // run sgml2lyx
3443         string tmp = lyxrc.linuxdoc_to_lyx_command + filename;
3444         Systemcalls one;
3445         Buffer * buf = 0;
3446
3447         int result = one.startscript(Systemcalls::System, tmp);
3448         if (result == 0) {
3449                 string filename = ChangeExtension(filename, ".lyx");
3450                 // File was generated without problems. Load it.
3451                 buf = bufferlist.loadLyXFile(filename);
3452         }
3453
3454         return result == 0;
3455 }
3456
3457
3458 void LyXFunc::MenuInsertLyXFile(string const & filen)
3459 {
3460         string filename = filen;
3461
3462         if (filename.empty()) {
3463                 // Launch a file browser
3464                 string initpath = lyxrc.document_path;
3465                 LyXFileDlg fileDlg;
3466
3467                 if (owner->view()->available()) {
3468                         string trypath = owner->buffer()->filepath;
3469                         // If directory is writeable, use this as default.
3470                         if (IsDirWriteable(trypath) == 1)
3471                                 initpath = trypath;
3472                 }
3473
3474                 // launches dialog
3475                 ProhibitInput(owner->view());
3476                 fileDlg.SetButton(0, _("Documents"), lyxrc.document_path);
3477                 fileDlg.SetButton(1, _("Examples"),
3478                                   AddPath(system_lyxdir, "examples"));
3479                 filename = fileDlg.Select(_("Select Document to Insert"),
3480                                           initpath, "*.lyx");
3481                 AllowInput(owner->view());
3482
3483                 // check selected filename
3484                 if (filename.empty()) {
3485                         owner->getMiniBuffer()->Set(_("Canceled."));
3486                         return;
3487                 }
3488         }
3489
3490         // get absolute path of file and make sure the filename ends
3491         // with .lyx
3492         filename = MakeAbsPath(filename);
3493         if (!IsLyXFilename(filename))
3494                 filename += ".lyx";
3495
3496         // Inserts document
3497         owner->getMiniBuffer()->Set(_("Inserting document"),
3498                                     MakeDisplayPath(filename), "...");
3499         bool res = owner->view()->insertLyXFile(filename);
3500         if (res) {
3501                 owner->getMiniBuffer()->Set(_("Document"),
3502                                             MakeDisplayPath(filename),
3503                                             _("inserted."));
3504         } else {
3505                 owner->getMiniBuffer()->Set(_("Could not insert document"),
3506                                             MakeDisplayPath(filename));
3507         }
3508 }
3509
3510 void LyXFunc::doImport(string const & argument)
3511 {
3512         string type;
3513         string filename = split(argument, type, ' ');
3514         lyxerr.debug() << "LyXFunc::doImport: " << type
3515                        << " file: " << filename << endl;
3516
3517         if (type == "latex")
3518                 doImportHelper(filename,
3519                                _("Select LaTeX file to import"), "*.tex",
3520                                doImportLaTeX);
3521         else if (type == "ascii")
3522                 doImportHelper(filename,
3523                                _("Select ASCII file to import"), "*.txt",
3524                                doImportASCIIasLines);
3525         else if (type == "asciiparagraph")
3526                 doImportHelper(filename,
3527                                _("Select ASCII file to import"), "*.txt",
3528                                doImportASCIIasParagraphs);
3529         else if (type == "noweb")
3530                 doImportHelper(filename,
3531                                _("Select NoWeb file to import"), "*.nw",
3532                                doImportNoweb);
3533         else if (type == "linuxdoc")
3534                 doImportHelper(filename,
3535                                _("Select LinuxDoc file to import"), "*.doc",
3536                                doImportLinuxDoc);
3537         else
3538                 setErrorMessage(string(N_("Unknown import type: ")) + type);
3539 }
3540
3541 void LyXFunc::reloadBuffer()
3542 {
3543         string fn = owner->buffer()->fileName();
3544         if (bufferlist.close(owner->buffer()))
3545                 owner->view()->buffer(bufferlist.loadLyXFile(fn));
3546 }
3547
3548
3549 void LyXFunc::CloseBuffer()
3550 {
3551         if (bufferlist.close(owner->buffer()) && !quitting) {
3552                 if (bufferlist.empty()) {
3553                         // need this otherwise SEGV may occur while trying to
3554                         // set variables that don't exist
3555                         // since there's no current buffer
3556                         owner->getDialogs()->hideBufferDependent();
3557                 }
3558                 else {
3559                         owner->view()->buffer(bufferlist.first());
3560                 }
3561         }
3562 }
3563
3564
3565 Inset * LyXFunc::getInsetByCode(Inset::Code code)
3566 {
3567         LyXCursor cursor = owner->view()->text->cursor;
3568         Buffer * buffer = owner->view()->buffer();
3569         for (Buffer::inset_iterator it = Buffer::inset_iterator(cursor.par(),
3570                                                                 cursor.pos());
3571              it != buffer->inset_iterator_end(); ++it) {
3572                 if ((*it)->LyxCode() == code)
3573                         return *it;
3574         }
3575         return 0;
3576 }
3577
3578
3579 // Each "owner" should have it's own message method. lyxview and
3580 // the minibuffer would use the minibuffer, but lyxserver would
3581 // send an ERROR signal to its client.  Alejandro 970603
3582 // This func is bit problematic when it comes to NLS, to make the
3583 // lyx servers client be language indepenent we must not translate
3584 // strings sent to this func.
3585 void LyXFunc::setErrorMessage(string const & m) const
3586 {
3587         dispatch_buffer = m;
3588         errorstat = true;
3589 }
3590
3591
3592 void LyXFunc::setMessage(string const & m)
3593 {
3594         dispatch_buffer = m;
3595 }