src/BufferView_pimpl.C

   1 #include <config.h>
   2
   3 #include <unistd.h>
   4 #include <sys/wait.h>
   5
   6 #ifdef __GNUG__
   7 #pragma implementation
   8 #endif
   9
  10 #include "BufferView_pimpl.h"
  11 #include "WorkArea.h"
  12 #include "lyxscreen.h"
  13 #include "lyxtext.h"
  14 #include "lyxrow.h"
  15 #include "LyXView.h"
  16 #include "commandtags.h"
  17 #include "lyxfunc.h"
  18 #include "minibuffer.h"
  19 #include "font.h"
  20 #include "bufferview_funcs.h"
  21 #include "TextCache.h"
  22 #include "bufferlist.h"
  23 #include "lyx_gui_misc.h"
  24 #include "lyxrc.h"
  25 #include "intl.h"
  26 #include "support/LAssert.h"
  27 #include "frontends/Dialogs.h"
  28 #include "insets/insetbib.h"
  29 #include "insets/insettext.h"
  30 /// added for Dispatch functions
  31 #include "lyx_cb.h"
  32 #include "filedlg.h"
  33 #include "lyx_main.h"
  34 #include "FloatList.h"
  35 #include "support/filetools.h"
  36 #include "support/lyxfunctional.h"
  37 #include "insets/inseturl.h"
  38 #include "insets/insetlatexaccent.h"
  39 #include "insets/insettoc.h"
  40 #include "insets/insetref.h"
  41 #include "insets/insetparent.h"
  42 #include "insets/insetindex.h"
  43 #include "insets/insetinclude.h"
  44 #include "insets/insetcite.h"
  45 #include "insets/insetert.h"
  46 #include "insets/insetexternal.h"
  47 #include "insets/insetgraphics.h"
  48 #include "insets/insetfoot.h"
  49 #include "insets/insetmarginal.h"
  50 #include "insets/insetminipage.h"
  51 #include "insets/insetfloat.h"
  52 #include "insets/insetlist.h"
  53 #include "insets/insettabular.h"
  54 #include "insets/insettheorem.h"
  55 #include "insets/insetcaption.h"
  56 #include "mathed/formulamacro.h"
  57 extern LyXTextClass::size_type current_layout;
  58 extern void math_insert_symbol(BufferView *, string const &);
  59 extern bool math_insert_greek(BufferView *, char);
  60 extern int greek_kb_flag;
  61
  62 #ifdef SIGC_CXX_NAMESPACES
  63 using SigC::slot;
  64 #endif
  65
  66 using std::pair;
  67 using std::endl;
  68 using std::make_pair;
  69 using std::min;
  70
  71 /* the selection possible is needed, that only motion events are
  72  * used, where the bottom press event was on the drawing area too */
  73 bool selection_possible = false;
  74
  75 extern BufferList bufferlist;
  76 extern char ascii_type;
  77
  78 extern void sigchldhandler(pid_t pid, int * status);
  79 extern int bibitemMaxWidth(BufferView *, LyXFont const &);
  80
  81 const unsigned int saved_positions_num = 20;
  82
  83 static inline
  84 void waitForX()
  85 {
  86         XSync(fl_get_display(), 0);
  87 }
  88
  89
  90 static
  91 void SetXtermCursor(Window win)
  92 {
  93         static Cursor cursor;
  94         static bool cursor_undefined = true;
  95         if (cursor_undefined){
  96                 cursor = XCreateFontCursor(fl_get_display(), XC_xterm);
  97                 XFlush(fl_get_display());
  98                 cursor_undefined = false;
  99         }
 100         XDefineCursor(fl_get_display(), win, cursor);
 101         XFlush(fl_get_display());
 102 }
 103
 104
 105 BufferView::Pimpl::Pimpl(BufferView * b, LyXView * o,
 106              int xpos, int ypos, int width, int height)
 107         : bv_(b), owner_(o), cursor_timeout(400)
 108 {
 109         buffer_ = 0;
 110         workarea_ = new WorkArea(xpos, ypos, width, height);
 111         // Setup the signals
 112         workarea_->scrollCB.connect(slot(this, &BufferView::Pimpl::scrollCB));
 113         workarea_->workAreaExpose
 114                 .connect(slot(this, &BufferView::Pimpl::workAreaExpose));
 115         workarea_->workAreaEnter
 116                 .connect(slot(this, &BufferView::Pimpl::enterView));
 117         workarea_->workAreaLeave
 118                 .connect(slot(this, &BufferView::Pimpl::leaveView));
 119         workarea_->workAreaButtonPress
 120                 .connect(slot(this, &BufferView::Pimpl::workAreaButtonPress));
 121         workarea_->workAreaButtonRelease
 122                 .connect(slot(this,
 123                               &BufferView::Pimpl::workAreaButtonRelease));
 124         workarea_->workAreaMotionNotify
 125                 .connect(slot(this, &BufferView::Pimpl::workAreaMotionNotify));
 126         workarea_->workAreaDoubleClick
 127                 .connect(slot(this, &BufferView::Pimpl::doubleClick));
 128         workarea_->workAreaTripleClick
 129                 .connect(slot(this, &BufferView::Pimpl::tripleClick));
 130         workarea_->workAreaKeyPress
 131                 .connect(slot(this, &BufferView::Pimpl::workAreaKeyPress));
 132
 133         screen_ = 0;
 134
 135         cursor_timeout.timeout.connect(slot(this,
 136                                             &BufferView::Pimpl::cursorToggle));
 137         current_scrollbar_value = 0;
 138         cursor_timeout.start();
 139         workarea_->setFocus();
 140         using_xterm_cursor = false;
 141         saved_positions.resize(saved_positions_num);
 142 }
 143
 144
 145 Painter & BufferView::Pimpl::painter()
 146 {
 147         return workarea_->getPainter();
 148 }
 149
 150
 151 void BufferView::Pimpl::buffer(Buffer * b)
 152 {
 153         lyxerr[Debug::INFO] << "Setting buffer in BufferView ("
 154                             << b << ")" << endl;
 155         if (buffer_) {
 156                 bv_->insetSleep();
 157                 buffer_->delUser(bv_);
 158
 159                 // Put the old text into the TextCache, but
 160                 // only if the buffer is still loaded.
 161                 // Also set the owner of the test to 0
 162                 //              bv_->text->owner(0);
 163                 textcache.add(buffer_, workarea_->workWidth(), bv_->text);
 164                 if (lyxerr.debugging())
 165                         textcache.show(lyxerr, "BufferView::buffer");
 166
 167                 bv_->text = 0;
 168         }
 169
 170         // Set current buffer
 171         buffer_ = b;
 172
 173         if (bufferlist.getState() == BufferList::CLOSING) return;
 174
 175         // Nuke old image
 176         // screen is always deleted when the buffer is changed.
 177         delete screen_;
 178         screen_ = 0;
 179
 180         // If we are closing the buffer, use the first buffer as current
 181         if (!buffer_) {
 182                 buffer_ = bufferlist.first();
 183         }
 184
 185         if (buffer_) {
 186                 lyxerr[Debug::INFO] << "Buffer addr: " << buffer_ << endl;
 187                 buffer_->addUser(bv_);
 188                 // If we don't have a text object for this, we make one
 189                 if (bv_->text == 0) {
 190                         resizeCurrentBuffer();
 191                 } else {
 192                         updateScreen();
 193                         updateScrollbar();
 194                 }
 195                 bv_->text->first = screen_->TopCursorVisible(bv_->text);
 196                 owner_->updateMenubar();
 197                 owner_->updateToolbar();
 198                 // Similarly, buffer-dependent dialogs should be updated or
 199                 // hidden. This should go here because some dialogs (eg ToC)
 200                 // require bv_->text.
 201                 owner_->getDialogs()->updateBufferDependent(true);
 202                 redraw();
 203                 bv_->insetWakeup();
 204         } else {
 205                 lyxerr[Debug::INFO] << "  No Buffer!" << endl;
 206                 owner_->updateMenubar();
 207                 owner_->updateToolbar();
 208                 owner_->getDialogs()->hideBufferDependent();
 209                 updateScrollbar();
 210                 workarea_->redraw();
 211
 212                 // Also remove all remaining text's from the testcache.
 213                 // (there should not be any!) (if there is any it is a
 214                 // bug!)
 215                 if (lyxerr.debugging())
 216                         textcache.show(lyxerr, "buffer delete all");
 217                 textcache.clear();
 218         }
 219         // should update layoutchoice even if we don't have a buffer.
 220         owner_->updateLayoutChoice();
 221         owner_->getMiniBuffer()->Init();
 222         owner_->updateWindowTitle();
 223 }
 224
 225
 226 void BufferView::Pimpl::resize(int xpos, int ypos, int width, int height)
 227 {
 228         workarea_->resize(xpos, ypos, width, height);
 229         update(bv_->text, SELECT);
 230         redraw();
 231 }
 232
 233
 234 void BufferView::Pimpl::resize()
 235 {
 236         if (buffer_)
 237                 resizeCurrentBuffer();
 238 }
 239
 240
 241 void BufferView::Pimpl::redraw()
 242 {
 243         lyxerr[Debug::INFO] << "BufferView::redraw()" << endl;
 244         workarea_->redraw();
 245 }
 246
 247
 248 bool BufferView::Pimpl::fitCursor(LyXText * text)
 249 {
 250         Assert(screen_);
 251
 252         bool ret = screen_->FitCursor(text, bv_);
 253         if (ret)
 254             updateScrollbar();
 255         return ret;
 256 }
 257
 258
 259 void BufferView::Pimpl::redoCurrentBuffer()
 260 {
 261         lyxerr[Debug::INFO] << "BufferView::redoCurrentBuffer" << endl;
 262         if (buffer_ && bv_->text) {
 263                 resize();
 264                 owner_->updateLayoutChoice();
 265         }
 266 }
 267
 268
 269 int BufferView::Pimpl::resizeCurrentBuffer()
 270 {
 271         lyxerr[Debug::INFO] << "resizeCurrentBuffer" << endl;
 272
 273         LyXParagraph * par = 0;
 274         LyXParagraph * selstartpar = 0;
 275         LyXParagraph * selendpar = 0;
 276         UpdatableInset * the_locking_inset = 0;
 277
 278         int pos = 0;
 279         int selstartpos = 0;
 280         int selendpos = 0;
 281         int selection = 0;
 282         int mark_set = 0;
 283
 284         ProhibitInput(bv_);
 285
 286         owner_->getMiniBuffer()->Set(_("Formatting document..."));
 287
 288         if (bv_->text) {
 289                 par = bv_->text->cursor.par();
 290                 pos = bv_->text->cursor.pos();
 291                 selstartpar = bv_->text->sel_start_cursor.par();
 292                 selstartpos = bv_->text->sel_start_cursor.pos();
 293                 selendpar = bv_->text->sel_end_cursor.par();
 294                 selendpos = bv_->text->sel_end_cursor.pos();
 295                 selection = bv_->text->selection;
 296                 mark_set = bv_->text->mark_set;
 297                 the_locking_inset = bv_->text->the_locking_inset;
 298                 delete bv_->text;
 299                 bv_->text = new LyXText(bv_);
 300         } else {
 301                 // See if we have a text in TextCache that fits
 302                 // the new buffer_ with the correct width.
 303                 bv_->text = textcache.findFit(buffer_, workarea_->workWidth());
 304                 if (bv_->text) {
 305                         if (lyxerr.debugging()) {
 306                                 lyxerr << "Found a LyXText that fits:\n";
 307                                 textcache.show(lyxerr, make_pair(buffer_, make_pair(workarea_->workWidth(), bv_->text)));
 308                         }
 309                         // Set the owner of the newly found text
 310                         //      bv_->text->owner(bv_);
 311                         if (lyxerr.debugging())
 312                                 textcache.show(lyxerr, "resizeCurrentBuffer");
 313                 } else {
 314                         bv_->text = new LyXText(bv_);
 315                 }
 316         }
 317         updateScreen();
 318
 319         if (par) {
 320                 bv_->text->selection = true;
 321                 /* at this point just to avoid the Delete-Empty-Paragraph
 322                  * Mechanism when setting the cursor */
 323                 bv_->text->mark_set = mark_set;
 324                 if (selection) {
 325                         bv_->text->SetCursor(bv_, selstartpar, selstartpos);
 326                         bv_->text->sel_cursor = bv_->text->cursor;
 327                         bv_->text->SetCursor(bv_, selendpar, selendpos);
 328                         bv_->text->SetSelection(bv_);
 329                         bv_->text->SetCursor(bv_, par, pos);
 330                 } else {
 331                         bv_->text->SetCursor(bv_, par, pos);
 332                         bv_->text->sel_cursor = bv_->text->cursor;
 333                         bv_->text->selection = false;
 334                 }
 335                 // remake the inset locking
 336                 bv_->text->the_locking_inset = the_locking_inset;
 337         }
 338         bv_->text->first = screen_->TopCursorVisible(bv_->text);
 339         buffer_->resizeInsets(bv_);
 340         // this will scroll the screen such that the cursor becomes visible
 341         updateScrollbar();
 342         redraw();
 343         owner_->getMiniBuffer()->Init();
 344         bv_->setState();
 345         AllowInput(bv_);
 346
 347         owner_->getDialogs()->hideSplash();
 348
 349         return 0;
 350 }
 351
 352
 353 void BufferView::Pimpl::updateScreen()
 354 {
 355         // Regenerate the screen.
 356         delete screen_;
 357         screen_ = new LyXScreen(*workarea_);
 358 }
 359
 360
 361 void BufferView::Pimpl::updateScrollbar()
 362 {
 363         /* If the text is smaller than the working area, the scrollbar
 364          * maximum must be the working area height. No scrolling will
 365          * be possible */
 366
 367         if (!buffer_) {
 368                 workarea_->setScrollbar(0, 1.0);
 369                 return;
 370         }
 371
 372         static unsigned long max2 = 0;
 373         static unsigned long height2 = 0;
 374
 375         unsigned long cbth = 0;
 376         long cbsf = 0;
 377
 378         if (bv_->text) {
 379                 cbth = bv_->text->height;
 380                 cbsf = bv_->text->first;
 381         }
 382
 383         // check if anything has changed.
 384         if (max2 == cbth &&
 385             height2 == workarea_->height() &&
 386             current_scrollbar_value == cbsf)
 387                 return; // no
 388         max2 = cbth;
 389         height2 = workarea_->height();
 390         current_scrollbar_value = cbsf;
 391
 392         if (cbth <= height2) { // text is smaller than screen
 393                 workarea_->setScrollbar(0, 1.0); // right?
 394                 return;
 395         }
 396
 397         long maximum_height = workarea_->height() * 3 / 4 + cbth;
 398         long value = cbsf;
 399
 400         // set the scrollbar
 401         double hfloat = workarea_->height();
 402         double maxfloat = maximum_height;
 403
 404         float slider_size = 0.0;
 405         int slider_value = value;
 406
 407         workarea_->setScrollbarBounds(0, bv_->text->height - workarea_->height());
 408         double lineh = bv_->text->DefaultHeight();
 409         workarea_->setScrollbarIncrements(lineh);
 410         if (maxfloat > 0.0) {
 411                 if ((hfloat / maxfloat) * float(height2) < 3)
 412                         slider_size = 3.0/float(height2);
 413                 else
 414                         slider_size = hfloat / maxfloat;
 415         } else
 416                 slider_size = hfloat;
 417
 418         workarea_->setScrollbar(slider_value, slider_size / workarea_->height());
 419 }
 420
 421
 422 // Callback for scrollbar slider
 423 void BufferView::Pimpl::scrollCB(double value)
 424 {
 425         if (!buffer_) return;
 426
 427         current_scrollbar_value = long(value);
 428         if (current_scrollbar_value < 0)
 429                 current_scrollbar_value = 0;
 430
 431         if (!screen_)
 432                 return;
 433
 434         screen_->Draw(bv_->text, bv_, current_scrollbar_value);
 435
 436         if (!lyxrc.cursor_follows_scrollbar) {
 437                 waitForX();
 438                 return;
 439         }
 440
 441         LyXText * vbt = bv_->text;
 442
 443         int const height = vbt->DefaultHeight();
 444         int const first = static_cast<int>((bv_->text->first + height));
 445         int const last = static_cast<int>((bv_->text->first + workarea_->height() - height));
 446
 447         if (vbt->cursor.y() < first)
 448                 vbt->SetCursorFromCoordinates(bv_, 0, first);
 449         else if (vbt->cursor.y() > last)
 450                 vbt->SetCursorFromCoordinates(bv_, 0, last);
 451
 452         waitForX();
 453 }
 454
 455
 456 int BufferView::Pimpl::scrollUp(long time)
 457 {
 458         if (!buffer_) return 0;
 459         if (!screen_) return 0;
 460
 461         double value = workarea_->getScrollbarValue();
 462
 463         if (value == 0) return 0;
 464
 465         float add_value =  (bv_->text->DefaultHeight()
 466                             + float(time) * float(time) * 0.125);
 467
 468         if (add_value > workarea_->height())
 469                 add_value = float(workarea_->height() -
 470                                   bv_->text->DefaultHeight());
 471
 472         value -= add_value;
 473
 474         if (value < 0)
 475                 value = 0;
 476
 477         workarea_->setScrollbarValue(value);
 478
 479         scrollCB(value);
 480         return 0;
 481 }
 482
 483
 484 int BufferView::Pimpl::scrollDown(long time)
 485 {
 486         if (!buffer_) return 0;
 487         if (!screen_) return 0;
 488
 489         double value= workarea_->getScrollbarValue();
 490         pair<float, float> p = workarea_->getScrollbarBounds();
 491         double max = p.second;
 492
 493         if (value == max) return 0;
 494
 495         float add_value =  (bv_->text->DefaultHeight()
 496                             + float(time) * float(time) * 0.125);
 497
 498         if (add_value > workarea_->height())
 499                 add_value = float(workarea_->height() -
 500                                   bv_->text->DefaultHeight());
 501
 502         value += add_value;
 503
 504         if (value > max)
 505                 value = max;
 506
 507         workarea_->setScrollbarValue(value);
 508
 509         scrollCB(value);
 510         return 0;
 511 }
 512
 513
 514 void BufferView::Pimpl::workAreaKeyPress(KeySym keysym, unsigned int state)
 515 {
 516         bv_->owner()->getLyXFunc()->processKeySym(keysym, state);
 517 }
 518
 519
 520 void BufferView::Pimpl::workAreaMotionNotify(int x, int y, unsigned int state)
 521 {
 522         // Only use motion with button 1
 523         if (!(state & Button1MotionMask))
 524                 return;
 525
 526         if (!buffer_ || !screen_) return;
 527
 528         // Check for inset locking
 529         if (bv_->theLockingInset()) {
 530                 LyXCursor cursor = bv_->text->cursor;
 531                 LyXFont font = bv_->text->GetFont(bv_->buffer(),
 532                                                   cursor.par(), cursor.pos());
 533                 int width = bv_->theLockingInset()->width(bv_, font);
 534                 int inset_x = font.isVisibleRightToLeft()
 535                         ? cursor.x() - width : cursor.x();
 536                 int start_x = inset_x + bv_->theLockingInset()->scroll();
 537                 bv_->theLockingInset()->
 538                         InsetMotionNotify(bv_,
 539                                           x - start_x,
 540                                           y - cursor.y() + bv_->text->first,
 541                                           state);
 542                 return;
 543         }
 544
 545         /* The test for not selection possible is needed, that only motion events are
 546          * used, where the bottom press event was on the drawing area too */
 547         if (!selection_possible)
 548                 return;
 549
 550         screen_->HideCursor();
 551
 552         bv_->text->SetCursorFromCoordinates(bv_, x, y + bv_->text->first);
 553
 554         if (!bv_->text->selection)
 555                 update(bv_->text, BufferView::UPDATE); // Maybe an empty line was deleted
 556
 557         bv_->text->SetSelection(bv_);
 558         screen_->ToggleToggle(bv_->text, bv_);
 559         fitCursor(bv_->text);
 560         screen_->ShowCursor(bv_->text, bv_);
 561 }
 562
 563
 564 // Single-click on work area
 565 void BufferView::Pimpl::workAreaButtonPress(int xpos, int ypos,
 566                                             unsigned int button)
 567 {
 568         last_click_x = -1;
 569         last_click_y = -1;
 570
 571         if (!buffer_ || !screen_) return;
 572
 573         Inset * inset_hit = checkInsetHit(bv_->text, xpos, ypos, button);
 574
 575         // ok ok, this is a hack.
 576         if (button == 4 || button == 5) {
 577                 switch (button) {
 578                 case 4:
 579                         scrollUp(lyxrc.wheel_jump); // default 100, set in lyxrc
 580                         break;
 581                 case 5:
 582                         scrollDown(lyxrc.wheel_jump);
 583                         break;
 584                 }
 585         }
 586
 587         if (bv_->theLockingInset()) {
 588                 // We are in inset locking mode
 589
 590                 /* Check whether the inset was hit. If not reset mode,
 591                    otherwise give the event to the inset */
 592                 if (inset_hit == bv_->theLockingInset()) {
 593                         bv_->theLockingInset()->
 594                                 InsetButtonPress(bv_,
 595                                                  xpos, ypos,
 596                                                  button);
 597                         return;
 598                 } else {
 599                         bv_->unlockInset(bv_->theLockingInset());
 600                 }
 601         }
 602
 603         if (!inset_hit)
 604                 selection_possible = true;
 605         screen_->HideCursor();
 606
 607         int const screen_first = bv_->text->first;
 608
 609         // Middle button press pastes if we have a selection
 610         bool paste_internally = false;
 611         if (button == 2
 612             && bv_->text->selection) {
 613                 owner_->getLyXFunc()->Dispatch(LFUN_COPY);
 614                 paste_internally = true;
 615         }
 616
 617         // Clear the selection
 618         screen_->ToggleSelection(bv_->text, bv_);
 619         bv_->text->ClearSelection(bv_);
 620         bv_->text->FullRebreak(bv_);
 621         screen_->Update(bv_->text, bv_);
 622         updateScrollbar();
 623
 624         // Single left click in math inset?
 625         if ((inset_hit != 0) &&
 626             (inset_hit->Editable()==Inset::HIGHLY_EDITABLE)) {
 627                 // Highly editable inset, like math
 628                 UpdatableInset * inset = static_cast<UpdatableInset *>(inset_hit);
 629                 selection_possible = false;
 630                 owner_->updateLayoutChoice();
 631                 owner_->getMiniBuffer()->Set(inset->EditMessage());
 632                 inset->InsetButtonPress(bv_, xpos, ypos, button);
 633                 inset->Edit(bv_, xpos, ypos, button);
 634                 return;
 635         }
 636
 637         // Right click on a footnote flag opens float menu
 638         if (button == 3) {
 639                 selection_possible = false;
 640                 return;
 641         }
 642
 643         if (!inset_hit) // otherwise it was already set in checkInsetHit(...)
 644                 bv_->text->SetCursorFromCoordinates(bv_, xpos, ypos + screen_first);
 645         bv_->text->FinishUndo();
 646         bv_->text->sel_cursor = bv_->text->cursor;
 647         bv_->text->cursor.x_fix(bv_->text->cursor.x());
 648
 649         owner_->updateLayoutChoice();
 650         if (fitCursor(bv_->text)) {
 651                 selection_possible = false;
 652         }
 653
 654         // Insert primary selection with middle mouse
 655         // if there is a local selection in the current buffer,
 656         // insert this
 657         if (button == 2) {
 658                 if (paste_internally)
 659                         owner_->getLyXFunc()->Dispatch(LFUN_PASTE);
 660                 else
 661                         owner_->getLyXFunc()->Dispatch(LFUN_PASTESELECTION,
 662                                                        "paragraph");
 663                 selection_possible = false;
 664                 return;
 665         }
 666 }
 667
 668
 669 void BufferView::Pimpl::doubleClick(int /*x*/, int /*y*/, unsigned int button)
 670 {
 671         // select a word
 672         if (!buffer_)
 673             return;
 674
 675         LyXText * text = bv_->getLyXText();
 676
 677         if (text->bv_owner && bv_->theLockingInset())
 678             return;
 679
 680         if (screen_ && button == 1) {
 681             if (text->bv_owner) {
 682                 screen_->HideCursor();
 683                 screen_->ToggleSelection(text, bv_);
 684                 text->SelectWord(bv_);
 685                 screen_->ToggleSelection(text, bv_, false);
 686             } else {
 687                 text->SelectWord(bv_);
 688             }
 689             /* This will fit the cursor on the screen
 690              * if necessary */
 691             update(text, BufferView::SELECT|BufferView::FITCUR);
 692         }
 693 }
 694
 695
 696 void BufferView::Pimpl::tripleClick(int /*x*/, int /*y*/, unsigned int button)
 697 {
 698         // select a line
 699         if (buffer_)
 700                 return;
 701
 702         LyXText * text = bv_->getLyXText();
 703
 704         if (text->bv_owner && bv_->theLockingInset())
 705             return;
 706
 707         if (screen_ && (button == 1)) {
 708                 screen_->HideCursor();
 709                 screen_->ToggleSelection(text, bv_);
 710                 text->CursorHome(bv_);
 711                 text->sel_cursor = text->cursor;
 712                 text->CursorEnd(bv_);
 713                 text->SetSelection(bv_);
 714                 screen_->ToggleSelection(text, bv_, false);
 715                 /* This will fit the cursor on the screen
 716                  * if necessary */
 717                 update(text, BufferView::SELECT|BufferView::FITCUR);
 718         }
 719 }
 720
 721
 722 void BufferView::Pimpl::enterView()
 723 {
 724         if (active() && available()) {
 725                 SetXtermCursor(workarea_->getWin());
 726                 using_xterm_cursor = true;
 727         }
 728 }
 729
 730
 731 void BufferView::Pimpl::leaveView()
 732 {
 733         if (using_xterm_cursor) {
 734                 XUndefineCursor(fl_get_display(), workarea_->getWin());
 735                 using_xterm_cursor = false;
 736         }
 737 }
 738
 739
 740 void BufferView::Pimpl::workAreaButtonRelease(int x, int y,
 741                                               unsigned int button)
 742 {
 743         if (!buffer_ || !screen_) return;
 744
 745         // If we hit an inset, we have the inset coordinates in these
 746         // and inset_hit points to the inset.  If we do not hit an
 747         // inset, inset_hit is 0, and inset_x == x, inset_y == y.
 748         Inset * inset_hit = checkInsetHit(bv_->text, x, y, button);
 749
 750         if (bv_->theLockingInset()) {
 751                 // We are in inset locking mode.
 752
 753                 /* LyX does a kind of work-area grabbing for insets.
 754                    Only a ButtonPress Event outside the inset will
 755                    force a InsetUnlock. */
 756                 bv_->theLockingInset()->
 757                         InsetButtonRelease(bv_, x, y, button);
 758                 return;
 759         }
 760
 761         selection_possible = false;
 762
 763         if (button >= 2) return;
 764
 765         bv_->setState();
 766         owner_->showState();
 767
 768         // Did we hit an editable inset?
 769         if (inset_hit) {
 770                 // Inset like error, notes and figures
 771                 selection_possible = false;
 772
 773                 // CHECK fix this proper in 0.13
 774
 775                 // Following a ref shouldn't issue
 776                 // a push on the undo-stack
 777                 // anylonger, now that we have
 778                 // keybindings for following
 779                 // references and returning from
 780                 // references.  IMHO though, it
 781                 // should be the inset's own business
 782                 // to push or not push on the undo
 783                 // stack. They don't *have* to
 784                 // alter the document...
 785                 // (Joacim)
 786                 // ...or maybe the SetCursorParUndo()
 787                 // below isn't necessary at all anylonger?
 788                 if (inset_hit->LyxCode() == Inset::REF_CODE) {
 789                         bv_->text->SetCursorParUndo(bv_->buffer());
 790                 }
 791
 792                 owner_->getMiniBuffer()->Set(inset_hit->EditMessage());
 793                 if (inset_hit->Editable()==Inset::HIGHLY_EDITABLE) {
 794                         // Highly editable inset, like math
 795                         UpdatableInset *inset = (UpdatableInset *)inset_hit;
 796                         inset->InsetButtonRelease(bv_, x, y, button);
 797                 } else {
 798                         inset_hit->InsetButtonRelease(bv_, x, y, button);
 799                         inset_hit->Edit(bv_, x, y, button);
 800                 }
 801                 return;
 802         }
 803
 804         // check whether we want to open a float
 805         if (bv_->text) {
 806                 bool hit = false;
 807                 char c = ' ';
 808                 if (bv_->text->cursor.pos() <
 809                     bv_->text->cursor.par()->Last()) {
 810                         c = bv_->text->cursor.par()->
 811                                 GetChar(bv_->text->cursor.pos());
 812                 }
 813 #ifndef NEW_INSETS
 814                if(!bv_->text->selection)
 815                 if (c == LyXParagraph::META_FOOTNOTE
 816                     || c == LyXParagraph::META_MARGIN
 817                     || c == LyXParagraph::META_FIG
 818                     || c == LyXParagraph::META_TAB
 819                     || c == LyXParagraph::META_WIDE_FIG
 820                     || c == LyXParagraph::META_WIDE_TAB
 821                     || c == LyXParagraph::META_ALGORITHM){
 822                         hit = true;
 823                 } else
 824 #endif
 825                         if (bv_->text->cursor.pos() - 1 >= 0) {
 826                         c = bv_->text->cursor.par()->
 827                                 GetChar(bv_->text->cursor.pos() - 1);
 828 #ifndef NEW_INSETS
 829                         if (c == LyXParagraph::META_FOOTNOTE
 830                             || c == LyXParagraph::META_MARGIN
 831                             || c == LyXParagraph::META_FIG
 832                             || c == LyXParagraph::META_TAB
 833                             || c == LyXParagraph::META_WIDE_FIG
 834                             || c == LyXParagraph::META_WIDE_TAB
 835                             || c == LyXParagraph::META_ALGORITHM){
 836                                 // We are one step too far to the right
 837                                 bv_->text->CursorLeft(bv_);
 838                                 hit = true;
 839                         }
 840 #endif
 841                 }
 842                 if (hit == true) {
 843 #ifndef NEW_INSETS
 844                         bv_->toggleFloat();
 845 #endif
 846                         selection_possible = false;
 847                         return;
 848                 }
 849         }
 850
 851 #ifndef NEW_INSETS
 852         // Do we want to close a float? (click on the float-label)
 853         if (bv_->text->cursor.row()->par()->footnoteflag ==
 854             LyXParagraph::OPEN_FOOTNOTE
 855             && bv_->text->cursor.row()->previous() &&
 856             bv_->text->cursor.row()->previous()->par()->
 857             footnoteflag != LyXParagraph::OPEN_FOOTNOTE){
 858                 LyXFont font(LyXFont::ALL_SANE);
 859                 font.setSize(LyXFont::SIZE_FOOTNOTE);
 860
 861                 int box_x = 20; // LYX_PAPER_MARGIN;
 862                 box_x += lyxfont::width(" wide-tab ", font);
 863
 864                 unsigned int screen_first = bv_->text->first;
 865
 866                 if (x < box_x
 867                     && y + screen_first > bv_->text->cursor.y() -
 868                     bv_->text->cursor.row()->baseline()
 869                     && y + screen_first < bv_->text->cursor.y() -
 870                     bv_->text->cursor.row()->baseline()
 871                     + lyxfont::maxAscent(font) * 1.2 + lyxfont::maxDescent(font) * 1.2) {
 872                         bv_->toggleFloat();
 873                         selection_possible = false;
 874                         return;
 875                 }
 876         }
 877 #endif
 878
 879         // Maybe we want to edit a bibitem ale970302
 880         if (bv_->text->cursor.par()->bibkey && x < 20 +
 881             bibitemMaxWidth(bv_, textclasslist.
 882                             TextClass(buffer_->
 883                                       params.textclass).defaultfont())) {
 884                 bv_->text->cursor.par()->bibkey->Edit(bv_, 0, 0, 0);
 885         }
 886
 887         return;
 888 }
 889
 890
 891 /*
 892  * Returns an inset if inset was hit. 0 otherwise.
 893  * If hit, the coordinates are changed relative to the inset.
 894  * Otherwise coordinates are not changed, and false is returned.
 895  */
 896 Inset * BufferView::Pimpl::checkInsetHit(LyXText * text, int & x, int & y,
 897                                          unsigned int /* button */)
 898 {
 899         if (!screen_)
 900                 return 0;
 901
 902         int y_tmp = y + text->first;
 903
 904         LyXCursor cursor;
 905         text->SetCursorFromCoordinates(bv_, cursor, x, y_tmp);
 906
 907         if (cursor.pos() < cursor.par()->Last()
 908             && cursor.par()->GetChar(cursor.pos()) == LyXParagraph::META_INSET
 909             && cursor.par()->GetInset(cursor.pos())
 910             && cursor.par()->GetInset(cursor.pos())->Editable()) {
 911
 912                 // Check whether the inset really was hit
 913                 Inset * tmpinset = cursor.par()->GetInset(cursor.pos());
 914                 LyXFont font = text->GetFont(bv_->buffer(),
 915                                                   cursor.par(), cursor.pos());
 916                 int width = tmpinset->width(bv_, font);
 917                 int inset_x = font.isVisibleRightToLeft()
 918                         ? cursor.x() - width : cursor.x();
 919                 int start_x = inset_x + tmpinset->scroll();
 920                 int end_x = inset_x + width;
 921
 922                 if (x > start_x && x < end_x
 923                     && y_tmp > cursor.y() - tmpinset->ascent(bv_, font)
 924                     && y_tmp < cursor.y() + tmpinset->descent(bv_, font)) {
 925                         text->SetCursor(bv_, cursor.par(),cursor.pos(),true);
 926                         x = x - start_x;
 927                         // The origin of an inset is on the baseline
 928                         y = y_tmp - (text->cursor.y());
 929                         return tmpinset;
 930                 }
 931         }
 932
 933         if ((cursor.pos() - 1 >= 0) &&
 934             (cursor.par()->GetChar(cursor.pos()-1) == LyXParagraph::META_INSET) &&
 935             (cursor.par()->GetInset(cursor.pos() - 1)) &&
 936             (cursor.par()->GetInset(cursor.pos() - 1)->Editable())) {
 937                 Inset * tmpinset = cursor.par()->GetInset(cursor.pos()-1);
 938                 LyXFont font = text->GetFont(bv_->buffer(), cursor.par(),
 939                                                   cursor.pos()-1);
 940                 int width = tmpinset->width(bv_, font);
 941                 int inset_x = font.isVisibleRightToLeft()
 942                         ? cursor.x() : cursor.x() - width;
 943                 int start_x = inset_x + tmpinset->scroll();
 944                 int end_x = inset_x + width;
 945
 946                 if (x > start_x && x < end_x
 947                     && y_tmp > cursor.y() - tmpinset->ascent(bv_, font)
 948                     && y_tmp < cursor.y() + tmpinset->descent(bv_, font)) {
 949 #if 0
 950                         if (move_cursor && (tmpinset != bv_->theLockingInset()))
 951 #endif
 952                                 text->SetCursor(bv_, cursor.par(),cursor.pos()-1,true);
 953                         x = x - start_x;
 954                         // The origin of an inset is on the baseline
 955                         y = y_tmp - (text->cursor.y());
 956                         return tmpinset;
 957                 }
 958         }
 959         return 0;
 960 }
 961
 962
 963 void BufferView::Pimpl::workAreaExpose()
 964 {
 965         static int work_area_width = 0;
 966         static unsigned int work_area_height = 0;
 967
 968         bool widthChange = workarea_->workWidth() != work_area_width;
 969         bool heightChange = workarea_->height() != work_area_height;
 970
 971         // update from work area
 972         work_area_width = workarea_->workWidth();
 973         work_area_height = workarea_->height();
 974         if (buffer_ != 0) {
 975                 if (widthChange) {
 976                         // All buffers need a resize
 977                         bufferlist.resize();
 978
 979                         // Remove all texts from the textcache
 980                         // This is not _really_ what we want to do. What
 981                         // we really want to do is to delete in textcache
 982                         // that does not have a BufferView with matching
 983                         // width, but as long as we have only one BufferView
 984                         // deleting all gives the same result.
 985                         if (lyxerr.debugging())
 986                                 textcache.show(lyxerr, "Expose delete all");
 987                         textcache.clear();
 988                 } else if (heightChange) {
 989                         // Rebuild image of current screen
 990                         updateScreen();
 991                         // fitCursor() ensures we don't jump back
 992                         // to the start of the document on vertical
 993                         // resize
 994                         fitCursor(bv_->text);
 995
 996                         // The main window size has changed, repaint most stuff
 997                         redraw();
 998                         // ...including the minibuffer
 999                         owner_->getMiniBuffer()->Init();
1000
1001                 } else if (screen_)
1002                     screen_->Redraw(bv_->text, bv_);
1003         } else {
1004                 // Grey box when we don't have a buffer
1005                 workarea_->greyOut();
1006         }
1007
1008         // always make sure that the scrollbar is sane.
1009         updateScrollbar();
1010         owner_->updateLayoutChoice();
1011         return;
1012 }
1013
1014
1015 void BufferView::Pimpl::update()
1016 {
1017         if (screen_) screen_->Update(bv_->text, bv_);
1018 }
1019
1020 // Values used when calling update:
1021 // -3 - update
1022 // -2 - update, move sel_cursor if selection, fitcursor
1023 // -1 - update, move sel_cursor if selection, fitcursor, mark dirty
1024 //  0 - update, move sel_cursor if selection, fitcursor
1025 //  1 - update, move sel_cursor if selection, fitcursor, mark dirty
1026 //  3 - update, move sel_cursor if selection
1027 //
1028 // update -
1029 // a simple redraw of the parts that need refresh
1030 //
1031 // move sel_cursor if selection -
1032 // the text's sel_cursor is moved if there is selection is progress
1033 //
1034 // fitcursor -
1035 // fitCursor() is called and the scrollbar updated
1036 //
1037 // mark dirty -
1038 // the buffer is marked dirty.
1039 //
1040 // enum {
1041 //       UPDATE = 0,
1042 //       SELECT = 1,
1043 //       FITCUR = 2,
1044 //       CHANGE = 4
1045 // };
1046 //
1047 // UPDATE_ONLY = UPDATE;
1048 // UPDATE_SELECT = UPDATE | SELECT;
1049 // UPDATE_SELECT_MOVE = UPDATE | SELECT | FITCUR;
1050 // UPDATE_SELECT_MOVE_AFTER_CHANGE = UPDATE | SELECT | FITCUR | CHANGE;
1051 //
1052 // update(-3) -> update(0)         -> update(0) -> update(UPDATE)
1053 // update(-2) -> update(1 + 2)     -> update(3) -> update(SELECT|FITCUR)
1054 // update(-1) -> update(1 + 2 + 4) -> update(7) -> update(SELECT|FITCUR|CHANGE)
1055 // update(1)  -> update(1 + 2 + 4) -> update(7) -> update(SELECT|FITCUR|CHANGE)
1056 // update(3)  -> update(1)         -> update(1) -> update(SELECT)
1057
1058 void BufferView::Pimpl::update(LyXText * text, BufferView::UpdateCodes f)
1059 {
1060         owner_->updateLayoutChoice();
1061
1062         if (!text->selection && (f & SELECT)) {
1063                 text->sel_cursor = text->cursor;
1064         }
1065
1066         text->FullRebreak(bv_);
1067
1068         if (text->inset_owner) {
1069             text->inset_owner->SetUpdateStatus(bv_, InsetText::NONE);
1070             bv_->updateInset(text->inset_owner, true);
1071         } else
1072             update();
1073
1074         if ((f & FITCUR)) {
1075                 fitCursor(text);
1076         }
1077
1078         if ((f & CHANGE)) {
1079                 if (buffer_->isLyxClean()) {
1080                         buffer_->markDirty();
1081                         owner_->getMiniBuffer()->setTimer(4);
1082                 } else {
1083                         buffer_->markDirty();
1084                 }
1085         }
1086 }
1087
1088
1089 // Callback for cursor timer
1090 void BufferView::Pimpl::cursorToggle()
1091 {
1092         // Quite a nice place for asyncron Inset updating, isn't it?
1093         // Actually no! This is run even if no buffer exist... so (Lgb)
1094         if (!buffer_) {
1095                 cursor_timeout.restart();
1096                 return;
1097         }
1098
1099         int status = 1;
1100         int pid = waitpid(static_cast<pid_t>(0), &status, WNOHANG);
1101         if (pid == -1) // error find out what is wrong
1102                 ; // ignore it for now.
1103         else if (pid > 0)
1104                 sigchldhandler(pid, &status);
1105
1106         updatelist.update(bv_);
1107
1108         if (!screen_) {
1109                 cursor_timeout.restart();
1110                 return;
1111         }
1112
1113         if (!bv_->theLockingInset()) {
1114                 screen_->CursorToggle(bv_->text, bv_);
1115         } else {
1116                 bv_->theLockingInset()->ToggleInsetCursor(bv_);
1117         }
1118
1119         cursor_timeout.restart();
1120 }
1121
1122
1123 void BufferView::Pimpl::cursorPrevious(LyXText * text)
1124 {
1125         if (!text->cursor.row()->previous())
1126                 return;
1127
1128         int y = text->first;
1129         if (text->inset_owner)
1130                 y += bv_->text->first;
1131         Row * cursorrow = text->cursor.row();
1132         text->SetCursorFromCoordinates(bv_, bv_->text->cursor.x_fix(), y);
1133         bv_->text->FinishUndo();
1134         // This is to allow jumping over large insets
1135         if ((cursorrow == text->cursor.row()))
1136                 text->CursorUp(bv_);
1137
1138         if (text->inset_owner ||
1139             text->cursor.row()->height() < workarea_->height())
1140                 screen_->Draw(bv_->text, bv_,
1141                               text->cursor.y()
1142                               - text->cursor.row()->baseline()
1143                               + text->cursor.row()->height()
1144                               - workarea_->height() + 1 );
1145         updateScrollbar();
1146 }
1147
1148
1149 void BufferView::Pimpl::cursorNext(LyXText * text)
1150 {
1151         if (!text->cursor.row()->next())
1152                 return;
1153
1154         int y = text->first + workarea_->height();
1155 //      if (text->inset_owner)
1156 //              y += bv_->text->first;
1157         text->GetRowNearY(y);
1158
1159         Row * cursorrow = text->cursor.row();
1160         text->SetCursorFromCoordinates(bv_, text->cursor.x_fix(), y); // + workarea_->height());
1161         bv_->text->FinishUndo();
1162         // This is to allow jumping over large insets
1163         if ((cursorrow == bv_->text->cursor.row()))
1164                 text->CursorDown(bv_);
1165
1166         if (text->inset_owner ||
1167             text->cursor.row()->height() < workarea_->height())
1168                 screen_->Draw(bv_->text, bv_, text->cursor.y() -
1169                               text->cursor.row()->baseline());
1170         updateScrollbar();
1171 }
1172
1173
1174 bool BufferView::Pimpl::available() const
1175 {
1176         if (buffer_ && bv_->text) return true;
1177         return false;
1178 }
1179
1180
1181 void BufferView::Pimpl::beforeChange(LyXText * text)
1182 {
1183         toggleSelection();
1184         text->ClearSelection(bv_);
1185 }
1186
1187
1188 void BufferView::Pimpl::savePosition(unsigned int i)
1189 {
1190         if (i >= saved_positions_num)
1191                 return;
1192         saved_positions[i] = Position(buffer_->fileName(),
1193                                       bv_->text->cursor.par()->id(),
1194                                       bv_->text->cursor.pos());
1195         if (i > 0)
1196                 owner_->getMiniBuffer()->Set(_("Saved bookmark ") + tostr(i));
1197 }
1198
1199
1200 void BufferView::Pimpl::restorePosition(unsigned int i)
1201 {
1202         if (i >= saved_positions_num)
1203                 return;
1204
1205         string fname = saved_positions[i].filename;
1206
1207         beforeChange(bv_->text);
1208
1209         if (fname != buffer_->fileName()) {
1210                 Buffer * b = bufferlist.exists(fname) ?
1211                         bufferlist.getBuffer(fname) :
1212                         bufferlist.loadLyXFile(fname); // don't ask, just load it
1213                 if (b != 0 ) buffer(b);
1214         }
1215
1216         LyXParagraph * par = bv_->text->GetParFromID(saved_positions[i].par_id);
1217         if (!par)
1218                 return;
1219
1220         bv_->text->SetCursor(bv_, par,
1221                              min(par->Last(), saved_positions[i].par_pos));
1222         update(bv_->text, BufferView::SELECT|BufferView::FITCUR);
1223         if (i > 0)
1224                 owner_->getMiniBuffer()->Set(_("Moved to bookmark ") + tostr(i));
1225 }
1226
1227
1228 bool BufferView::Pimpl::isSavedPosition(unsigned int i)
1229 {
1230         if (i >= saved_positions_num)
1231                 return false;
1232
1233         return !saved_positions[i].filename.empty();
1234 }
1235
1236
1237 void BufferView::Pimpl::setState()
1238 {
1239         if (!lyxrc.rtl_support)
1240                 return;
1241
1242         LyXText * text = bv_->getLyXText();
1243         if (text->real_current_font.isRightToLeft() &&
1244             text->real_current_font.latex() != LyXFont::ON) {
1245                 if (owner_->getIntl()->primarykeymap)
1246                         owner_->getIntl()->KeyMapSec();
1247         } else {
1248                 if (!owner_->getIntl()->primarykeymap)
1249                         owner_->getIntl()->KeyMapPrim();
1250         }
1251 }
1252
1253
1254 void BufferView::Pimpl::insetSleep()
1255 {
1256         if (bv_->theLockingInset() && !bv_->inset_slept) {
1257                 bv_->theLockingInset()->GetCursorPos(bv_, bv_->slx, bv_->sly);
1258                 bv_->theLockingInset()->InsetUnlock(bv_);
1259                 bv_->inset_slept = true;
1260         }
1261 }
1262
1263
1264 void BufferView::Pimpl::insetWakeup()
1265 {
1266         if (bv_->theLockingInset() && bv_->inset_slept) {
1267                 bv_->theLockingInset()->Edit(bv_, bv_->slx, bv_->sly, 0);
1268                 bv_->inset_slept = false;
1269         }
1270 }
1271
1272
1273 void BufferView::Pimpl::insetUnlock()
1274 {
1275         if (bv_->theLockingInset()) {
1276                 if (!bv_->inset_slept)
1277                         bv_->theLockingInset()->InsetUnlock(bv_);
1278                 bv_->theLockingInset(0);
1279                 bv_->text->FinishUndo();
1280                 bv_->inset_slept = false;
1281         }
1282 }
1283
1284
1285 bool BufferView::Pimpl::focus() const
1286 {
1287         return workarea_->hasFocus();
1288 }
1289
1290
1291 void BufferView::Pimpl::focus(bool f)
1292 {
1293         if (f) workarea_->setFocus();
1294 }
1295
1296
1297 bool BufferView::Pimpl::active() const
1298 {
1299         return workarea_->active();
1300 }
1301
1302
1303 bool BufferView::Pimpl::belowMouse() const
1304 {
1305         return workarea_->belowMouse();
1306 }
1307
1308
1309 void BufferView::Pimpl::showCursor()
1310 {
1311         if (screen_)
1312                 screen_->ShowCursor(bv_->text, bv_);
1313 }
1314
1315
1316 void BufferView::Pimpl::hideCursor()
1317 {
1318         if (screen_)
1319                 screen_->HideCursor();
1320 }
1321
1322
1323 void BufferView::Pimpl::toggleSelection(bool b)
1324 {
1325         if (screen_)
1326                 screen_->ToggleSelection(bv_->text, bv_, b);
1327 }
1328
1329
1330 void BufferView::Pimpl::toggleToggle()
1331 {
1332         if (screen_)
1333                 screen_->ToggleToggle(bv_->text, bv_);
1334 }
1335
1336
1337 void BufferView::Pimpl::center()
1338 {
1339         beforeChange(bv_->text);
1340         if (bv_->text->cursor.y() > static_cast<int>((workarea_->height() / 2))) {
1341                 screen_->Draw(bv_->text, bv_, bv_->text->cursor.y() - workarea_->height() / 2);
1342         } else {
1343                 screen_->Draw(bv_->text, bv_, 0);
1344         }
1345         update(bv_->text, BufferView::SELECT|BufferView::FITCUR);
1346         redraw();
1347 }
1348
1349
1350 void BufferView::Pimpl::pasteClipboard(bool asPara)
1351 {
1352         if (!buffer_) return;
1353
1354         screen_->HideCursor();
1355         beforeChange(bv_->text);
1356
1357         string const clip(workarea_->getClipboard());
1358
1359         if (clip.empty()) return;
1360
1361         if (asPara) {
1362                 bv_->text->InsertStringB(bv_, clip);
1363         } else {
1364                 bv_->text->InsertStringA(bv_, clip);
1365         }
1366         update(bv_->text, BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
1367 }
1368
1369
1370 void BufferView::Pimpl::stuffClipboard(string const & stuff) const
1371 {
1372         workarea_->putClipboard(stuff);
1373 }
1374
1375
1376 /*
1377  * Dispatch functions for actions which can be valid for BufferView->text
1378  * and/or InsetText->text!!!
1379  */
1380 static LyXText * TEXT(BufferView * bv) { return bv->getLyXText(); }
1381
1382 inline
1383 void BufferView::Pimpl::moveCursorUpdate(bool selecting)
1384 {
1385         if (selecting || TEXT(bv_)->mark_set) {
1386                 TEXT(bv_)->SetSelection(bv_);
1387                 if (TEXT(bv_)->bv_owner)
1388                         bv_->toggleToggle();
1389         }
1390         update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR);
1391         showCursor();
1392
1393         /* ---> Everytime the cursor is moved, show the current font state. */
1394         // should this too me moved out of this func?
1395         //owner->showState();
1396         bv_->setState();
1397 }
1398
1399
1400 Inset * BufferView::Pimpl::getInsetByCode(Inset::Code code)
1401 {
1402         LyXCursor cursor = TEXT(bv_)->cursor;
1403         Buffer::inset_iterator it =
1404                 find_if(Buffer::inset_iterator(
1405                         cursor.par(), cursor.pos()),
1406                         buffer_->inset_iterator_end(),
1407                         compare_memfun(&Inset::LyxCode, code)
1408                         );
1409         return it != buffer_->inset_iterator_end() ? (*it) : 0;
1410 }
1411
1412
1413 void BufferView::Pimpl::MenuInsertLyXFile(string const & filen)
1414 {
1415         string filename = filen;
1416
1417         if (filename.empty()) {
1418                 // Launch a file browser
1419                 string initpath = lyxrc.document_path;
1420                 LyXFileDlg fileDlg;
1421
1422                 if (available()) {
1423                         string const trypath = owner_->buffer()->filepath;
1424                         // If directory is writeable, use this as default.
1425                         if (IsDirWriteable(trypath) == 1)
1426                                 initpath = trypath;
1427                 }
1428
1429                 // launches dialog
1430                 ProhibitInput(bv_);
1431                 fileDlg.SetButton(0, _("Documents"), lyxrc.document_path);
1432                 fileDlg.SetButton(1, _("Examples"),
1433                                   AddPath(system_lyxdir, "examples"));
1434                 filename = fileDlg.Select(_("Select Document to Insert"),
1435                                           initpath, "*.lyx");
1436                 AllowInput(bv_);
1437
1438                 // check selected filename
1439                 if (filename.empty()) {
1440                         owner_->getMiniBuffer()->Set(_("Canceled."));
1441                         return;
1442                 }
1443         }
1444
1445         // get absolute path of file and make sure the filename ends
1446         // with .lyx
1447         filename = MakeAbsPath(filename);
1448         if (!IsLyXFilename(filename))
1449                 filename += ".lyx";
1450
1451         // Inserts document
1452         owner_->getMiniBuffer()->Set(_("Inserting document"),
1453                                      MakeDisplayPath(filename), "...");
1454         bool const res = bv_->insertLyXFile(filename);
1455         if (res) {
1456                 owner_->getMiniBuffer()->Set(_("Document"),
1457                                              MakeDisplayPath(filename),
1458                                              _("inserted."));
1459         } else {
1460                 owner_->getMiniBuffer()->Set(_("Could not insert document"),
1461                                              MakeDisplayPath(filename));
1462         }
1463 }
1464
1465
1466 bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
1467 {
1468         switch (action) {
1469                 // --- Misc -------------------------------------------
1470         case LFUN_APPENDIX:
1471                 if (available()) {
1472                         TEXT(bv_)->toggleAppendix(bv_);
1473                         update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
1474                 }
1475                 break;
1476
1477         case LFUN_TOC_INSERT:
1478         case LFUN_LOA_INSERT:
1479         case LFUN_LOF_INSERT:
1480         case LFUN_LOT_INSERT:
1481         {
1482                 InsetCommandParams p;
1483
1484                 if (action == LFUN_TOC_INSERT )
1485                         p.setCmdName( "tableofcontents" );
1486                 else if (action == LFUN_LOA_INSERT )
1487                         p.setCmdName( "listofalgorithms" );
1488                 else if (action == LFUN_LOF_INSERT )
1489                         p.setCmdName( "listoffigures" );
1490                 else
1491                         p.setCmdName( "listoftables" );
1492
1493                 Inset * inset = new InsetTOC( p );
1494                 if (!bv_->insertInset( inset, "Standard", true ) )
1495                         delete inset;
1496                 break;
1497         }
1498
1499         case LFUN_TABULAR_FEATURE:
1500         case LFUN_SCROLL_INSET:
1501                 // this is not handled here as this funktion is only aktive
1502                 // if we have a locking_inset and that one is (or contains)
1503                 // a tabular-inset
1504                 break;
1505
1506         case LFUN_INSET_GRAPHICS:
1507         {
1508                 Inset * new_inset = new InsetGraphics;
1509                 if (!bv_->insertInset(new_inset)) {
1510                         delete new_inset;
1511                 } else {
1512                         // this is need because you don't use a inset->Edit()
1513                         bv_->updateInset(new_inset, true);
1514                         new_inset->Edit(bv_, 0, 0, 0);
1515                 }
1516                 break;
1517         }
1518
1519         case LFUN_PASTE:
1520                 bv_->paste();
1521                 setState();
1522                 break;
1523
1524         case LFUN_PASTESELECTION:
1525         {
1526                 bool asPara = false;
1527                 if (argument == "paragraph") asPara = true;
1528                 pasteClipboard(asPara);
1529         }
1530         break;
1531
1532         case LFUN_CUT:
1533                 bv_->cut();
1534                 break;
1535
1536         case LFUN_COPY:
1537                 bv_->copy();
1538                 break;
1539
1540         case LFUN_LAYOUT_COPY:
1541                 bv_->copyEnvironment();
1542                 break;
1543
1544         case LFUN_LAYOUT_PASTE:
1545                 bv_->pasteEnvironment();
1546                 setState();
1547                 break;
1548
1549         case LFUN_GOTOERROR:
1550                 bv_->gotoInset(Inset::ERROR_CODE, false);
1551                 break;
1552
1553         case LFUN_GOTONOTE:
1554                 bv_->gotoInset(Inset::IGNORE_CODE, false);
1555                 break;
1556
1557         case LFUN_REFERENCE_GOTO:
1558         {
1559                 vector<Inset::Code> tmp;
1560                 tmp.push_back(Inset::LABEL_CODE);
1561                 tmp.push_back(Inset::REF_CODE);
1562                 bv_->gotoInset(tmp, true);
1563                 break;
1564         }
1565
1566         case LFUN_HYPHENATION:
1567                 bv_->hyphenationPoint();
1568                 break;
1569
1570         case LFUN_LDOTS:
1571                 bv_->ldots();
1572                 break;
1573
1574         case LFUN_END_OF_SENTENCE:
1575                 bv_->endOfSentenceDot();
1576                 break;
1577
1578         case LFUN_MENU_SEPARATOR:
1579                 bv_->menuSeparator();
1580                 break;
1581
1582         case LFUN_HFILL:
1583                 bv_->hfill();
1584                 break;
1585
1586         case LFUN_DEPTH:
1587                 changeDepth(bv_, TEXT(bv_), 0);
1588                 break;
1589
1590         case LFUN_DEPTH_MIN:
1591                 changeDepth(bv_, TEXT(bv_), -1);
1592                 break;
1593
1594         case LFUN_DEPTH_PLUS:
1595                 changeDepth(bv_, TEXT(bv_), 1);
1596                 break;
1597
1598         case LFUN_FREE:
1599                 Free(bv_);
1600                 setState();
1601                 owner_->showState();
1602                 break;
1603
1604         case LFUN_TEX:
1605                 Tex(bv_);
1606                 setState();
1607                 owner_->showState();
1608                 break;
1609
1610         case LFUN_FILE_INSERT:
1611         {
1612                 MenuInsertLyXFile(argument);
1613         }
1614         break;
1615
1616         case LFUN_FILE_INSERT_ASCII:
1617         {
1618                 bool asPara = (argument == "paragraph");
1619                 InsertAsciiFile(bv_, string(), asPara);
1620         }
1621         break;
1622
1623         case LFUN_LAYOUT:
1624         {
1625                 lyxerr.debug() << "LFUN_LAYOUT: (arg) "
1626                                << argument << endl;
1627
1628                 // Derive layout number from given argument (string)
1629                 // and current buffer's textclass (number). */
1630                 LyXTextClassList::ClassList::size_type tclass =
1631                         buffer_->params.textclass;
1632                 pair <bool, LyXTextClass::size_type> layout =
1633                         textclasslist.NumberOfLayout(tclass, argument);
1634
1635                 // If the entry is obsolete, use the new one instead.
1636                 if (layout.first) {
1637                         string obs = textclasslist.Style(tclass,layout.second)
1638                                 .obsoleted_by();
1639                         if (!obs.empty())
1640                                 layout =
1641                                         textclasslist.NumberOfLayout(tclass, obs);
1642                 }
1643
1644                 // see if we found the layout number:
1645                 if (!layout.first) {
1646                         owner_->getLyXFunc()->setErrorMessage(
1647                                 string(N_("Layout ")) + argument +
1648                                 N_(" not known"));
1649                         break;
1650                 }
1651
1652                 if (current_layout != layout.second) {
1653                         hideCursor();
1654                         current_layout = layout.second;
1655                         update(TEXT(bv_),
1656                                BufferView::SELECT|BufferView::FITCUR);
1657                         TEXT(bv_)->SetLayout(bv_, layout.second);
1658                         owner_->setLayout(layout.second);
1659                         update(TEXT(bv_),
1660                                BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
1661                         setState();
1662                 }
1663         }
1664         break;
1665
1666         case LFUN_LANGUAGE:
1667                 Lang(bv_, argument);
1668                 setState();
1669                 owner_->showState();
1670                 break;
1671
1672         case LFUN_EMPH:
1673                 Emph(bv_);
1674                 owner_->showState();
1675                 break;
1676
1677         case LFUN_BOLD:
1678                 Bold(bv_);
1679                 owner_->showState();
1680                 break;
1681
1682         case LFUN_NOUN:
1683                 Noun(bv_);
1684                 owner_->showState();
1685                 break;
1686
1687         case LFUN_CODE:
1688                 Code(bv_);
1689                 owner_->showState();
1690                 break;
1691
1692         case LFUN_SANS:
1693                 Sans(bv_);
1694                 owner_->showState();
1695                 break;
1696
1697         case LFUN_ROMAN:
1698                 Roman(bv_);
1699                 owner_->showState();
1700                 break;
1701
1702         case LFUN_DEFAULT:
1703                 StyleReset(bv_);
1704                 owner_->showState();
1705                 break;
1706
1707         case LFUN_UNDERLINE:
1708                 Underline(bv_);
1709                 owner_->showState();
1710                 break;
1711
1712         case LFUN_FONT_SIZE:
1713                 FontSize(bv_, argument);
1714                 owner_->showState();
1715                 break;
1716
1717         case LFUN_FONT_STATE:
1718                 owner_->getLyXFunc()->setMessage(CurrentState(bv_));
1719                 break;
1720
1721         case LFUN_UPCASE_WORD:
1722                 update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR);
1723                 TEXT(bv_)->ChangeWordCase(bv_, LyXText::text_uppercase);
1724                 if (TEXT(bv_)->inset_owner)
1725                         bv_->updateInset(TEXT(bv_)->inset_owner, true);
1726                 update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
1727                 break;
1728
1729         case LFUN_LOWCASE_WORD:
1730                 update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR);
1731                 TEXT(bv_)->ChangeWordCase(bv_, LyXText::text_lowercase);
1732                 if (TEXT(bv_)->inset_owner)
1733                         bv_->updateInset(TEXT(bv_)->inset_owner, true);
1734                 update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
1735                 break;
1736
1737         case LFUN_CAPITALIZE_WORD:
1738                 update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR);
1739                 TEXT(bv_)->ChangeWordCase(bv_,
1740                                              LyXText::text_capitalization);
1741                 if (TEXT(bv_)->inset_owner)
1742                         bv_->updateInset(TEXT(bv_)->inset_owner, true);
1743                 update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
1744                 break;
1745
1746         case LFUN_INSERT_LABEL:
1747                 MenuInsertLabel(bv_, argument);
1748                 break;
1749
1750         case LFUN_REF_INSERT:
1751                 if (argument.empty()) {
1752                         InsetCommandParams p("ref");
1753                         owner_->getDialogs()->createRef(p.getAsString());
1754                 } else {
1755                         InsetCommandParams p;
1756                         p.setFromString(argument);
1757
1758                         InsetRef * inset = new InsetRef(p, *buffer_);
1759                         if (!bv_->insertInset(inset))
1760                                 delete inset;
1761                         else
1762                                 bv_->updateInset(inset, true);
1763                 }
1764                 break;
1765
1766         case LFUN_BOOKMARK_SAVE:
1767                 savePosition(strToUnsignedInt(argument));
1768                 break;
1769
1770         case LFUN_BOOKMARK_GOTO:
1771                 restorePosition(strToUnsignedInt(argument));
1772                 break;
1773
1774         case LFUN_REF_GOTO:
1775         {
1776                 string label(argument);
1777                 if (label.empty()) {
1778                         InsetRef * inset =
1779                                 static_cast<InsetRef*>(getInsetByCode(Inset::REF_CODE));
1780                         if (inset) {
1781                                 label = inset->getContents();
1782                                 savePosition(0);
1783                         }
1784                 }
1785
1786                 if (!label.empty()) {
1787                         //bv_->savePosition(0);
1788                         if (!bv_->gotoLabel(label))
1789                                 WriteAlert(_("Error"),
1790                                            _("Couldn't find this label"),
1791                                            _("in current document."));
1792                 }
1793         }
1794         break;
1795
1796                 // --- Cursor Movements -----------------------------
1797         case LFUN_RIGHT:
1798         {
1799                 bool is_rtl = TEXT(bv_)->cursor.par()->isRightToLeftPar(buffer_->params);
1800                 if (!TEXT(bv_)->mark_set)
1801                         beforeChange(TEXT(bv_));
1802                 update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR);
1803                 if (is_rtl)
1804                         TEXT(bv_)->CursorLeft(bv_, false);
1805                 if (TEXT(bv_)->cursor.pos() < TEXT(bv_)->cursor.par()->Last()
1806                     && TEXT(bv_)->cursor.par()->GetChar(TEXT(bv_)->cursor.pos())
1807                     == LyXParagraph::META_INSET
1808                     && TEXT(bv_)->cursor.par()->GetInset(TEXT(bv_)->cursor.pos())
1809                     && TEXT(bv_)->cursor.par()->GetInset(TEXT(bv_)->cursor.pos())->Editable() == Inset::HIGHLY_EDITABLE){
1810                         Inset * tmpinset = TEXT(bv_)->cursor.par()->GetInset(TEXT(bv_)->cursor.pos());
1811                         owner_->getLyXFunc()->setMessage(tmpinset->EditMessage());
1812                         int y = 0;
1813                         if (is_rtl) {
1814                                 LyXFont font =
1815                                         TEXT(bv_)->GetFont(buffer_,
1816                                                               TEXT(bv_)->cursor.par(),
1817                                                               TEXT(bv_)->cursor.pos());
1818                                 y = tmpinset->descent(bv_,font);
1819                         }
1820                         tmpinset->Edit(bv_, 0, y, 0);
1821                         break;
1822                 }
1823                 if (!is_rtl)
1824                         TEXT(bv_)->CursorRight(bv_, false);
1825                 TEXT(bv_)->FinishUndo();
1826                 moveCursorUpdate(false);
1827                 owner_->showState();
1828         }
1829         break;
1830
1831         case LFUN_LEFT:
1832         {
1833                 // This is soooo ugly. Isn`t it possible to make
1834                 // it simpler? (Lgb)
1835                 bool is_rtl = TEXT(bv_)->cursor.par()->isRightToLeftPar(buffer_->params);
1836                 if (!TEXT(bv_)->mark_set)
1837                         beforeChange(TEXT(bv_));
1838                 update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR);
1839                 LyXCursor cur = TEXT(bv_)->cursor;
1840                 if (!is_rtl)
1841                         TEXT(bv_)->CursorLeft(bv_, false);
1842                 if ((is_rtl || cur != TEXT(bv_)->cursor) && // only if really moved!
1843                     TEXT(bv_)->cursor.pos() < TEXT(bv_)->cursor.par()->Last() &&
1844                     (TEXT(bv_)->cursor.par()->GetChar(TEXT(bv_)->cursor.pos()) ==
1845                      LyXParagraph::META_INSET) &&
1846                     TEXT(bv_)->cursor.par()->GetInset(TEXT(bv_)->cursor.pos()) &&
1847                     (TEXT(bv_)->cursor.par()->GetInset(TEXT(bv_)->cursor.pos())->Editable()
1848                      == Inset::HIGHLY_EDITABLE))
1849                 {
1850                         Inset * tmpinset = TEXT(bv_)->cursor.par()->GetInset(TEXT(bv_)->cursor.pos());
1851                         owner_->getLyXFunc()->setMessage(tmpinset->EditMessage());
1852                         LyXFont font = TEXT(bv_)->GetFont(buffer_,
1853                                                              TEXT(bv_)->cursor.par(),
1854                                                              TEXT(bv_)->cursor.pos());
1855                         int y = is_rtl ? 0
1856                                 : tmpinset->descent(bv_,font);
1857                         tmpinset->Edit(bv_,
1858                                        tmpinset->x() +
1859                                        tmpinset->width(bv_,font),
1860                                        y, 0);
1861                         break;
1862                 }
1863                 if  (is_rtl)
1864                         TEXT(bv_)->CursorRight(bv_, false);
1865
1866                 TEXT(bv_)->FinishUndo();
1867                 moveCursorUpdate(false);
1868                 owner_->showState();
1869         }
1870         break;
1871
1872         case LFUN_UP:
1873                 if (!TEXT(bv_)->mark_set)
1874                         beforeChange(TEXT(bv_));
1875                 update(TEXT(bv_), BufferView::UPDATE);
1876                 TEXT(bv_)->CursorUp(bv_);
1877                 TEXT(bv_)->FinishUndo();
1878                 moveCursorUpdate(false);
1879                 owner_->showState();
1880                 break;
1881
1882         case LFUN_DOWN:
1883                 if (!TEXT(bv_)->mark_set)
1884                         beforeChange(TEXT(bv_));
1885                 update(TEXT(bv_), BufferView::UPDATE);
1886                 TEXT(bv_)->CursorDown(bv_);
1887                 TEXT(bv_)->FinishUndo();
1888                 moveCursorUpdate(false);
1889                 owner_->showState();
1890                 break;
1891
1892         case LFUN_UP_PARAGRAPH:
1893                 if (!TEXT(bv_)->mark_set)
1894                         beforeChange(TEXT(bv_));
1895                 update(TEXT(bv_), BufferView::UPDATE);
1896                 TEXT(bv_)->CursorUpParagraph(bv_);
1897                 TEXT(bv_)->FinishUndo();
1898                 moveCursorUpdate(false);
1899                 owner_->showState();
1900                 break;
1901
1902         case LFUN_DOWN_PARAGRAPH:
1903                 if (!TEXT(bv_)->mark_set)
1904                         beforeChange(TEXT(bv_));
1905                 update(TEXT(bv_), BufferView::UPDATE);
1906                 TEXT(bv_)->CursorDownParagraph(bv_);
1907                 TEXT(bv_)->FinishUndo();
1908                 moveCursorUpdate(false);
1909                 owner_->showState();
1910                 break;
1911
1912         case LFUN_PRIOR:
1913                 if (!TEXT(bv_)->mark_set)
1914                         beforeChange(TEXT(bv_));
1915                 update(TEXT(bv_), BufferView::UPDATE);
1916                 cursorPrevious(TEXT(bv_));
1917                 TEXT(bv_)->FinishUndo();
1918                 moveCursorUpdate(false);
1919                 owner_->showState();
1920                 break;
1921
1922         case LFUN_NEXT:
1923                 if (!TEXT(bv_)->mark_set)
1924                         beforeChange(TEXT(bv_));
1925                 update(TEXT(bv_), BufferView::UPDATE);
1926                 cursorNext(TEXT(bv_));
1927                 TEXT(bv_)->FinishUndo();
1928                 moveCursorUpdate(false);
1929                 owner_->showState();
1930                 break;
1931
1932         case LFUN_HOME:
1933                 if (!TEXT(bv_)->mark_set)
1934                         beforeChange(TEXT(bv_));
1935                 update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR);
1936                 TEXT(bv_)->CursorHome(bv_);
1937                 TEXT(bv_)->FinishUndo();
1938                 moveCursorUpdate(false);
1939                 owner_->showState();
1940                 break;
1941
1942         case LFUN_END:
1943                 if (!TEXT(bv_)->mark_set)
1944                         beforeChange(TEXT(bv_));
1945                 update(TEXT(bv_),
1946                        BufferView::SELECT|BufferView::FITCUR);
1947                 TEXT(bv_)->CursorEnd(bv_);
1948                 TEXT(bv_)->FinishUndo();
1949                 moveCursorUpdate(false);
1950                 owner_->showState();
1951                 break;
1952
1953         case LFUN_SHIFT_TAB:
1954         case LFUN_TAB:
1955                 if (!TEXT(bv_)->mark_set)
1956                         beforeChange(TEXT(bv_));
1957                 update(TEXT(bv_),
1958                        BufferView::SELECT|BufferView::FITCUR);
1959                 TEXT(bv_)->CursorTab(bv_);
1960                 TEXT(bv_)->FinishUndo();
1961                 moveCursorUpdate(false);
1962                 owner_->showState();
1963                 break;
1964
1965         case LFUN_WORDRIGHT:
1966                 if (!TEXT(bv_)->mark_set)
1967                         beforeChange(TEXT(bv_));
1968                 update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR);
1969                 if (TEXT(bv_)->cursor.par()->isRightToLeftPar(buffer_->params))
1970                         TEXT(bv_)->CursorLeftOneWord(bv_);
1971                 else
1972                         TEXT(bv_)->CursorRightOneWord(bv_);
1973                 TEXT(bv_)->FinishUndo();
1974                 moveCursorUpdate(false);
1975                 owner_->showState();
1976                 break;
1977
1978         case LFUN_WORDLEFT:
1979                 if (!TEXT(bv_)->mark_set)
1980                         beforeChange(TEXT(bv_));
1981                 update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR);
1982                 if (TEXT(bv_)->cursor.par()->isRightToLeftPar(buffer_->params))
1983                         TEXT(bv_)->CursorRightOneWord(bv_);
1984                 else
1985                         TEXT(bv_)->CursorLeftOneWord(bv_);
1986                 TEXT(bv_)->FinishUndo();
1987                 moveCursorUpdate(false);
1988                 owner_->showState();
1989                 break;
1990
1991         case LFUN_BEGINNINGBUF:
1992                 if (!TEXT(bv_)->mark_set)
1993                         beforeChange(TEXT(bv_));
1994                 update(TEXT(bv_),
1995                        BufferView::SELECT|BufferView::FITCUR);
1996                 TEXT(bv_)->CursorTop(bv_);
1997                 TEXT(bv_)->FinishUndo();
1998                 moveCursorUpdate(false);
1999                 owner_->showState();
2000                 break;
2001
2002         case LFUN_ENDBUF:
2003                 if (!TEXT(bv_)->mark_set)
2004                         beforeChange(TEXT(bv_));
2005                 update(TEXT(bv_),
2006                        BufferView::SELECT|BufferView::FITCUR);
2007                 TEXT(bv_)->CursorBottom(bv_);
2008                 TEXT(bv_)->FinishUndo();
2009                 moveCursorUpdate(false);
2010                 owner_->showState();
2011                 break;
2012
2013
2014                 /* cursor selection ---------------------------- */
2015         case LFUN_RIGHTSEL:
2016                 update(TEXT(bv_),
2017                        BufferView::SELECT|BufferView::FITCUR);
2018                 if (TEXT(bv_)->cursor.par()->isRightToLeftPar(buffer_->params))
2019                         TEXT(bv_)->CursorLeft(bv_);
2020                 else
2021                         TEXT(bv_)->CursorRight(bv_);
2022                 TEXT(bv_)->FinishUndo();
2023                 moveCursorUpdate(true);
2024                 owner_->showState();
2025                 break;
2026
2027         case LFUN_LEFTSEL:
2028                 update(TEXT(bv_),
2029                        BufferView::SELECT|BufferView::FITCUR);
2030                 if (TEXT(bv_)->cursor.par()->isRightToLeftPar(buffer_->params))
2031                         TEXT(bv_)->CursorRight(bv_);
2032                 else
2033                         TEXT(bv_)->CursorLeft(bv_);
2034                 TEXT(bv_)->FinishUndo();
2035                 moveCursorUpdate(true);
2036                 owner_->showState();
2037                 break;
2038
2039         case LFUN_UPSEL:
2040                 update(TEXT(bv_),
2041                        BufferView::SELECT|BufferView::FITCUR);
2042                 TEXT(bv_)->CursorUp(bv_);
2043                 TEXT(bv_)->FinishUndo();
2044                 moveCursorUpdate(true);
2045                 owner_->showState();
2046                 break;
2047
2048         case LFUN_DOWNSEL:
2049                 update(TEXT(bv_),
2050                        BufferView::SELECT|BufferView::FITCUR);
2051                 TEXT(bv_)->CursorDown(bv_);
2052                 TEXT(bv_)->FinishUndo();
2053                 moveCursorUpdate(true);
2054                 owner_->showState();
2055                 break;
2056
2057         case LFUN_UP_PARAGRAPHSEL:
2058                 update(TEXT(bv_),
2059                        BufferView::SELECT|BufferView::FITCUR);
2060                 TEXT(bv_)->CursorUpParagraph(bv_);
2061                 TEXT(bv_)->FinishUndo();
2062                 moveCursorUpdate(true);
2063                 owner_->showState();
2064                 break;
2065
2066         case LFUN_DOWN_PARAGRAPHSEL:
2067                 update(TEXT(bv_),
2068                        BufferView::SELECT|BufferView::FITCUR);
2069                 TEXT(bv_)->CursorDownParagraph(bv_);
2070                 TEXT(bv_)->FinishUndo();
2071                 moveCursorUpdate(true);
2072                 owner_->showState();
2073                 break;
2074
2075         case LFUN_PRIORSEL:
2076                 update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR);
2077                 cursorPrevious(TEXT(bv_));
2078                 TEXT(bv_)->FinishUndo();
2079                 moveCursorUpdate(true);
2080                 owner_->showState();
2081                 break;
2082
2083         case LFUN_NEXTSEL:
2084                 update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR);
2085                 cursorNext(TEXT(bv_));
2086                 TEXT(bv_)->FinishUndo();
2087                 moveCursorUpdate(true);
2088                 owner_->showState();
2089                 break;
2090
2091         case LFUN_HOMESEL:
2092                 update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR);
2093                 TEXT(bv_)->CursorHome(bv_);
2094                 TEXT(bv_)->FinishUndo();
2095                 moveCursorUpdate(true);
2096                 owner_->showState();
2097                 break;
2098
2099         case LFUN_ENDSEL:
2100                 update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR);
2101                 TEXT(bv_)->CursorEnd(bv_);
2102                 TEXT(bv_)->FinishUndo();
2103                 moveCursorUpdate(true);
2104                 owner_->showState();
2105                 break;
2106
2107         case LFUN_WORDRIGHTSEL:
2108                 update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR);
2109                 if (TEXT(bv_)->cursor.par()->isRightToLeftPar(buffer_->params))
2110                         TEXT(bv_)->CursorLeftOneWord(bv_);
2111                 else
2112                         TEXT(bv_)->CursorRightOneWord(bv_);
2113                 TEXT(bv_)->FinishUndo();
2114                 moveCursorUpdate(true);
2115                 owner_->showState();
2116                 break;
2117
2118         case LFUN_WORDLEFTSEL:
2119                 update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR);
2120                 if (TEXT(bv_)->cursor.par()->isRightToLeftPar(buffer_->params))
2121                         TEXT(bv_)->CursorRightOneWord(bv_);
2122                 else
2123                         TEXT(bv_)->CursorLeftOneWord(bv_);
2124                 TEXT(bv_)->FinishUndo();
2125                 moveCursorUpdate(true);
2126                 owner_->showState();
2127                 break;
2128
2129         case LFUN_BEGINNINGBUFSEL:
2130                 if (TEXT(bv_)->inset_owner)
2131                         break;
2132                 update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR);
2133                 TEXT(bv_)->CursorTop(bv_);
2134                 TEXT(bv_)->FinishUndo();
2135                 moveCursorUpdate(true);
2136                 owner_->showState();
2137                 break;
2138
2139         case LFUN_ENDBUFSEL:
2140                 if (TEXT(bv_)->inset_owner)
2141                         break;
2142                 update(TEXT(bv_),
2143                        BufferView::SELECT|BufferView::FITCUR);
2144                 TEXT(bv_)->CursorBottom(bv_);
2145                 TEXT(bv_)->FinishUndo();
2146                 moveCursorUpdate(true);
2147                 owner_->showState();
2148                 break;
2149
2150                 // --- text changing commands ------------------------
2151         case LFUN_BREAKLINE:
2152                 beforeChange(TEXT(bv_));
2153                 TEXT(bv_)->InsertChar(bv_, LyXParagraph::META_NEWLINE);
2154                 update(TEXT(bv_),
2155                        BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
2156                 moveCursorUpdate(false);
2157                 break;
2158
2159         case LFUN_PROTECTEDSPACE:
2160         {
2161                 LyXLayout const & style =
2162                         textclasslist.Style(buffer_->params.textclass,
2163                                             TEXT(bv_)->cursor.par()->GetLayout());
2164
2165                 if (style.free_spacing) {
2166                         TEXT(bv_)->InsertChar(bv_, ' ');
2167                         update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
2168                 } else {
2169                         bv_->protectedBlank(TEXT(bv_));
2170                 }
2171                 moveCursorUpdate(false);
2172         }
2173         break;
2174
2175         case LFUN_SETMARK:
2176                 if (TEXT(bv_)->mark_set) {
2177                         beforeChange(TEXT(bv_));
2178                         update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR);
2179                         owner_->getLyXFunc()->setMessage(N_("Mark removed"));
2180                 } else {
2181                         beforeChange(TEXT(bv_));
2182                         TEXT(bv_)->mark_set = 1;
2183                         update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR);
2184                         owner_->getLyXFunc()->setMessage(N_("Mark set"));
2185                 }
2186                 TEXT(bv_)->sel_cursor = TEXT(bv_)->cursor;
2187                 break;
2188
2189         case LFUN_DELETE:
2190                 if (!TEXT(bv_)->selection) {
2191                         TEXT(bv_)->Delete(bv_);
2192                         TEXT(bv_)->sel_cursor =
2193                                 TEXT(bv_)->cursor;
2194                         update(TEXT(bv_),
2195                                BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
2196                         // It is possible to make it a lot faster still
2197                         // just comment out the line below...
2198                         showCursor();
2199                 } else {
2200                         bv_->cut();
2201                 }
2202                 moveCursorUpdate(false);
2203                 owner_->showState();
2204                 setState();
2205                 break;
2206
2207         case LFUN_DELETE_SKIP:
2208         {
2209                 // Reverse the effect of LFUN_BREAKPARAGRAPH_SKIP.
2210
2211                 LyXCursor cursor = TEXT(bv_)->cursor;
2212
2213                 if (!TEXT(bv_)->selection) {
2214                         if (cursor.pos() == cursor.par()->Last()) {
2215                                 TEXT(bv_)->CursorRight(bv_);
2216                                 cursor = TEXT(bv_)->cursor;
2217                                 if (cursor.pos() == 0
2218                                     && !(cursor.par()->added_space_top
2219                                          == VSpace (VSpace::NONE))) {
2220                                         TEXT(bv_)->SetParagraph
2221                                                 (bv_,
2222                                                  cursor.par()->line_top,
2223                                                  cursor.par()->line_bottom,
2224                                                  cursor.par()->pagebreak_top,
2225                                                  cursor.par()->pagebreak_bottom,
2226                                                  VSpace(VSpace::NONE),
2227                                                  cursor.par()->added_space_bottom,
2228                                                  cursor.par()->align,
2229                                                  cursor.par()->labelwidthstring, 0);
2230                                         TEXT(bv_)->CursorLeft(bv_);
2231                                         update(TEXT(bv_),
2232                                                BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
2233                                 } else {
2234                                         TEXT(bv_)->CursorLeft(bv_);
2235                                         TEXT(bv_)->Delete(bv_);
2236                                         TEXT(bv_)->sel_cursor =
2237                                                 TEXT(bv_)->cursor;
2238                                         update(TEXT(bv_),
2239                                                BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
2240                                 }
2241                         } else {
2242                                 TEXT(bv_)->Delete(bv_);
2243                                 TEXT(bv_)->sel_cursor =
2244                                         TEXT(bv_)->cursor;
2245                                 update(TEXT(bv_),
2246                                        BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
2247                         }
2248                 } else {
2249                         bv_->cut();
2250                 }
2251         }
2252         break;
2253
2254         /* -------> Delete word forward. */
2255         case LFUN_DELETE_WORD_FORWARD:
2256                 update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR);
2257                 TEXT(bv_)->DeleteWordForward(bv_);
2258                 update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
2259                 moveCursorUpdate(false);
2260                 owner_->showState();
2261                 break;
2262
2263                 /* -------> Delete word backward. */
2264         case LFUN_DELETE_WORD_BACKWARD:
2265                 update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR);
2266                 TEXT(bv_)->DeleteWordBackward(bv_);
2267                 update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
2268                 moveCursorUpdate(false);
2269                 owner_->showState();
2270                 break;
2271
2272                 /* -------> Kill to end of line. */
2273         case LFUN_DELETE_LINE_FORWARD:
2274                 update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR);
2275                 TEXT(bv_)->DeleteLineForward(bv_);
2276                 update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
2277                 moveCursorUpdate(false);
2278                 break;
2279
2280                 /* -------> Set mark off. */
2281         case LFUN_MARK_OFF:
2282                 beforeChange(TEXT(bv_));
2283                 update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR);
2284                 TEXT(bv_)->sel_cursor = TEXT(bv_)->cursor;
2285                 owner_->getLyXFunc()->setMessage(N_("Mark off"));
2286                 break;
2287
2288                 /* -------> Set mark on. */
2289         case LFUN_MARK_ON:
2290                 beforeChange(TEXT(bv_));
2291                 TEXT(bv_)->mark_set = 1;
2292                 update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR);
2293                 TEXT(bv_)->sel_cursor = TEXT(bv_)->cursor;
2294                 owner_->getLyXFunc()->setMessage(N_("Mark on"));
2295                 break;
2296
2297         case LFUN_BACKSPACE:
2298         {
2299                 if (!TEXT(bv_)->selection) {
2300                         if (owner_->getIntl()->getTrans().backspace()) {
2301                                 TEXT(bv_)->Backspace(bv_);
2302                                 TEXT(bv_)->sel_cursor =
2303                                         TEXT(bv_)->cursor;
2304                                 update(TEXT(bv_),
2305                                        BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
2306                                 // It is possible to make it a lot faster still
2307                                 // just comment out the line below...
2308                                 showCursor();
2309                         }
2310                 } else {
2311                         bv_->cut();
2312                 }
2313                 owner_->showState();
2314                 setState();
2315         }
2316         break;
2317
2318         case LFUN_BACKSPACE_SKIP:
2319         {
2320                 // Reverse the effect of LFUN_BREAKPARAGRAPH_SKIP.
2321
2322                 LyXCursor cursor = TEXT(bv_)->cursor;
2323
2324                 if (!TEXT(bv_)->selection) {
2325                         if (cursor.pos() == 0
2326                             && !(cursor.par()->added_space_top
2327                                  == VSpace (VSpace::NONE))) {
2328                                 TEXT(bv_)->SetParagraph
2329                                         (bv_,
2330                                          cursor.par()->line_top,
2331                                          cursor.par()->line_bottom,
2332                                          cursor.par()->pagebreak_top,
2333                                          cursor.par()->pagebreak_bottom,
2334                                          VSpace(VSpace::NONE), cursor.par()->added_space_bottom,
2335                                          cursor.par()->align,
2336                                          cursor.par()->labelwidthstring, 0);
2337                                 update(TEXT(bv_),
2338                                        BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
2339                         } else {
2340                                 TEXT(bv_)->Backspace(bv_);
2341                                 TEXT(bv_)->sel_cursor
2342                                         = cursor;
2343                                 update(TEXT(bv_),
2344                                        BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
2345                         }
2346                 } else
2347                         bv_->cut();
2348         }
2349         break;
2350
2351         case LFUN_BREAKPARAGRAPH:
2352         {
2353                 beforeChange(TEXT(bv_));
2354                 TEXT(bv_)->BreakParagraph(bv_, 0);
2355                 update(TEXT(bv_),
2356                        BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
2357                 TEXT(bv_)->sel_cursor = TEXT(bv_)->cursor;
2358                 setState();
2359                 owner_->showState();
2360                 break;
2361         }
2362
2363         case LFUN_BREAKPARAGRAPHKEEPLAYOUT:
2364         {
2365                 beforeChange(TEXT(bv_));
2366                 TEXT(bv_)->BreakParagraph(bv_, 1);
2367                 update(TEXT(bv_),
2368                        BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
2369                 TEXT(bv_)->sel_cursor = TEXT(bv_)->cursor;
2370                 setState();
2371                 owner_->showState();
2372                 break;
2373         }
2374
2375         case LFUN_BREAKPARAGRAPH_SKIP:
2376         {
2377                 // When at the beginning of a paragraph, remove
2378                 // indentation and add a "defskip" at the top.
2379                 // Otherwise, do the same as LFUN_BREAKPARAGRAPH.
2380
2381                 LyXCursor cursor = TEXT(bv_)->cursor;
2382
2383                 beforeChange(TEXT(bv_));
2384                 if (cursor.pos() == 0) {
2385                         if (cursor.par()->added_space_top == VSpace(VSpace::NONE)) {
2386                                 TEXT(bv_)->SetParagraph
2387                                         (bv_,
2388                                          cursor.par()->line_top,
2389                                          cursor.par()->line_bottom,
2390                                          cursor.par()->pagebreak_top,
2391                                          cursor.par()->pagebreak_bottom,
2392                                          VSpace(VSpace::DEFSKIP), cursor.par()->added_space_bottom,
2393                                          cursor.par()->align,
2394                                          cursor.par()->labelwidthstring, 1);
2395                                 //update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
2396                         }
2397                 }
2398                 else {
2399                         TEXT(bv_)->BreakParagraph(bv_, 0);
2400                         //update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
2401                 }
2402
2403                 update(TEXT(bv_),
2404                        BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
2405                 TEXT(bv_)->sel_cursor = cursor;
2406                 setState();
2407                 owner_->showState();
2408         }
2409         break;
2410
2411         case LFUN_PARAGRAPH_SPACING:
2412         {
2413                 LyXParagraph * par = TEXT(bv_)->cursor.par();
2414                 Spacing::Space cur_spacing = par->spacing.getSpace();
2415                 float cur_value = 1.0;
2416                 if (cur_spacing == Spacing::Other) {
2417                         cur_value = par->spacing.getValue();
2418                 }
2419
2420                 istringstream istr(argument.c_str());
2421
2422                 string tmp;
2423                 istr >> tmp;
2424                 Spacing::Space new_spacing = cur_spacing;
2425                 float new_value = cur_value;
2426                 if (tmp.empty()) {
2427                         lyxerr << "Missing argument to `paragraph-spacing'"
2428                                << endl;
2429                 } else if (tmp == "single") {
2430                         new_spacing = Spacing::Single;
2431                 } else if (tmp == "onehalf") {
2432                         new_spacing = Spacing::Onehalf;
2433                 } else if (tmp == "double") {
2434                         new_spacing = Spacing::Double;
2435                 } else if (tmp == "other") {
2436                         new_spacing = Spacing::Other;
2437                         float tmpval = 0.0;
2438                         istr >> tmpval;
2439                         lyxerr << "new_value = " << tmpval << endl;
2440                         if (tmpval != 0.0)
2441                                 new_value = tmpval;
2442                 } else if (tmp == "default") {
2443                         new_spacing = Spacing::Default;
2444                 } else {
2445                         lyxerr << _("Unknown spacing argument: ")
2446                                << argument << endl;
2447                 }
2448                 if (cur_spacing != new_spacing || cur_value != new_value) {
2449                         par->spacing.set(new_spacing, new_value);
2450                         TEXT(bv_)->RedoParagraph(bv_);
2451                         update(TEXT(bv_),
2452                                BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
2453                 }
2454         }
2455         break;
2456
2457         case LFUN_QUOTE:
2458                 beforeChange(TEXT(bv_));
2459                 TEXT(bv_)->InsertChar(bv_, '\"');  // This " matches the single quote in the code
2460                 update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
2461                 moveCursorUpdate(false);
2462                 break;
2463
2464         case LFUN_HTMLURL:
2465         case LFUN_URL:
2466         {
2467                 InsetCommandParams p;
2468                 if (action == LFUN_HTMLURL)
2469                         p.setCmdName("htmlurl");
2470                 else
2471                         p.setCmdName("url");
2472                 owner_->getDialogs()->createUrl( p.getAsString() );
2473         }
2474         break;
2475
2476         case LFUN_INSERT_URL:
2477         {
2478                 InsetCommandParams p;
2479                 p.setFromString( argument );
2480
2481                 InsetUrl * inset = new InsetUrl( p );
2482                 if (!bv_->insertInset(inset))
2483                         delete inset;
2484                 else
2485                         bv_->updateInset( inset, true );
2486         }
2487         break;
2488
2489         case LFUN_INSET_TEXT:
2490         {
2491                 InsetText * new_inset = new InsetText;
2492                 if (bv_->insertInset(new_inset))
2493                         new_inset->Edit(bv_, 0, 0, 0);
2494                 else
2495                         delete new_inset;
2496         }
2497         break;
2498
2499         case LFUN_INSET_ERT:
2500         {
2501                 InsetERT * new_inset = new InsetERT;
2502                 if (bv_->insertInset(new_inset))
2503                         new_inset->Edit(bv_, 0, 0, 0);
2504                 else
2505                         delete new_inset;
2506         }
2507         break;
2508
2509         case LFUN_INSET_EXTERNAL:
2510         {
2511                 InsetExternal * new_inset = new InsetExternal;
2512                 if (bv_->insertInset(new_inset))
2513                         new_inset->Edit(bv_, 0, 0, 0);
2514                 else
2515                         delete new_inset;
2516         }
2517         break;
2518
2519         case LFUN_INSET_FOOTNOTE:
2520         {
2521                 InsetFoot * new_inset = new InsetFoot;
2522                 if (bv_->insertInset(new_inset))
2523                         new_inset->Edit(bv_, 0, 0, 0);
2524                 else
2525                         delete new_inset;
2526         }
2527         break;
2528
2529         case LFUN_INSET_MARGINAL:
2530         {
2531                 InsetMarginal * new_inset = new InsetMarginal;
2532                 if (bv_->insertInset(new_inset))
2533                         new_inset->Edit(bv_, 0, 0, 0);
2534                 else
2535                         delete new_inset;
2536         }
2537         break;
2538
2539         case LFUN_INSET_MINIPAGE:
2540         {
2541                 InsetMinipage * new_inset = new InsetMinipage;
2542                 if (bv_->insertInset(new_inset))
2543                         new_inset->Edit(bv_, 0, 0, 0);
2544                 else
2545                         delete new_inset;
2546         }
2547         break;
2548
2549         case LFUN_INSET_FLOAT:
2550         {
2551                 // check if the float type exist
2552                 if (floatList.typeExist(argument)) {
2553                         InsetFloat * new_inset = new InsetFloat(argument);
2554                         if (bv_->insertInset(new_inset))
2555                                 new_inset->Edit(bv_, 0, 0, 0);
2556                         else
2557                                 delete new_inset;
2558                 } else {
2559                         lyxerr << "Non-existant float type: "
2560                                << argument << endl;
2561                 }
2562
2563         }
2564         break;
2565
2566         case LFUN_INSET_LIST:
2567         {
2568                 InsetList * new_inset = new InsetList;
2569                 if (bv_->insertInset(new_inset))
2570                         new_inset->Edit(bv_, 0, 0, 0);
2571                 else
2572                         delete new_inset;
2573         }
2574         break;
2575
2576         case LFUN_INSET_THEOREM:
2577         {
2578                 InsetTheorem * new_inset = new InsetTheorem;
2579                 if (bv_->insertInset(new_inset))
2580                         new_inset->Edit(bv_, 0, 0, 0);
2581                 else
2582                         delete new_inset;
2583         }
2584         break;
2585
2586         case LFUN_INSET_CAPTION:
2587         {
2588                 // Do we have a locking inset...
2589                 if (bv_->theLockingInset()) {
2590                         lyxerr << "Locking inset code: "
2591                                << static_cast<int>(bv_->theLockingInset()->LyxCode());
2592                         InsetCaption * new_inset = new InsetCaption;
2593                         new_inset->setOwner(bv_->theLockingInset());
2594                         new_inset->SetAutoBreakRows(true);
2595                         new_inset->SetDrawFrame(0, InsetText::LOCKED);
2596                         new_inset->SetFrameColor(0, LColor::footnoteframe);
2597                         if (bv_->insertInset(new_inset))
2598                                 new_inset->Edit(bv_, 0, 0, 0);
2599                         else
2600                                 delete new_inset;
2601                 }
2602         }
2603         break;
2604
2605         case LFUN_INSET_TABULAR:
2606         {
2607                 int r = 2, c = 2;
2608                 if (!argument.empty())
2609                         ::sscanf(argument.c_str(),"%d%d", &r, &c);
2610                 InsetTabular * new_inset =
2611                         new InsetTabular(*buffer_, r, c);
2612                 bool rtl =
2613                         TEXT(bv_)->real_current_font.isRightToLeft();
2614                 if (!bv_->open_new_inset(new_inset, rtl))
2615                         delete new_inset;
2616         }
2617         break;
2618
2619         // --- lyxserver commands ----------------------------
2620
2621         case LFUN_CHARATCURSOR:
2622         {
2623                 LyXParagraph::size_type pos = TEXT(bv_)->cursor.pos();
2624                 if (pos < TEXT(bv_)->cursor.par()->size())
2625                         owner_->getLyXFunc()->setMessage(
2626                                 tostr(TEXT(bv_)->cursor.par()->GetChar(pos)));
2627                 else
2628                         owner_->getLyXFunc()->setMessage("EOF");
2629         }
2630         break;
2631
2632         case LFUN_GETXY:
2633                 owner_->getLyXFunc()->setMessage(tostr(TEXT(bv_)->cursor.x())
2634                                                  + ' '
2635                                                  + tostr(TEXT(bv_)->cursor.y()));
2636                 break;
2637
2638         case LFUN_SETXY:
2639         {
2640                 int x;
2641                 int y;
2642                 ::sscanf(argument.c_str(), " %d %d", &x, &y);
2643                 TEXT(bv_)->SetCursorFromCoordinates(bv_, x, y);
2644         }
2645         break;
2646
2647         case LFUN_GETLAYOUT:
2648                 owner_->getLyXFunc()->setMessage(tostr(TEXT(bv_)->cursor.par()->layout));
2649                 break;
2650
2651         case LFUN_GETFONT:
2652         {
2653                 LyXFont & font = TEXT(bv_)->current_font;
2654                 if (font.shape() == LyXFont::ITALIC_SHAPE)
2655                         owner_->getLyXFunc()->setMessage("E");
2656                 else if (font.shape() == LyXFont::SMALLCAPS_SHAPE)
2657                         owner_->getLyXFunc()->setMessage("N");
2658                 else
2659                         owner_->getLyXFunc()->setMessage("0");
2660
2661         }
2662         break;
2663
2664         case LFUN_GETLATEX:
2665         {
2666                 LyXFont & font = TEXT(bv_)->current_font;
2667                 if (font.latex() == LyXFont::ON)
2668                         owner_->getLyXFunc()->setMessage("L");
2669                 else
2670                         owner_->getLyXFunc()->setMessage("0");
2671         }
2672         break;
2673
2674         // --- accented characters ---------------------------
2675
2676         case LFUN_UMLAUT:
2677         case LFUN_CIRCUMFLEX:
2678         case LFUN_GRAVE:
2679         case LFUN_ACUTE:
2680         case LFUN_TILDE:
2681         case LFUN_CEDILLA:
2682         case LFUN_MACRON:
2683         case LFUN_DOT:
2684         case LFUN_UNDERDOT:
2685         case LFUN_UNDERBAR:
2686         case LFUN_CARON:
2687         case LFUN_SPECIAL_CARON:
2688         case LFUN_BREVE:
2689         case LFUN_TIE:
2690         case LFUN_HUNG_UMLAUT:
2691         case LFUN_CIRCLE:
2692         case LFUN_OGONEK:
2693                 owner_->getLyXFunc()->handleKeyFunc(action);
2694                 break;
2695
2696         // --- insert characters ----------------------------------------
2697
2698         case LFUN_MATH_DELIM:
2699         case LFUN_INSERT_MATRIX:
2700         {
2701                 if (available()) {
2702                         if (bv_->open_new_inset(new InsetFormula(false)))
2703                         {
2704                                 bv_->theLockingInset()
2705                                         ->LocalDispatch(bv_, action, argument);
2706                         }
2707                 }
2708         }
2709         break;
2710
2711         case LFUN_INSERT_MATH:
2712         {
2713                 math_insert_symbol(bv_, argument);
2714         }
2715         break;
2716
2717         case LFUN_MATH_DISPLAY:
2718         {
2719                 if (available())
2720                         bv_->open_new_inset(new InsetFormula(true));
2721                 break;
2722         }
2723
2724         case LFUN_MATH_MACRO:
2725         {
2726                 if (available()) {
2727                         string s(argument);
2728                         if (s.empty())
2729                                 owner_->getLyXFunc()->setErrorMessage(N_("Missing argument"));
2730                         else {
2731                                 string const s1 = token(s, ' ', 1);
2732                                 int const na = s1.empty() ? 0 : lyx::atoi(s1);
2733                                 bv_->open_new_inset(new InsetFormulaMacro(token(s, ' ', 0), na));
2734                         }
2735                 }
2736         }
2737         break;
2738
2739         case LFUN_MATH_MODE:   // Open or create a math inset
2740         {
2741                 if (available())
2742                         bv_->open_new_inset(new InsetFormula);
2743                 owner_->getLyXFunc()->setMessage(N_("Math editor mode"));
2744         }
2745         break;
2746
2747         case LFUN_CITATION_INSERT:
2748         {
2749                 InsetCommandParams p;
2750                 p.setFromString( argument );
2751
2752                 InsetCitation * inset = new InsetCitation( p );
2753                 if (!bv_->insertInset(inset))
2754                         delete inset;
2755                 else
2756                         bv_->updateInset( inset, true );
2757         }
2758         break;
2759
2760         case LFUN_INSERT_BIBTEX:
2761         {
2762                 // ale970405+lasgoutt970425
2763                 // The argument can be up to two tokens separated
2764                 // by a space. The first one is the bibstyle.
2765                 string const db       = token(argument, ' ', 0);
2766                 string bibstyle = token(argument, ' ', 1);
2767                 if (bibstyle.empty())
2768                         bibstyle = "plain";
2769
2770                 InsetCommandParams p( "BibTeX", db, bibstyle );
2771                 InsetBibtex * inset = new InsetBibtex(p);
2772
2773                 if (bv_->insertInset(inset)) {
2774                         if (argument.empty())
2775                                 inset->Edit(bv_, 0, 0, 0);
2776                 } else
2777                         delete inset;
2778         }
2779         break;
2780
2781         // BibTeX data bases
2782         case LFUN_BIBDB_ADD:
2783         {
2784                 InsetBibtex * inset =
2785                         static_cast<InsetBibtex*>(getInsetByCode(Inset::BIBTEX_CODE));
2786                 if (inset) {
2787                         inset->addDatabase(argument);
2788                 }
2789         }
2790         break;
2791
2792         case LFUN_BIBDB_DEL:
2793         {
2794                 InsetBibtex * inset =
2795                         static_cast<InsetBibtex*>(getInsetByCode(Inset::BIBTEX_CODE));
2796                 if (inset) {
2797                         inset->delDatabase(argument);
2798                 }
2799         }
2800         break;
2801
2802         case LFUN_BIBTEX_STYLE:
2803         {
2804                 InsetBibtex * inset =
2805                         static_cast<InsetBibtex*>(getInsetByCode(Inset::BIBTEX_CODE));
2806                 if (inset) {
2807                         inset->setOptions(argument);
2808                 }
2809         }
2810         break;
2811
2812         case LFUN_INDEX_CREATE:
2813         {
2814                 InsetCommandParams p( "index" );
2815
2816                 if (argument.empty()) {
2817                         // Get the word immediately preceding the cursor
2818                         LyXParagraph::size_type curpos =
2819                                 TEXT(bv_)->cursor.pos() - 1;
2820
2821                         string curstring;
2822                         if (curpos >= 0 )
2823                                 curstring = TEXT(bv_)
2824                                         ->cursor.par()->GetWord(curpos);
2825
2826                         p.setContents( curstring );
2827                 } else {
2828                         p.setContents( argument );
2829                 }
2830
2831                 owner_->getDialogs()->createIndex( p.getAsString() );
2832         }
2833         break;
2834
2835         case LFUN_INDEX_INSERT:
2836         {
2837                 InsetCommandParams p;
2838                 p.setFromString(argument);
2839                 InsetIndex * inset = new InsetIndex(p);
2840
2841                 if (!bv_->insertInset(inset))
2842                         delete inset;
2843                 else
2844                         bv_->updateInset(inset, true);
2845         }
2846         break;
2847
2848         case LFUN_INDEX_INSERT_LAST:
2849         {
2850                 // Get word immediately preceding the cursor
2851                 LyXParagraph::size_type curpos =
2852                         TEXT(bv_)->cursor.pos() - 1;
2853                 // Can't do that at the beginning of a paragraph
2854                 if (curpos < 0) break;
2855
2856                 string const curstring(TEXT(bv_)
2857                                        ->cursor.par()->GetWord(curpos));
2858
2859                 InsetCommandParams p("index", curstring);
2860                 InsetIndex * inset = new InsetIndex(p);
2861
2862                 if (!bv_->insertInset(inset))
2863                         delete inset;
2864                 else
2865                         bv_->updateInset(inset, true);
2866         }
2867         break;
2868
2869         case LFUN_INDEX_PRINT:
2870         {
2871                 InsetCommandParams p("printindex");
2872                 Inset * inset = new InsetPrintIndex(p);
2873                 if (!bv_->insertInset(inset, "Standard", true))
2874                         delete inset;
2875         }
2876         break;
2877
2878         case LFUN_PARENTINSERT:
2879         {
2880                 lyxerr << "arg " << argument << endl;
2881                 InsetCommandParams p( "lyxparent", argument );
2882                 Inset * inset = new InsetParent(p, *buffer_);
2883                 if (!bv_->insertInset(inset, "Standard", true))
2884                         delete inset;
2885         }
2886         break;
2887
2888         case LFUN_CHILD_INSERT:
2889         {
2890                 InsetCommandParams p;
2891                 p.setFromString(argument);
2892
2893                 InsetInclude * inset = new InsetInclude(p, *buffer_);
2894                 if (!bv_->insertInset(inset))
2895                         delete inset;
2896                 else
2897                         bv_->updateInset(inset, true);
2898         }
2899         break;
2900
2901         case LFUN_INSERT_NOTE:
2902                 bv_->insertNote();
2903                 break;
2904
2905         case LFUN_SELFINSERT:
2906         {
2907                 LyXFont const old_font(TEXT(bv_)->real_current_font);
2908                 for (string::size_type i = 0; i < argument.length(); ++i) {
2909                         TEXT(bv_)->InsertChar(bv_, argument[i]);
2910                         // This needs to be in the loop, or else we
2911                         // won't break lines correctly. (Asger)
2912                         update(TEXT(bv_),
2913                                BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
2914                 }
2915                 TEXT(bv_)->sel_cursor = TEXT(bv_)->cursor;
2916                 moveCursorUpdate(false);
2917
2918                 // real_current_font.number can change so we need to
2919                 // update the minibuffer
2920                 if (old_font != TEXT(bv_)->real_current_font)
2921                         owner_->showState();
2922         }
2923         break;
2924
2925         case LFUN_DATE_INSERT:  // jdblair: date-insert cmd
2926         {
2927                 struct tm * now_tm;
2928
2929                 time_t now_time_t = time(NULL);
2930                 now_tm = localtime(&now_time_t);
2931                 setlocale(LC_TIME, "");
2932                 string arg;
2933                 if (!argument.empty())
2934                         arg = argument;
2935                 else
2936                         arg = lyxrc.date_insert_format;
2937                 char datetmp[32];
2938                 int const datetmp_len =
2939                         ::strftime(datetmp, 32, arg.c_str(), now_tm);
2940                 for (int i = 0; i < datetmp_len; i++) {
2941                         TEXT(bv_)->InsertChar(bv_, datetmp[i]);
2942                         update(TEXT(bv_),
2943                                BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
2944                 }
2945
2946                 TEXT(bv_)->sel_cursor = TEXT(bv_)->cursor;
2947                 moveCursorUpdate(false);
2948         }
2949         break;
2950
2951         case LFUN_UNKNOWN_ACTION:
2952         {
2953                 if (!buffer_) {
2954                         owner_->getLyXFunc()->setErrorMessage(N_("No document open"));
2955                         break;
2956                 }
2957
2958                 if (buffer_->isReadonly()) {
2959                         owner_->getLyXFunc()->setErrorMessage(N_("Document is read only"));
2960                         break;
2961                 }
2962                 if (!argument.empty()) {
2963                         /* Automatically delete the currently selected
2964                          * text and replace it with what is being
2965                          * typed in now. Depends on lyxrc settings
2966                          * "auto_region_delete", which defaults to
2967                          * true (on). */
2968
2969                         if (lyxrc.auto_region_delete) {
2970                                 if (TEXT(bv_)->selection){
2971                                         TEXT(bv_)->CutSelection(bv_, false);
2972                                         update(TEXT(bv_),
2973                                                BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
2974                                 }
2975                         }
2976
2977                         beforeChange(TEXT(bv_));
2978                         LyXFont const old_font(TEXT(bv_)->real_current_font);
2979                         for (string::size_type i = 0;
2980                              i < argument.length(); ++i) {
2981                                 if (greek_kb_flag) {
2982                                         if (!math_insert_greek(bv_,
2983                                                                argument[i]))
2984                                                 owner_->getIntl()->getTrans().TranslateAndInsert(argument[i], TEXT(bv_));
2985                                 } else
2986                                         owner_->getIntl()->getTrans().TranslateAndInsert(argument[i], TEXT(bv_));
2987                         }
2988
2989                         update(TEXT(bv_),BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
2990
2991                         TEXT(bv_)->sel_cursor = TEXT(bv_)->cursor;
2992                         moveCursorUpdate(false);
2993
2994                         // real_current_font.number can change so we need to
2995                         // update the minibuffer
2996                         if (old_font != TEXT(bv_)->real_current_font)
2997                                 owner_->showState();
2998                 } else {
2999                         // if we don't have an argument there was something
3000                         // strange going on so we just tell this to someone!
3001                         owner_->getLyXFunc()->setErrorMessage(N_("No argument givven"));
3002                 }
3003                 break;
3004         }
3005         default:
3006                 return false;
3007         } // end of switch
3008
3009         return true;
3010 }