src/mathed/math_cursor.C

   1 /**
   2  * \file math_cursor.C
   3  * This file is part of LyX, the document processor.
   4  * Licence details can be found in the file COPYING.
   5  *
   6  * \author Alejandro Aguilar Sierra
   7  * \author André Pönitz
   8  *
   9  * Full author contact details are available in file CREDITS.
  10  */
  11
  12 #include <config.h>
  13
  14 #include "lyxrc.h"
  15 #include "support/LAssert.h"
  16 #include "support/limited_stack.h"
  17 #include "debug.h"
  18 #include "support/std_sstream.h"
  19 #include "math_cursor.h"
  20 #include "formulabase.h"
  21 #include "funcrequest.h"
  22 #include "math_braceinset.h"
  23 #include "math_commentinset.h"
  24 #include "math_charinset.h"
  25 #include "math_factory.h"
  26 #include "math_gridinset.h"
  27 #include "math_macroarg.h"
  28 #include "math_macrotemplate.h"
  29 #include "math_mathmlstream.h"
  30 #include "math_scriptinset.h"
  31 #include "math_spaceinset.h"
  32 #include "math_support.h"
  33 #include "math_unknowninset.h"
  34
  35
  36 //#define FILEDEBUG 1
  37
  38 using namespace lyx::support;
  39
  40 using std::endl;
  41 using std::isalpha;
  42 using std::min;
  43 using std::swap;
  44
  45 using std::ostringstream;
  46
  47
  48 // matheds own cut buffer
  49 limited_stack<string> theCutBuffer;
  50
  51
  52 MathCursor::MathCursor(InsetFormulaBase * formula, bool front)
  53         :       formula_(formula), autocorrect_(false), selection_(false), targetx_(-1)
  54 {
  55         front ? first() : last();
  56         Anchor_ = Cursor_;
  57 }
  58
  59
  60 MathCursor::~MathCursor()
  61 {
  62         // ensure that 'notifyCursorLeave' is called
  63         while (popLeft())
  64                 ;
  65 }
  66
  67
  68 void MathCursor::push(MathAtom & t)
  69 {
  70         Cursor_.push_back(CursorPos(t.nucleus()));
  71 }
  72
  73
  74 void MathCursor::pushLeft(MathAtom & t)
  75 {
  76         //lyxerr << "Entering atom " << t << " left" << endl;
  77         push(t);
  78         t->idxFirst(idx(), pos());
  79 }
  80
  81
  82 void MathCursor::pushRight(MathAtom & t)
  83 {
  84         //lyxerr << "Entering atom " << t << " right" << endl;
  85         posLeft();
  86         push(t);
  87         t->idxLast(idx(), pos());
  88 }
  89
  90
  91 bool MathCursor::popLeft()
  92 {
  93         //lyxerr << "Leaving atom to the left" << endl;
  94         if (depth() <= 1) {
  95                 if (depth() == 1)
  96                         inset()->notifyCursorLeaves(idx());
  97                 return false;
  98         }
  99         inset()->notifyCursorLeaves(idx());
 100         Cursor_.pop_back();
 101         return true;
 102 }
 103
 104
 105 bool MathCursor::popRight()
 106 {
 107         //lyxerr << "Leaving atom "; inset()->write(cerr, false); cerr << " right" << endl;
 108         if (depth() <= 1) {
 109                 if (depth() == 1)
 110                         inset()->notifyCursorLeaves(idx());
 111                 return false;
 112         }
 113         inset()->notifyCursorLeaves(idx());
 114         Cursor_.pop_back();
 115         posRight();
 116         return true;
 117 }
 118
 119
 120
 121 #if FILEDEBUG
 122         void MathCursor::dump(char const * what) const
 123         {
 124                 lyxerr << "MC: " << what << endl;
 125                 lyxerr << " Cursor: " << depth() << endl;
 126                 for (unsigned i = 0; i < depth(); ++i)
 127                         lyxerr << "    i: " << i << ' ' << Cursor_[i] << endl;
 128                 lyxerr << " Anchor: " << Anchor_.size() << endl;
 129                 for (unsigned i = 0; i < Anchor_.size(); ++i)
 130                         lyxerr << "    i: " << i << ' ' << Anchor_[i] << endl;
 131                 lyxerr  << " sel: " << selection_ << endl;
 132         }
 133 #else
 134         void MathCursor::dump(char const *) const {}
 135 #endif
 136
 137
 138 bool MathCursor::isInside(MathInset const * p) const
 139 {
 140         for (unsigned i = 0; i < depth(); ++i)
 141                 if (Cursor_[i].inset_ == p)
 142                         return true;
 143         return false;
 144 }
 145
 146
 147 bool MathCursor::openable(MathAtom const & t, bool sel) const
 148 {
 149         if (!t->isActive())
 150                 return false;
 151
 152         if (t->lock())
 153                 return false;
 154
 155         if (sel) {
 156                 // we can't move into anything new during selection
 157                 if (depth() == Anchor_.size())
 158                         return false;
 159                 if (t.operator->() != Anchor_[depth()].inset_)
 160                         return false;
 161         }
 162         return true;
 163 }
 164
 165
 166 bool MathCursor::inNucleus() const
 167 {
 168         return inset()->asScriptInset() && idx() == 2;
 169 }
 170
 171
 172 bool MathCursor::posLeft()
 173 {
 174         if (pos() == 0)
 175                 return false;
 176         --pos();
 177         return true;
 178 }
 179
 180
 181 bool MathCursor::posRight()
 182 {
 183         if (pos() == size())
 184                 return false;
 185         ++pos();
 186         return true;
 187 }
 188
 189
 190 bool MathCursor::left(bool sel)
 191 {
 192         dump("Left 1");
 193         autocorrect_ = false;
 194         targetx_ = -1; // "no target"
 195         if (inMacroMode()) {
 196                 macroModeClose();
 197                 return true;
 198         }
 199         selHandle(sel);
 200
 201         if (hasPrevAtom() && openable(prevAtom(), sel)) {
 202                 pushRight(prevAtom());
 203                 return true;
 204         }
 205
 206         return posLeft() || idxLeft() || popLeft() || selection_;
 207 }
 208
 209
 210 bool MathCursor::right(bool sel)
 211 {
 212         dump("Right 1");
 213         autocorrect_ = false;
 214         targetx_ = -1; // "no target"
 215         if (inMacroMode()) {
 216                 macroModeClose();
 217                 return true;
 218         }
 219         selHandle(sel);
 220
 221         if (hasNextAtom() && openable(nextAtom(), sel)) {
 222                 pushLeft(nextAtom());
 223                 return true;
 224         }
 225
 226         return posRight() || idxRight() || popRight() || selection_;
 227 }
 228
 229
 230 void MathCursor::first()
 231 {
 232         Cursor_.clear();
 233         push(formula_->par());
 234         inset()->idxFirst(idx(), pos());
 235 }
 236
 237
 238 void MathCursor::last()
 239 {
 240         Cursor_.clear();
 241         push(formula_->par());
 242         inset()->idxLast(idx(), pos());
 243 }
 244
 245
 246 bool positionable
 247         (MathIterator const & cursor, MathIterator const & anchor)
 248 {
 249         // avoid deeper nested insets when selecting
 250         if (cursor.size() > anchor.size())
 251                 return false;
 252
 253         // anchor might be deeper, should have same path then
 254         for (MathIterator::size_type i = 0; i < cursor.size(); ++i)
 255                 if (cursor[i].inset_ != anchor[i].inset_)
 256                         return false;
 257
 258         // position should be ok.
 259         return true;
 260 }
 261
 262
 263 void MathCursor::setPos(int x, int y)
 264 {
 265         dump("setPos 1");
 266         bool res = bruteFind(x, y,
 267                 formula()->xlow(), formula()->xhigh(),
 268                 formula()->ylow(), formula()->yhigh());
 269         if (!res) {
 270                 // this can happen on creation of "math-display"
 271                 dump("setPos 1.5");
 272                 first();
 273         }
 274         targetx_ = -1; // "no target"
 275         dump("setPos 2");
 276 }
 277
 278
 279
 280 bool MathCursor::home(bool sel)
 281 {
 282         dump("home 1");
 283         autocorrect_ = false;
 284         selHandle(sel);
 285         macroModeClose();
 286         if (!inset()->idxHome(idx(), pos()))
 287                 return popLeft();
 288         dump("home 2");
 289         targetx_ = -1; // "no target"
 290         return true;
 291 }
 292
 293
 294 bool MathCursor::end(bool sel)
 295 {
 296         dump("end 1");
 297         autocorrect_ = false;
 298         selHandle(sel);
 299         macroModeClose();
 300         if (!inset()->idxEnd(idx(), pos()))
 301                 return popRight();
 302         dump("end 2");
 303         targetx_ = -1; // "no target"
 304         return true;
 305 }
 306
 307
 308 void MathCursor::plainErase()
 309 {
 310         array().erase(pos());
 311 }
 312
 313
 314 void MathCursor::markInsert()
 315 {
 316         //lyxerr << "inserting mark" << endl;
 317         array().insert(pos(), MathAtom(new MathCharInset(0)));
 318 }
 319
 320
 321 void MathCursor::markErase()
 322 {
 323         //lyxerr << "deleting mark" << endl;
 324         array().erase(pos());
 325 }
 326
 327
 328 void MathCursor::plainInsert(MathAtom const & t)
 329 {
 330         dump("plainInsert");
 331         array().insert(pos(), t);
 332         ++pos();
 333 }
 334
 335
 336 void MathCursor::insert2(string const & str)
 337 {
 338         MathArray ar;
 339         asArray(str, ar);
 340         insert(ar);
 341 }
 342
 343
 344 void MathCursor::insert(string const & str)
 345 {
 346         //lyxerr << "inserting '" << str << "'" << endl;
 347         selClearOrDel();
 348         for (string::const_iterator it = str.begin(); it != str.end(); ++it)
 349                 plainInsert(MathAtom(new MathCharInset(*it)));
 350 }
 351
 352
 353 void MathCursor::insert(char c)
 354 {
 355         //lyxerr << "inserting '" << c << "'" << endl;
 356         selClearOrDel();
 357         plainInsert(MathAtom(new MathCharInset(c)));
 358 }
 359
 360
 361 void MathCursor::insert(MathAtom const & t)
 362 {
 363         macroModeClose();
 364         selClearOrDel();
 365         plainInsert(t);
 366 }
 367
 368
 369 void MathCursor::niceInsert(string const & t)
 370 {
 371         MathArray ar;
 372         asArray(t, ar);
 373         if (ar.size() == 1)
 374                 niceInsert(ar[0]);
 375         else
 376                 insert(ar);
 377 }
 378
 379
 380 void MathCursor::niceInsert(MathAtom const & t)
 381 {
 382         macroModeClose();
 383         string safe = grabAndEraseSelection();
 384         plainInsert(t);
 385         // enter the new inset and move the contents of the selection if possible
 386         if (t->isActive()) {
 387                 posLeft();
 388                 pushLeft(nextAtom());
 389                 paste(safe);
 390         }
 391 }
 392
 393
 394 void MathCursor::insert(MathArray const & ar)
 395 {
 396         macroModeClose();
 397         if (selection_)
 398                 eraseSelection();
 399         array().insert(pos(), ar);
 400         pos() += ar.size();
 401 }
 402
 403
 404 void MathCursor::paste(string const & data)
 405 {
 406         dispatch(FuncRequest(LFUN_PASTE, data));
 407 }
 408
 409
 410 bool MathCursor::backspace()
 411 {
 412         autocorrect_ = false;
 413
 414         if (selection_) {
 415                 selDel();
 416                 return true;
 417         }
 418
 419         if (pos() == 0) {
 420                 if (inset()->ncols() == 1 &&
 421                           inset()->nrows() == 1 &&
 422                           depth() == 1 &&
 423                           size() == 0)
 424                         return false;
 425                 pullArg();
 426                 return true;
 427         }
 428
 429         if (inMacroMode()) {
 430                 MathUnknownInset * p = activeMacro();
 431                 if (p->name().size() > 1) {
 432                         p->setName(p->name().substr(0, p->name().size() - 1));
 433                         return true;
 434                 }
 435         }
 436
 437         --pos();
 438         plainErase();
 439         return true;
 440 }
 441
 442
 443 bool MathCursor::erase()
 444 {
 445         autocorrect_ = false;
 446         if (inMacroMode())
 447                 return true;
 448
 449         if (selection_) {
 450                 selDel();
 451                 return true;
 452         }
 453
 454         // delete empty cells if possible
 455         if (array().empty())
 456                 if (inset()->idxDelete(idx()))
 457                         return true;
 458
 459         // old behaviour when in last position of cell
 460         if (pos() == size()) {
 461                 if (inset()->ncols() == 1 && inset()->nrows() == 1 && depth() == 1 && size() == 0)
 462                         return false;
 463                 else{
 464                         inset()->idxGlue(idx());
 465                         return true;
 466                 }
 467         }
 468
 469         plainErase();
 470         return true;
 471 }
 472
 473
 474 bool MathCursor::up(bool sel)
 475 {
 476         dump("up 1");
 477         macroModeClose();
 478         selHandle(sel);
 479         MathIterator save = Cursor_;
 480         if (goUpDown(true))
 481                 return true;
 482         Cursor_ = save;
 483         autocorrect_ = false;
 484         return selection_;
 485 }
 486
 487
 488 bool MathCursor::down(bool sel)
 489 {
 490         dump("down 1");
 491         macroModeClose();
 492         selHandle(sel);
 493         MathIterator save = Cursor_;
 494         if (goUpDown(false))
 495                 return true;
 496         Cursor_ = save;
 497         autocorrect_ = false;
 498         return selection_;
 499 }
 500
 501
 502 void MathCursor::macroModeClose()
 503 {
 504         if (!inMacroMode())
 505                 return;
 506         MathUnknownInset * p = activeMacro();
 507         p->finalize();
 508         string s = p->name();
 509         --pos();
 510         array().erase(pos());
 511
 512         // do nothing if the macro name is empty
 513         if (s == "\\")
 514                 return;
 515
 516         string const name = s.substr(1);
 517
 518         // prevent entering of recursive macros
 519         if (formula()->lyxCode() == InsetOld::MATHMACRO_CODE
 520                         && formula()->getInsetName() == name)
 521                 lyxerr << "can't enter recursive macro" << endl;
 522
 523         niceInsert(createMathInset(name));
 524 }
 525
 526
 527 string MathCursor::macroName() const
 528 {
 529         return inMacroMode() ? activeMacro()->name() : string();
 530 }
 531
 532
 533 void MathCursor::selClear()
 534 {
 535         Anchor_.clear();
 536         selection_ = false;
 537 }
 538
 539
 540 void MathCursor::selCopy()
 541 {
 542         dump("selCopy");
 543         if (selection_) {
 544                 theCutBuffer.push(grabSelection());
 545                 selection_ = false;
 546         } else {
 547                 //theCutBuffer.erase();
 548         }
 549 }
 550
 551
 552 void MathCursor::selCut()
 553 {
 554         dump("selCut");
 555         theCutBuffer.push(grabAndEraseSelection());
 556 }
 557
 558
 559 void MathCursor::selDel()
 560 {
 561         dump("selDel");
 562         if (selection_) {
 563                 eraseSelection();
 564                 selection_ = false;
 565         }
 566 }
 567
 568
 569 void MathCursor::selPaste(size_t n)
 570 {
 571         dump("selPaste");
 572         selClearOrDel();
 573         if (n < theCutBuffer.size())
 574                 paste(theCutBuffer[n]);
 575         //grabSelection();
 576         selection_ = false;
 577 }
 578
 579
 580 void MathCursor::selHandle(bool sel)
 581 {
 582         if (sel == selection_)
 583                 return;
 584         //clear();
 585         Anchor_ = Cursor_;
 586         selection_ = sel;
 587 }
 588
 589
 590 void MathCursor::selStart()
 591 {
 592         dump("selStart 1");
 593         //clear();
 594         Anchor_ = Cursor_;
 595         selection_ = true;
 596         dump("selStart 2");
 597 }
 598
 599
 600 void MathCursor::selClearOrDel()
 601 {
 602         if (lyxrc.auto_region_delete)
 603                 selDel();
 604         else
 605                 selection_ = false;
 606 }
 607
 608
 609 void MathCursor::drawSelection(PainterInfo & pi) const
 610 {
 611         if (!selection_)
 612                 return;
 613         CursorPos i1;
 614         CursorPos i2;
 615         getSelection(i1, i2);
 616         i1.inset_->drawSelection(pi, i1.idx_, i1.pos_, i2.idx_, i2.pos_);
 617 }
 618
 619
 620 void MathCursor::handleNest(MathAtom const & a)
 621 {
 622         MathAtom at = a;
 623         asArray(grabAndEraseSelection(), at.nucleus()->cell(0));
 624         insert(at);
 625         pushRight(prevAtom());
 626 }
 627
 628
 629 void MathCursor::getPos(int & x, int & y) const
 630 {
 631         inset()->getPos(idx(), pos(), x, y);
 632 }
 633
 634
 635 int MathCursor::targetX() const
 636 {
 637         if (targetx_ != -1)
 638                 return targetx_;
 639         int x = 0, y = 0;
 640         getPos(x, y);
 641         return x;
 642 }
 643
 644
 645 MathInset * MathCursor::inset() const
 646 {
 647         return cursor().inset_;
 648 }
 649
 650
 651 InsetFormulaBase * MathCursor::formula() const
 652 {
 653         return formula_;
 654 }
 655
 656
 657 MathCursor::idx_type MathCursor::idx() const
 658 {
 659         return cursor().idx_;
 660 }
 661
 662
 663 MathCursor::idx_type & MathCursor::idx()
 664 {
 665         return cursor().idx_;
 666 }
 667
 668
 669 MathCursor::pos_type MathCursor::pos() const
 670 {
 671         return cursor().pos_;
 672 }
 673
 674
 675 void MathCursor::adjust(pos_type from, difference_type diff)
 676 {
 677         if (cursor().pos_ > from)
 678                 cursor().pos_ += diff;
 679         if (Anchor_.back().pos_ > from)
 680                 Anchor_.back().pos_ += diff;
 681         // just to be on the safe side
 682         // theoretically unecessary
 683         normalize();
 684 }
 685
 686
 687 MathCursor::pos_type & MathCursor::pos()
 688 {
 689         return cursor().pos_;
 690 }
 691
 692
 693 bool MathCursor::inMacroMode() const
 694 {
 695         if (!hasPrevAtom())
 696                 return false;
 697         MathUnknownInset const * p = prevAtom()->asUnknownInset();
 698         return p && !p->final();
 699 }
 700
 701
 702 MathUnknownInset * MathCursor::activeMacro()
 703 {
 704         return inMacroMode() ? prevAtom().nucleus()->asUnknownInset() : 0;
 705 }
 706
 707
 708 MathUnknownInset const * MathCursor::activeMacro() const
 709 {
 710         return inMacroMode() ? prevAtom()->asUnknownInset() : 0;
 711 }
 712
 713
 714 bool MathCursor::inMacroArgMode() const
 715 {
 716         return pos() > 0 && prevAtom()->getChar() == '#';
 717 }
 718
 719
 720 bool MathCursor::selection() const
 721 {
 722         return selection_;
 723 }
 724
 725
 726 MathGridInset * MathCursor::enclosingGrid(MathCursor::idx_type & idx) const
 727 {
 728         for (MathInset::difference_type i = depth() - 1; i >= 0; --i) {
 729                 MathGridInset * p = Cursor_[i].inset_->asGridInset();
 730                 if (p) {
 731                         idx = Cursor_[i].idx_;
 732                         return p;
 733                 }
 734         }
 735         return 0;
 736 }
 737
 738
 739 void MathCursor::popToHere(MathInset const * p)
 740 {
 741         while (depth() && Cursor_.back().inset_ != p)
 742                 Cursor_.pop_back();
 743 }
 744
 745
 746 void MathCursor::popToEnclosingGrid()
 747 {
 748         while (depth() && !Cursor_.back().inset_->asGridInset())
 749                 Cursor_.pop_back();
 750 }
 751
 752
 753 void MathCursor::popToEnclosingHull()
 754 {
 755         while (depth() && !Cursor_.back().inset_->asHullInset())
 756                 Cursor_.pop_back();
 757 }
 758
 759
 760 void MathCursor::pullArg()
 761 {
 762         dump("pullarg");
 763         MathArray a = array();
 764         if (popLeft()) {
 765                 plainErase();
 766                 array().insert(pos(), a);
 767                 Anchor_ = Cursor_;
 768         } else {
 769                 formula()->mutateToText();
 770         }
 771 }
 772
 773
 774 void MathCursor::touch()
 775 {
 776         MathIterator::const_iterator it = Cursor_.begin();
 777         MathIterator::const_iterator et = Cursor_.end();
 778         for ( ; it != et; ++it)
 779                 it->cell().touch();
 780 }
 781
 782
 783 void MathCursor::normalize()
 784 {
 785         if (idx() >= inset()->nargs()) {
 786                 lyxerr << "this should not really happen - 1: "
 787                        << idx() << ' ' << inset()->nargs()
 788                        << " in: " << inset() << endl;
 789                 dump("error 2");
 790         }
 791         idx() = min(idx(), inset()->nargs() - 1);
 792
 793         if (pos() > size()) {
 794                 lyxerr << "this should not really happen - 2: "
 795                         << pos() << ' ' << size() <<  " in idx: " << idx()
 796                        << " in atom: '";
 797                 WriteStream wi(lyxerr, false, true);
 798                 inset()->write(wi);
 799                 lyxerr << endl;
 800                 dump("error 4");
 801         }
 802         pos() = min(pos(), size());
 803 }
 804
 805
 806 MathCursor::size_type MathCursor::size() const
 807 {
 808         return array().size();
 809 }
 810
 811
 812 bool MathCursor::hasPrevAtom() const
 813 {
 814         return pos() > 0;
 815 }
 816
 817
 818 bool MathCursor::hasNextAtom() const
 819 {
 820         return pos() < size();
 821 }
 822
 823
 824 MathAtom const & MathCursor::prevAtom() const
 825 {
 826         Assert(pos() > 0);
 827         return array()[pos() - 1];
 828 }
 829
 830
 831 MathAtom & MathCursor::prevAtom()
 832 {
 833         Assert(pos() > 0);
 834         return array()[pos() - 1];
 835 }
 836
 837
 838 MathAtom const & MathCursor::nextAtom() const
 839 {
 840         Assert(pos() < size());
 841         return array()[pos()];
 842 }
 843
 844
 845 MathAtom & MathCursor::nextAtom()
 846 {
 847         Assert(pos() < size());
 848         return array()[pos()];
 849 }
 850
 851
 852 MathArray & MathCursor::array() const
 853 {
 854         static MathArray dummy;
 855
 856         if (idx() >= inset()->nargs()) {
 857                 lyxerr << "############  idx_ " << idx() << " not valid" << endl;
 858                 return dummy;
 859         }
 860
 861         if (depth() == 0) {
 862                 lyxerr << "############  depth() == 0 not valid" << endl;
 863                 return dummy;
 864         }
 865
 866         return cursor().cell();
 867 }
 868
 869
 870 void MathCursor::idxNext()
 871 {
 872         inset()->idxNext(idx(), pos());
 873 }
 874
 875
 876 void MathCursor::idxPrev()
 877 {
 878         inset()->idxPrev(idx(), pos());
 879 }
 880
 881
 882 char MathCursor::valign() const
 883 {
 884         idx_type idx;
 885         MathGridInset * p = enclosingGrid(idx);
 886         return p ? p->valign() : '\0';
 887 }
 888
 889
 890 char MathCursor::halign() const
 891 {
 892         idx_type idx;
 893         MathGridInset * p = enclosingGrid(idx);
 894         return p ? p->halign(idx % p->ncols()) : '\0';
 895 }
 896
 897
 898 void MathCursor::getSelection(CursorPos & i1, CursorPos & i2) const
 899 {
 900         CursorPos anc = normalAnchor();
 901         if (anc < cursor()) {
 902                 i1 = anc;
 903                 i2 = cursor();
 904         } else {
 905                 i1 = cursor();
 906                 i2 = anc;
 907         }
 908 }
 909
 910
 911 CursorPos & MathCursor::cursor()
 912 {
 913         Assert(depth());
 914         return Cursor_.back();
 915 }
 916
 917
 918 CursorPos const & MathCursor::cursor() const
 919 {
 920         Assert(depth());
 921         return Cursor_.back();
 922 }
 923
 924
 925 bool MathCursor::goUpDown(bool up)
 926 {
 927         // Be warned: The 'logic' implemented in this function is highly fragile.
 928         // A distance of one pixel or a '<' vs '<=' _really_ matters.
 929         // So fiddle around with it only if you know what you are doing!
 930   int xo = 0;
 931         int yo = 0;
 932         getPos(xo, yo);
 933
 934         // check if we had something else in mind, if not, this is the future goal
 935         if (targetx_ == -1)
 936                 targetx_ = xo;
 937         else
 938                 xo = targetx_;
 939
 940         // try neigbouring script insets
 941         // try left
 942         if (hasPrevAtom()) {
 943                 MathScriptInset const * p = prevAtom()->asScriptInset();
 944                 if (p && p->has(up)) {
 945                         --pos();
 946                         push(nextAtom());
 947                         idx() = up; // the superscript has index 1
 948                         pos() = size();
 949                         ///lyxerr << "updown: handled by scriptinset to the left" << endl;
 950                         return true;
 951                 }
 952         }
 953
 954         // try right
 955         if (hasNextAtom()) {
 956                 MathScriptInset const * p = nextAtom()->asScriptInset();
 957                 if (p && p->has(up)) {
 958                         push(nextAtom());
 959                         idx() = up;
 960                         pos() = 0;
 961                         ///lyxerr << "updown: handled by scriptinset to the right" << endl;
 962                         return true;
 963                 }
 964         }
 965
 966         // try current cell for e.g. text insets
 967         if (inset()->idxUpDown2(idx(), pos(), up, targetx_))
 968                 return true;
 969
 970         //xarray().boundingBox(xlow, xhigh, ylow, yhigh);
 971         //if (up)
 972         //      yhigh = yo - 4;
 973         //else
 974         //      ylow = yo + 4;
 975         //if (bruteFind(xo, yo, xlow, xhigh, ylow, yhigh)) {
 976         //      lyxerr << "updown: handled by brute find in the same cell" << endl;
 977         //      return true;
 978         //}
 979
 980         // try to find an inset that knows better then we
 981         while (1) {
 982                 ///lyxerr << "updown: We are in " << *inset() << " idx: " << idx() << endl;
 983                 // ask inset first
 984                 if (inset()->idxUpDown(idx(), pos(), up, targetx_)) {
 985                         // try to find best position within this inset
 986                         if (!selection())
 987                                 bruteFind2(xo, yo);
 988                         return true;
 989                 }
 990
 991                 // no such inset found, just take something "above"
 992                 ///lyxerr << "updown: handled by strange case" << endl;
 993                 if (!popLeft())
 994                         return
 995                                 bruteFind(xo, yo,
 996                                         formula()->xlow(),
 997                                         formula()->xhigh(),
 998                                         up ? formula()->ylow() : yo + 4,
 999                                         up ? yo - 4 : formula()->yhigh()
1000                                 );
1001
1002                 // any improvement so far?
1003                 int xnew, ynew;
1004                 getPos(xnew, ynew);
1005                 if (up ? ynew < yo : ynew > yo)
1006                         return true;
1007         }
1008 }
1009
1010
1011 bool MathCursor::bruteFind
1012         (int x, int y, int xlow, int xhigh, int ylow, int yhigh)
1013 {
1014         MathIterator best_cursor;
1015         double best_dist = 1e10;
1016
1017         MathIterator it = ibegin(formula()->par().nucleus());
1018         MathIterator et = iend(formula()->par().nucleus());
1019         while (1) {
1020                 // avoid invalid nesting when selecting
1021                 if (!selection_ || positionable(it, Anchor_)) {
1022                         int xo, yo;
1023                         it.back().getPos(xo, yo);
1024                         if (xlow <= xo && xo <= xhigh && ylow <= yo && yo <= yhigh) {
1025                                 double d = (x - xo) * (x - xo) + (y - yo) * (y - yo);
1026                                 //lyxerr << "x: " << x << " y: " << y << " d: " << endl;
1027                                 // '<=' in order to take the last possible position
1028                                 // this is important for clicking behind \sum in e.g. '\sum_i a'
1029                                 if (d <= best_dist) {
1030                                         best_dist   = d;
1031                                         best_cursor = it;
1032                                 }
1033                         }
1034                 }
1035
1036                 if (it == et)
1037                         break;
1038                 ++it;
1039         }
1040
1041         if (best_dist < 1e10)
1042                 Cursor_ = best_cursor;
1043         return best_dist < 1e10;
1044 }
1045
1046
1047 void MathCursor::bruteFind2(int x, int y)
1048 {
1049         double best_dist = 1e10;
1050
1051         MathIterator it = Cursor_;
1052         it.back().setPos(0);
1053         MathIterator et = Cursor_;
1054         et.back().setPos(it.cell().size());
1055         for (int i = 0; ; ++i) {
1056                 int xo, yo;
1057                 it.back().getPos(xo, yo);
1058                 double d = (x - xo) * (x - xo) + (y - yo) * (y - yo);
1059                 // '<=' in order to take the last possible position
1060                 // this is important for clicking behind \sum in e.g. '\sum_i a'
1061                 lyxerr << "i: " << i << " d: " << d << " best: " << best_dist << endl;
1062                 if (d <= best_dist) {
1063                         best_dist = d;
1064                         Cursor_   = it;
1065                 }
1066                 if (it == et)
1067                         break;
1068                 ++it;
1069         }
1070 }
1071
1072
1073 bool MathCursor::idxLineLast()
1074 {
1075         idx() -= idx() % inset()->ncols();
1076         idx() += inset()->ncols() - 1;
1077         pos() = size();
1078         return true;
1079 }
1080
1081 bool MathCursor::idxLeft()
1082 {
1083         return inset()->idxLeft(idx(), pos());
1084 }
1085
1086
1087 bool MathCursor::idxRight()
1088 {
1089         return inset()->idxRight(idx(), pos());
1090 }
1091
1092
1093 bool MathCursor::script(bool up)
1094 {
1095         // Hack to get \\^ and \\_ working
1096         if (inMacroMode() && macroName() == "\\") {
1097                 if (up)
1098                         niceInsert(createMathInset("mathcircumflex"));
1099                 else
1100                         interpret('_');
1101                 return true;
1102         }
1103
1104         macroModeClose();
1105         string safe = grabAndEraseSelection();
1106         if (inNucleus()) {
1107                 // we are in a nucleus of a script inset, move to _our_ script
1108                 inset()->asScriptInset()->ensure(up);
1109                 idx() = up;
1110                 pos() = 0;
1111         } else if (hasPrevAtom() && prevAtom()->asScriptInset()) {
1112                 prevAtom().nucleus()->asScriptInset()->ensure(up);
1113                 pushRight(prevAtom());
1114                 idx() = up;
1115                 pos() = size();
1116         } else if (hasPrevAtom()) {
1117                 --pos();
1118                 array()[pos()] = MathAtom(new MathScriptInset(nextAtom(), up));
1119                 pushLeft(nextAtom());
1120                 idx() = up;
1121                 pos() = 0;
1122         } else {
1123                 plainInsert(MathAtom(new MathScriptInset(up)));
1124                 prevAtom().nucleus()->asScriptInset()->ensure(up);
1125                 pushRight(prevAtom());
1126                 idx() = up;
1127                 pos() = 0;
1128         }
1129         paste(safe);
1130         dump("1");
1131         return true;
1132 }
1133
1134
1135 bool MathCursor::interpret(char c)
1136 {
1137         //lyxerr << "interpret 2: '" << c << "'" << endl;
1138         targetx_ = -1; // "no target"
1139         if (inMacroArgMode()) {
1140                 --pos();
1141                 plainErase();
1142                 int n = c - '0';
1143                 MathMacroTemplate const * p = formula()->par()->asMacroTemplate();
1144                 if (p && 1 <= n && n <= p->numargs())
1145                         insert(MathAtom(new MathMacroArgument(c - '0')));
1146                 else {
1147                         insert(createMathInset("#"));
1148                         interpret(c); // try again
1149                 }
1150                 return true;
1151         }
1152
1153         // handle macroMode
1154         if (inMacroMode()) {
1155                 string name = macroName();
1156                 //lyxerr << "interpret name: '" << name << "'" << endl;
1157
1158                 if (isalpha(c)) {
1159                         activeMacro()->setName(activeMacro()->name() + c);
1160                         return true;
1161                 }
1162
1163                 // handle 'special char' macros
1164                 if (name == "\\") {
1165                         // remove the '\\'
1166                         backspace();
1167                         if (c == '\\') {
1168                                 if (currentMode() == MathInset::TEXT_MODE)
1169                                         niceInsert(createMathInset("textbackslash"));
1170                                 else
1171                                         niceInsert(createMathInset("backslash"));
1172                         } else if (c == '{') {
1173                                 niceInsert(MathAtom(new MathBraceInset));
1174                         } else {
1175                                 niceInsert(createMathInset(string(1, c)));
1176                         }
1177                         return true;
1178                 }
1179
1180                 // leave macro mode and try again if necessary
1181                 macroModeClose();
1182                 if (c == '{')
1183                         niceInsert(MathAtom(new MathBraceInset));
1184                 else if (c != ' ')
1185                         interpret(c);
1186                 return true;
1187         }
1188
1189         // This is annoying as one has to press <space> far too often.
1190         // Disable it.
1191
1192         if (0) {
1193                 // leave autocorrect mode if necessary
1194                 if (autocorrect_ && c == ' ') {
1195                         autocorrect_ = false;
1196                         return true;
1197                 }
1198         }
1199
1200         // just clear selection on pressing the space bar
1201         if (selection_ && c == ' ') {
1202                 selection_ = false;
1203                 return true;
1204         }
1205
1206         selClearOrDel();
1207
1208         if (c == '\\') {
1209                 //lyxerr << "starting with macro" << endl;
1210                 insert(MathAtom(new MathUnknownInset("\\", false)));
1211                 return true;
1212         }
1213
1214         if (c == '\n') {
1215                 if (currentMode() == MathInset::TEXT_MODE)
1216                         insert(c);
1217                 return true;
1218         }
1219
1220         if (c == ' ') {
1221                 if (currentMode() == MathInset::TEXT_MODE) {
1222                         // insert spaces in text mode,
1223                         // but suppress direct insertion of two spaces in a row
1224                         // the still allows typing  '<space>a<space>' and deleting the 'a', but
1225                         // it is better than nothing...
1226                         if (!hasPrevAtom() || prevAtom()->getChar() != ' ')
1227                                 insert(c);
1228                         return true;
1229                 }
1230                 if (hasPrevAtom() && prevAtom()->asSpaceInset()) {
1231                         prevAtom().nucleus()->asSpaceInset()->incSpace();
1232                         return true;
1233                 }
1234                 if (popRight())
1235                         return true;
1236                 // if are at the very end, leave the formula
1237                 return pos() != size();
1238         }
1239
1240         if (c == '{' || c == '}' || c == '#' || c == '&' || c == '$') {
1241                 createMathInset(string(1, c));
1242                 return true;
1243         }
1244
1245         if (c == '%') {
1246                 niceInsert(MathAtom(new MathCommentInset));
1247                 return true;
1248         }
1249
1250         // try auto-correction
1251         //if (autocorrect_ && hasPrevAtom() && math_autocorrect(prevAtom(), c))
1252         //      return true;
1253
1254         // no special circumstances, so insert the character without any fuss
1255         insert(c);
1256         autocorrect_ = true;
1257         return true;
1258 }
1259
1260
1261 void MathCursor::setSelection(MathIterator const & where, size_type n)
1262 {
1263         selection_ = true;
1264         Anchor_ = where;
1265         Cursor_ = where;
1266         cursor().pos_ += n;
1267 }
1268
1269
1270 void MathCursor::insetToggle()
1271 {
1272         if (hasNextAtom()) {
1273                 // toggle previous inset ...
1274                 nextAtom().nucleus()->lock(!nextAtom()->lock());
1275         } else if (popLeft() && hasNextAtom()) {
1276                 // ... or enclosing inset if we are in the last inset position
1277                 nextAtom().nucleus()->lock(!nextAtom()->lock());
1278                 posRight();
1279         }
1280 }
1281
1282
1283 string MathCursor::info() const
1284 {
1285         ostringstream os;
1286         os << "Math editor mode.  ";
1287         for (int i = 0, n = depth(); i < n; ++i) {
1288                 Cursor_[i].inset_->infoize(os);
1289                 os << "  ";
1290         }
1291         if (hasPrevAtom())
1292                 prevAtom()->infoize2(os);
1293         os << "                    ";
1294         return STRCONV(os.str());
1295 }
1296
1297
1298 unsigned MathCursor::depth() const
1299 {
1300         return Cursor_.size();
1301 }
1302
1303
1304
1305
1306 namespace {
1307
1308 void region(CursorPos const & i1, CursorPos const & i2,
1309         MathInset::row_type & r1, MathInset::row_type & r2,
1310         MathInset::col_type & c1, MathInset::col_type & c2)
1311 {
1312         MathInset * p = i1.inset_;
1313         c1 = p->col(i1.idx_);
1314         c2 = p->col(i2.idx_);
1315         if (c1 > c2)
1316                 swap(c1, c2);
1317         r1 = p->row(i1.idx_);
1318         r2 = p->row(i2.idx_);
1319         if (r1 > r2)
1320                 swap(r1, r2);
1321 }
1322
1323 }
1324
1325
1326 string MathCursor::grabSelection() const
1327 {
1328         if (!selection_)
1329                 return string();
1330
1331         CursorPos i1;
1332         CursorPos i2;
1333         getSelection(i1, i2);
1334
1335         if (i1.idx_ == i2.idx_) {
1336                 MathArray::const_iterator it = i1.cell().begin();
1337                 return asString(MathArray(it + i1.pos_, it + i2.pos_));
1338         }
1339
1340         row_type r1, r2;
1341         col_type c1, c2;
1342         region(i1, i2, r1, r2, c1, c2);
1343
1344         string data;
1345         for (row_type row = r1; row <= r2; ++row) {
1346                 if (row > r1)
1347                         data += "\\\\";
1348                 for (col_type col = c1; col <= c2; ++col) {
1349                         if (col > c1)
1350                                 data += '&';
1351                         data += asString(i1.inset_->cell(i1.inset_->index(row, col)));
1352                 }
1353         }
1354         return data;
1355 }
1356
1357
1358 void MathCursor::eraseSelection()
1359 {
1360         CursorPos i1;
1361         CursorPos i2;
1362         getSelection(i1, i2);
1363         if (i1.idx_ == i2.idx_)
1364                 i1.cell().erase(i1.pos_, i2.pos_);
1365         else {
1366                 MathInset * p = i1.inset_;
1367                 row_type r1, r2;
1368                 col_type c1, c2;
1369                 region(i1, i2, r1, r2, c1, c2);
1370                 for (row_type row = r1; row <= r2; ++row)
1371                         for (col_type col = c1; col <= c2; ++col)
1372                                 p->cell(p->index(row, col)).clear();
1373         }
1374         cursor() = i1;
1375 }
1376
1377
1378 string MathCursor::grabAndEraseSelection()
1379 {
1380         if (!selection_)
1381                 return string();
1382         string res = grabSelection();
1383         eraseSelection();
1384         selection_ = false;
1385         return res;
1386 }
1387
1388
1389 CursorPos MathCursor::normalAnchor() const
1390 {
1391         if (Anchor_.size() < depth()) {
1392                 Anchor_ = Cursor_;
1393                 lyxerr << "unusual Anchor size" << endl;
1394         }
1395         //lyx::Assert(Anchor_.size() >= cursor.depth());
1396         // use Anchor on the same level as Cursor
1397         CursorPos normal = Anchor_[depth() - 1];
1398         if (depth() < Anchor_.size() && !(normal < cursor())) {
1399                 // anchor is behind cursor -> move anchor behind the inset
1400                 ++normal.pos_;
1401         }
1402         return normal;
1403 }
1404
1405
1406 dispatch_result MathCursor::dispatch(FuncRequest const & cmd)
1407 {
1408         // mouse clicks are somewhat special
1409         // check
1410         switch (cmd.action) {
1411                 case LFUN_MOUSE_PRESS:
1412                 case LFUN_MOUSE_MOTION:
1413                 case LFUN_MOUSE_RELEASE:
1414                 case LFUN_MOUSE_DOUBLE: {
1415                         CursorPos & pos = Cursor_.back();
1416                         dispatch_result res = UNDISPATCHED;
1417                         int x = 0, y = 0;
1418                         getPos(x, y);
1419                         if (x < cmd.x && hasPrevAtom()) {
1420                                 res = prevAtom().nucleus()->dispatch(cmd, pos.idx_, pos.pos_);
1421                                 if (res != UNDISPATCHED)
1422                                         return res;
1423                         }
1424                         if (x > cmd.x && hasNextAtom()) {
1425                                 res = nextAtom().nucleus()->dispatch(cmd, pos.idx_, pos.pos_);
1426                                 if (res != UNDISPATCHED)
1427                                         return res;
1428                         }
1429                 }
1430                 default:
1431                         break;
1432         }
1433
1434         for (int i = Cursor_.size() - 1; i >= 0; --i) {
1435                 CursorPos & pos = Cursor_[i];
1436                 dispatch_result res = pos.inset_->dispatch(cmd, pos.idx_, pos.pos_);
1437                 if (res != UNDISPATCHED) {
1438                         if (res == DISPATCHED_POP) {
1439                                 Cursor_.shrink(i + 1);
1440                                 selClear();
1441                         }
1442                         return res;
1443                 }
1444         }
1445         return UNDISPATCHED;
1446 }
1447
1448
1449 MathInset::mode_type MathCursor::currentMode() const
1450 {
1451         for (int i = Cursor_.size() - 1; i >= 0; --i) {
1452                 MathInset::mode_type res = Cursor_[i].inset_->currentMode();
1453                 if (res != MathInset::UNDECIDED_MODE)
1454                         return res;
1455         }
1456         return MathInset::UNDECIDED_MODE;
1457 }
1458
1459
1460 void MathCursor::handleFont(string const & font)
1461 {
1462         string safe;
1463         if (selection()) {
1464                 macroModeClose();
1465                 safe = grabAndEraseSelection();
1466         }
1467
1468         if (array().size()) {
1469                 // something left in the cell
1470                 if (pos() == 0) {
1471                         // cursor in first position
1472                         popLeft();
1473                 } else if (pos() == array().size()) {
1474                         // cursor in last position
1475                         popRight();
1476                 } else {
1477                         // cursor in between. split cell
1478                         MathArray::iterator bt = array().begin();
1479                         MathAtom at = createMathInset(font);
1480                         at.nucleus()->cell(0) = MathArray(bt, bt + pos());
1481                         cursor().cell().erase(bt, bt + pos());
1482                         popLeft();
1483                         plainInsert(at);
1484                 }
1485         } else {
1486                 // nothing left in the cell
1487                 pullArg();
1488                 plainErase();
1489         }
1490         insert(safe);
1491 }
1492
1493
1494 void releaseMathCursor(BufferView * bv)
1495 {
1496         if (mathcursor) {
1497                 InsetFormulaBase * f =  mathcursor->formula();
1498                 delete mathcursor;
1499                 mathcursor = 0;
1500                 f->insetUnlock(bv);
1501         }
1502 }