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/limited_stack.h"
  16 #include "debug.h"
  17 #include "support/std_sstream.h"
  18 #include "math_cursor.h"
  19 #include "formulabase.h"
  20 #include "funcrequest.h"
  21 #include "math_braceinset.h"
  22 #include "math_commentinset.h"
  23 #include "math_charinset.h"
  24 #include "math_factory.h"
  25 #include "math_gridinset.h"
  26 #include "math_macroarg.h"
  27 #include "math_macrotemplate.h"
  28 #include "math_mathmlstream.h"
  29 #include "math_scriptinset.h"
  30 #include "math_spaceinset.h"
  31 #include "math_support.h"
  32 #include "math_unknowninset.h"
  33
  34 #include <boost/assert.hpp>
  35
  36 //#define FILEDEBUG 1
  37
  38 using std::endl;
  39 using std::isalpha;
  40 using std::min;
  41 using std::swap;
  42
  43 using std::ostringstream;
  44
  45
  46 // matheds own cut buffer
  47 limited_stack<string> theCutBuffer;
  48
  49
  50 MathCursor::MathCursor(InsetFormulaBase * formula, bool front)
  51         :       formula_(formula), autocorrect_(false), selection_(false), targetx_(-1)
  52 {
  53         front ? first() : last();
  54         Anchor_ = Cursor_;
  55 }
  56
  57
  58 MathCursor::~MathCursor()
  59 {
  60         // ensure that 'notifyCursorLeave' is called
  61         while (popLeft())
  62                 ;
  63 }
  64
  65
  66 void MathCursor::push(MathAtom & t)
  67 {
  68         Cursor_.push_back(CursorPos(t.nucleus()));
  69 }
  70
  71
  72 void MathCursor::pushLeft(MathAtom & t)
  73 {
  74         //lyxerr << "Entering atom " << t << " left" << endl;
  75         push(t);
  76         t->idxFirst(idx(), pos());
  77 }
  78
  79
  80 void MathCursor::pushRight(MathAtom & t)
  81 {
  82         //lyxerr << "Entering atom " << t << " right" << endl;
  83         posLeft();
  84         push(t);
  85         t->idxLast(idx(), pos());
  86 }
  87
  88
  89 bool MathCursor::popLeft()
  90 {
  91         //lyxerr << "Leaving atom to the left" << endl;
  92         if (depth() <= 1) {
  93                 if (depth() == 1)
  94                         inset()->notifyCursorLeaves(idx());
  95                 return false;
  96         }
  97         inset()->notifyCursorLeaves(idx());
  98         Cursor_.pop_back();
  99         return true;
 100 }
 101
 102
 103 bool MathCursor::popRight()
 104 {
 105         //lyxerr << "Leaving atom "; inset()->write(cerr, false); cerr << " right" << endl;
 106         if (depth() <= 1) {
 107                 if (depth() == 1)
 108                         inset()->notifyCursorLeaves(idx());
 109                 return false;
 110         }
 111         inset()->notifyCursorLeaves(idx());
 112         Cursor_.pop_back();
 113         posRight();
 114         return true;
 115 }
 116
 117
 118
 119 #if FILEDEBUG
 120         void MathCursor::dump(char const * what) const
 121         {
 122                 lyxerr << "MC: " << what << endl;
 123                 lyxerr << " Cursor: " << depth() << endl;
 124                 for (unsigned i = 0; i < depth(); ++i)
 125                         lyxerr << "    i: " << i << ' ' << Cursor_[i] << endl;
 126                 lyxerr << " Anchor: " << Anchor_.size() << endl;
 127                 for (unsigned i = 0; i < Anchor_.size(); ++i)
 128                         lyxerr << "    i: " << i << ' ' << Anchor_[i] << endl;
 129                 lyxerr  << " sel: " << selection_ << endl;
 130         }
 131 #else
 132         void MathCursor::dump(char const *) const {}
 133 #endif
 134
 135
 136 bool MathCursor::isInside(MathInset const * p) const
 137 {
 138         for (unsigned i = 0; i < depth(); ++i)
 139                 if (Cursor_[i].inset_ == p)
 140                         return true;
 141         return false;
 142 }
 143
 144
 145 bool MathCursor::openable(MathAtom const & t, bool sel) const
 146 {
 147         if (!t->isActive())
 148                 return false;
 149
 150         if (t->lock())
 151                 return false;
 152
 153         if (sel) {
 154                 // we can't move into anything new during selection
 155                 if (depth() == Anchor_.size())
 156                         return false;
 157                 if (t.operator->() != Anchor_[depth()].inset_)
 158                         return false;
 159         }
 160         return true;
 161 }
 162
 163
 164 bool MathCursor::inNucleus() const
 165 {
 166         return inset()->asScriptInset() && idx() == 2;
 167 }
 168
 169
 170 bool MathCursor::posLeft()
 171 {
 172         if (pos() == 0)
 173                 return false;
 174         --pos();
 175         return true;
 176 }
 177
 178
 179 bool MathCursor::posRight()
 180 {
 181         if (pos() == size())
 182                 return false;
 183         ++pos();
 184         return true;
 185 }
 186
 187
 188 bool MathCursor::left(bool sel)
 189 {
 190         dump("Left 1");
 191         autocorrect_ = false;
 192         targetx_ = -1; // "no target"
 193         if (inMacroMode()) {
 194                 macroModeClose();
 195                 return true;
 196         }
 197         selHandle(sel);
 198
 199         if (hasPrevAtom() && openable(prevAtom(), sel)) {
 200                 pushRight(prevAtom());
 201                 return true;
 202         }
 203
 204         return posLeft() || idxLeft() || popLeft() || selection_;
 205 }
 206
 207
 208 bool MathCursor::right(bool sel)
 209 {
 210         dump("Right 1");
 211         autocorrect_ = false;
 212         targetx_ = -1; // "no target"
 213         if (inMacroMode()) {
 214                 macroModeClose();
 215                 return true;
 216         }
 217         selHandle(sel);
 218
 219         if (hasNextAtom() && openable(nextAtom(), sel)) {
 220                 pushLeft(nextAtom());
 221                 return true;
 222         }
 223
 224         return posRight() || idxRight() || popRight() || selection_;
 225 }
 226
 227
 228 void MathCursor::first()
 229 {
 230         Cursor_.clear();
 231         push(formula_->par());
 232         inset()->idxFirst(idx(), pos());
 233 }
 234
 235
 236 void MathCursor::last()
 237 {
 238         Cursor_.clear();
 239         push(formula_->par());
 240         inset()->idxLast(idx(), pos());
 241 }
 242
 243
 244 bool positionable
 245         (MathIterator const & cursor, MathIterator const & anchor)
 246 {
 247         // avoid deeper nested insets when selecting
 248         if (cursor.size() > anchor.size())
 249                 return false;
 250
 251         // anchor might be deeper, should have same path then
 252         for (MathIterator::size_type i = 0; i < cursor.size(); ++i)
 253                 if (cursor[i].inset_ != anchor[i].inset_)
 254                         return false;
 255
 256         // position should be ok.
 257         return true;
 258 }
 259
 260
 261 void MathCursor::setPos(int x, int y)
 262 {
 263         dump("setPos 1");
 264         bool res = bruteFind(x, y,
 265                 formula()->xlow(), formula()->xhigh(),
 266                 formula()->ylow(), formula()->yhigh());
 267         if (!res) {
 268                 // this can happen on creation of "math-display"
 269                 dump("setPos 1.5");
 270                 first();
 271         }
 272         targetx_ = -1; // "no target"
 273         dump("setPos 2");
 274 }
 275
 276
 277
 278 bool MathCursor::home(bool sel)
 279 {
 280         dump("home 1");
 281         autocorrect_ = false;
 282         selHandle(sel);
 283         macroModeClose();
 284         if (!inset()->idxHome(idx(), pos()))
 285                 return popLeft();
 286         dump("home 2");
 287         targetx_ = -1; // "no target"
 288         return true;
 289 }
 290
 291
 292 bool MathCursor::end(bool sel)
 293 {
 294         dump("end 1");
 295         autocorrect_ = false;
 296         selHandle(sel);
 297         macroModeClose();
 298         if (!inset()->idxEnd(idx(), pos()))
 299                 return popRight();
 300         dump("end 2");
 301         targetx_ = -1; // "no target"
 302         return true;
 303 }
 304
 305
 306 void MathCursor::plainErase()
 307 {
 308         array().erase(pos());
 309 }
 310
 311
 312 void MathCursor::markInsert()
 313 {
 314         //lyxerr << "inserting mark" << endl;
 315         array().insert(pos(), MathAtom(new MathCharInset(0)));
 316 }
 317
 318
 319 void MathCursor::markErase()
 320 {
 321         //lyxerr << "deleting mark" << endl;
 322         array().erase(pos());
 323 }
 324
 325
 326 void MathCursor::plainInsert(MathAtom const & t)
 327 {
 328         dump("plainInsert");
 329         array().insert(pos(), t);
 330         ++pos();
 331 }
 332
 333
 334 void MathCursor::insert2(string const & str)
 335 {
 336         MathArray ar;
 337         asArray(str, ar);
 338         insert(ar);
 339 }
 340
 341
 342 void MathCursor::insert(string const & str)
 343 {
 344         //lyxerr << "inserting '" << str << "'" << endl;
 345         selClearOrDel();
 346         for (string::const_iterator it = str.begin(); it != str.end(); ++it)
 347                 plainInsert(MathAtom(new MathCharInset(*it)));
 348 }
 349
 350
 351 void MathCursor::insert(char c)
 352 {
 353         //lyxerr << "inserting '" << c << "'" << endl;
 354         selClearOrDel();
 355         plainInsert(MathAtom(new MathCharInset(c)));
 356 }
 357
 358
 359 void MathCursor::insert(MathAtom const & t)
 360 {
 361         macroModeClose();
 362         selClearOrDel();
 363         plainInsert(t);
 364 }
 365
 366
 367 void MathCursor::niceInsert(string const & t)
 368 {
 369         MathArray ar;
 370         asArray(t, ar);
 371         if (ar.size() == 1)
 372                 niceInsert(ar[0]);
 373         else
 374                 insert(ar);
 375 }
 376
 377
 378 void MathCursor::niceInsert(MathAtom const & t)
 379 {
 380         macroModeClose();
 381         string safe = grabAndEraseSelection();
 382         plainInsert(t);
 383         // enter the new inset and move the contents of the selection if possible
 384         if (t->isActive()) {
 385                 posLeft();
 386                 pushLeft(nextAtom());
 387                 paste(safe);
 388         }
 389 }
 390
 391
 392 void MathCursor::insert(MathArray const & ar)
 393 {
 394         macroModeClose();
 395         if (selection_)
 396                 eraseSelection();
 397         array().insert(pos(), ar);
 398         pos() += ar.size();
 399 }
 400
 401
 402 void MathCursor::paste(string const & data)
 403 {
 404         dispatch(FuncRequest(LFUN_PASTE, data));
 405 }
 406
 407
 408 bool MathCursor::backspace()
 409 {
 410         autocorrect_ = false;
 411
 412         if (selection_) {
 413                 selDel();
 414                 return true;
 415         }
 416
 417         if (pos() == 0) {
 418                 if (inset()->ncols() == 1 &&
 419                           inset()->nrows() == 1 &&
 420                           depth() == 1 &&
 421                           size() == 0)
 422                         return false;
 423                 pullArg();
 424                 return true;
 425         }
 426
 427         if (inMacroMode()) {
 428                 MathUnknownInset * p = activeMacro();
 429                 if (p->name().size() > 1) {
 430                         p->setName(p->name().substr(0, p->name().size() - 1));
 431                         return true;
 432                 }
 433         }
 434
 435         --pos();
 436         plainErase();
 437         return true;
 438 }
 439
 440
 441 bool MathCursor::erase()
 442 {
 443         autocorrect_ = false;
 444         if (inMacroMode())
 445                 return true;
 446
 447         if (selection_) {
 448                 selDel();
 449                 return true;
 450         }
 451
 452         // delete empty cells if possible
 453         if (array().empty())
 454                 if (inset()->idxDelete(idx()))
 455                         return true;
 456
 457         // old behaviour when in last position of cell
 458         if (pos() == size()) {
 459                 if (inset()->ncols() == 1 && inset()->nrows() == 1 && depth() == 1 && size() == 0)
 460                         return false;
 461                 else{
 462                         inset()->idxGlue(idx());
 463                         return true;
 464                 }
 465         }
 466
 467         plainErase();
 468         return true;
 469 }
 470
 471
 472 bool MathCursor::up(bool sel)
 473 {
 474         dump("up 1");
 475         macroModeClose();
 476         selHandle(sel);
 477         MathIterator save = Cursor_;
 478         if (goUpDown(true))
 479                 return true;
 480         Cursor_ = save;
 481         autocorrect_ = false;
 482         return selection_;
 483 }
 484
 485
 486 bool MathCursor::down(bool sel)
 487 {
 488         dump("down 1");
 489         macroModeClose();
 490         selHandle(sel);
 491         MathIterator save = Cursor_;
 492         if (goUpDown(false))
 493                 return true;
 494         Cursor_ = save;
 495         autocorrect_ = false;
 496         return selection_;
 497 }
 498
 499
 500 void MathCursor::macroModeClose()
 501 {
 502         if (!inMacroMode())
 503                 return;
 504         MathUnknownInset * p = activeMacro();
 505         p->finalize();
 506         string s = p->name();
 507         --pos();
 508         array().erase(pos());
 509
 510         // do nothing if the macro name is empty
 511         if (s == "\\")
 512                 return;
 513
 514         string const name = s.substr(1);
 515
 516         // prevent entering of recursive macros
 517         if (formula()->lyxCode() == InsetOld::MATHMACRO_CODE
 518                         && formula()->getInsetName() == name)
 519                 lyxerr << "can't enter recursive macro" << endl;
 520
 521         niceInsert(createMathInset(name));
 522 }
 523
 524
 525 string MathCursor::macroName() const
 526 {
 527         return inMacroMode() ? activeMacro()->name() : string();
 528 }
 529
 530
 531 void MathCursor::selClear()
 532 {
 533         Anchor_.clear();
 534         selection_ = false;
 535 }
 536
 537
 538 void MathCursor::selCopy()
 539 {
 540         dump("selCopy");
 541         if (selection_) {
 542                 theCutBuffer.push(grabSelection());
 543                 selection_ = false;
 544         } else {
 545                 //theCutBuffer.erase();
 546         }
 547 }
 548
 549
 550 void MathCursor::selCut()
 551 {
 552         dump("selCut");
 553         theCutBuffer.push(grabAndEraseSelection());
 554 }
 555
 556
 557 void MathCursor::selDel()
 558 {
 559         dump("selDel");
 560         if (selection_) {
 561                 eraseSelection();
 562                 selection_ = false;
 563         }
 564 }
 565
 566
 567 void MathCursor::selPaste(size_t n)
 568 {
 569         dump("selPaste");
 570         selClearOrDel();
 571         if (n < theCutBuffer.size())
 572                 paste(theCutBuffer[n]);
 573         //grabSelection();
 574         selection_ = false;
 575 }
 576
 577
 578 void MathCursor::selHandle(bool sel)
 579 {
 580         if (sel == selection_)
 581                 return;
 582         //clear();
 583         Anchor_ = Cursor_;
 584         selection_ = sel;
 585 }
 586
 587
 588 void MathCursor::selStart()
 589 {
 590         dump("selStart 1");
 591         //clear();
 592         Anchor_ = Cursor_;
 593         selection_ = true;
 594         dump("selStart 2");
 595 }
 596
 597
 598 void MathCursor::selClearOrDel()
 599 {
 600         if (lyxrc.auto_region_delete)
 601                 selDel();
 602         else
 603                 selection_ = false;
 604 }
 605
 606
 607 void MathCursor::drawSelection(PainterInfo & pi) const
 608 {
 609         if (!selection_)
 610                 return;
 611         CursorPos i1;
 612         CursorPos i2;
 613         getSelection(i1, i2);
 614         i1.inset_->drawSelection(pi, i1.idx_, i1.pos_, i2.idx_, i2.pos_);
 615 }
 616
 617
 618 void MathCursor::handleNest(MathAtom const & a, int c)
 619 {
 620         MathAtom at = a;
 621         asArray(grabAndEraseSelection(), at.nucleus()->cell(c));
 622         insert(at);
 623         pushRight(prevAtom());
 624 }
 625
 626
 627 void MathCursor::getPos(int & x, int & y) const
 628 {
 629         inset()->getPos(idx(), pos(), x, y);
 630 }
 631
 632
 633 int MathCursor::targetX() const
 634 {
 635         if (targetx_ != -1)
 636                 return targetx_;
 637         int x = 0, y = 0;
 638         getPos(x, y);
 639         return x;
 640 }
 641
 642
 643 MathInset * MathCursor::inset() const
 644 {
 645         return cursor().inset_;
 646 }
 647
 648
 649 InsetFormulaBase * MathCursor::formula() const
 650 {
 651         return formula_;
 652 }
 653
 654
 655 MathCursor::idx_type MathCursor::idx() const
 656 {
 657         return cursor().idx_;
 658 }
 659
 660
 661 MathCursor::idx_type & MathCursor::idx()
 662 {
 663         return cursor().idx_;
 664 }
 665
 666
 667 MathCursor::pos_type MathCursor::pos() const
 668 {
 669         return cursor().pos_;
 670 }
 671
 672
 673 void MathCursor::adjust(pos_type from, difference_type diff)
 674 {
 675         if (cursor().pos_ > from)
 676                 cursor().pos_ += diff;
 677         if (Anchor_.back().pos_ > from)
 678                 Anchor_.back().pos_ += diff;
 679         // just to be on the safe side
 680         // theoretically unecessary
 681         normalize();
 682 }
 683
 684
 685 MathCursor::pos_type & MathCursor::pos()
 686 {
 687         return cursor().pos_;
 688 }
 689
 690
 691 bool MathCursor::inMacroMode() const
 692 {
 693         if (!hasPrevAtom())
 694                 return false;
 695         MathUnknownInset const * p = prevAtom()->asUnknownInset();
 696         return p && !p->final();
 697 }
 698
 699
 700 MathUnknownInset * MathCursor::activeMacro()
 701 {
 702         return inMacroMode() ? prevAtom().nucleus()->asUnknownInset() : 0;
 703 }
 704
 705
 706 MathUnknownInset const * MathCursor::activeMacro() const
 707 {
 708         return inMacroMode() ? prevAtom()->asUnknownInset() : 0;
 709 }
 710
 711
 712 bool MathCursor::inMacroArgMode() const
 713 {
 714         return pos() > 0 && prevAtom()->getChar() == '#';
 715 }
 716
 717
 718 bool MathCursor::selection() const
 719 {
 720         return selection_;
 721 }
 722
 723
 724 MathGridInset * MathCursor::enclosingGrid(MathCursor::idx_type & idx) const
 725 {
 726         for (MathInset::difference_type i = depth() - 1; i >= 0; --i) {
 727                 MathGridInset * p = Cursor_[i].inset_->asGridInset();
 728                 if (p) {
 729                         idx = Cursor_[i].idx_;
 730                         return p;
 731                 }
 732         }
 733         return 0;
 734 }
 735
 736
 737 void MathCursor::popToHere(MathInset const * p)
 738 {
 739         while (depth() && Cursor_.back().inset_ != p)
 740                 Cursor_.pop_back();
 741 }
 742
 743
 744 void MathCursor::popToEnclosingGrid()
 745 {
 746         while (depth() && !Cursor_.back().inset_->asGridInset())
 747                 Cursor_.pop_back();
 748 }
 749
 750
 751 void MathCursor::popToEnclosingHull()
 752 {
 753         while (depth() && !Cursor_.back().inset_->asHullInset())
 754                 Cursor_.pop_back();
 755 }
 756
 757
 758 void MathCursor::pullArg()
 759 {
 760         dump("pullarg");
 761         MathArray a = array();
 762         if (popLeft()) {
 763                 plainErase();
 764                 array().insert(pos(), a);
 765                 Anchor_ = Cursor_;
 766         } else {
 767                 formula()->mutateToText();
 768         }
 769 }
 770
 771
 772 void MathCursor::touch()
 773 {
 774         MathIterator::const_iterator it = Cursor_.begin();
 775         MathIterator::const_iterator et = Cursor_.end();
 776         for ( ; it != et; ++it)
 777                 it->cell().touch();
 778 }
 779
 780
 781 void MathCursor::normalize()
 782 {
 783         if (idx() >= inset()->nargs()) {
 784                 lyxerr << "this should not really happen - 1: "
 785                        << idx() << ' ' << inset()->nargs()
 786                        << " in: " << inset() << endl;
 787                 dump("error 2");
 788         }
 789         idx() = min(idx(), inset()->nargs() - 1);
 790
 791         if (pos() > size()) {
 792                 lyxerr << "this should not really happen - 2: "
 793                         << pos() << ' ' << size() <<  " in idx: " << idx()
 794                        << " in atom: '";
 795                 WriteStream wi(lyxerr, false, true);
 796                 inset()->write(wi);
 797                 lyxerr << endl;
 798                 dump("error 4");
 799         }
 800         pos() = min(pos(), size());
 801 }
 802
 803
 804 MathCursor::size_type MathCursor::size() const
 805 {
 806         return array().size();
 807 }
 808
 809
 810 bool MathCursor::hasPrevAtom() const
 811 {
 812         return pos() > 0;
 813 }
 814
 815
 816 bool MathCursor::hasNextAtom() const
 817 {
 818         return pos() < size();
 819 }
 820
 821
 822 MathAtom const & MathCursor::prevAtom() const
 823 {
 824         BOOST_ASSERT(pos() > 0);
 825         return array()[pos() - 1];
 826 }
 827
 828
 829 MathAtom & MathCursor::prevAtom()
 830 {
 831         BOOST_ASSERT(pos() > 0);
 832         return array()[pos() - 1];
 833 }
 834
 835
 836 MathAtom const & MathCursor::nextAtom() const
 837 {
 838         BOOST_ASSERT(pos() < size());
 839         return array()[pos()];
 840 }
 841
 842
 843 MathAtom & MathCursor::nextAtom()
 844 {
 845         BOOST_ASSERT(pos() < size());
 846         return array()[pos()];
 847 }
 848
 849
 850 MathArray & MathCursor::array() const
 851 {
 852         static MathArray dummy;
 853
 854         if (idx() >= inset()->nargs()) {
 855                 lyxerr << "############  idx_ " << idx() << " not valid" << endl;
 856                 return dummy;
 857         }
 858
 859         if (depth() == 0) {
 860                 lyxerr << "############  depth() == 0 not valid" << endl;
 861                 return dummy;
 862         }
 863
 864         return cursor().cell();
 865 }
 866
 867
 868 void MathCursor::idxNext()
 869 {
 870         inset()->idxNext(idx(), pos());
 871 }
 872
 873
 874 void MathCursor::idxPrev()
 875 {
 876         inset()->idxPrev(idx(), pos());
 877 }
 878
 879
 880 char MathCursor::valign() const
 881 {
 882         idx_type idx;
 883         MathGridInset * p = enclosingGrid(idx);
 884         return p ? p->valign() : '\0';
 885 }
 886
 887
 888 char MathCursor::halign() const
 889 {
 890         idx_type idx;
 891         MathGridInset * p = enclosingGrid(idx);
 892         return p ? p->halign(idx % p->ncols()) : '\0';
 893 }
 894
 895
 896 void MathCursor::getSelection(CursorPos & i1, CursorPos & i2) const
 897 {
 898         CursorPos anc = normalAnchor();
 899         if (anc < cursor()) {
 900                 i1 = anc;
 901                 i2 = cursor();
 902         } else {
 903                 i1 = cursor();
 904                 i2 = anc;
 905         }
 906 }
 907
 908
 909 CursorPos & MathCursor::cursor()
 910 {
 911         BOOST_ASSERT(depth());
 912         return Cursor_.back();
 913 }
 914
 915
 916 CursorPos const & MathCursor::cursor() const
 917 {
 918         BOOST_ASSERT(depth());
 919         return Cursor_.back();
 920 }
 921
 922
 923 bool MathCursor::goUpDown(bool up)
 924 {
 925         // Be warned: The 'logic' implemented in this function is highly fragile.
 926         // A distance of one pixel or a '<' vs '<=' _really_ matters.
 927         // So fiddle around with it only if you know what you are doing!
 928   int xo = 0;
 929         int yo = 0;
 930         getPos(xo, yo);
 931
 932         // check if we had something else in mind, if not, this is the future goal
 933         if (targetx_ == -1)
 934                 targetx_ = xo;
 935         else
 936                 xo = targetx_;
 937
 938         // try neigbouring script insets
 939         if (!selection()) {
 940                 // try left
 941                 if (hasPrevAtom()) {
 942                         MathScriptInset const * p = prevAtom()->asScriptInset();
 943                         if (p && p->has(up)) {
 944                                 --pos();
 945                                 push(nextAtom());
 946                                 idx() = up; // the superscript has index 1
 947                                 pos() = size();
 948                                 //lyxerr << "updown: handled by scriptinset to the left" << endl;
 949                                 return true;
 950                         }
 951                 }
 952
 953                 // try right
 954                 if (hasNextAtom()) {
 955                         MathScriptInset const * p = nextAtom()->asScriptInset();
 956                         if (p && p->has(up)) {
 957                                 push(nextAtom());
 958                                 idx() = up;
 959                                 pos() = 0;
 960                                 //lyxerr << "updown: handled by scriptinset to the right" << endl;
 961                                 return true;
 962                         }
 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                 niceInsert(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 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::BOOST_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 }