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