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