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