src/text2.C

   1 /**
   2  * \file text2.C
   3  * This file is part of LyX, the document processor.
   4  * Licence details can be found in the file COPYING.
   5  *
   6  * \author Asger Alstrup
   7  * \author Lars Gullik Bjønnes
   8  * \author Alfredo Braunstein
   9  * \author Jean-Marc Lasgouttes
  10  * \author Angus Leeming
  11  * \author John Levon
  12  * \author André Pönitz
  13  * \author Allan Rae
  14  * \author Dekel Tsur
  15  * \author Jürgen Vigna
  16  *
  17  * Full author contact details are available in file CREDITS.
  18  */
  19
  20 #include <config.h>
  21
  22 #include "lyxtext.h"
  23 #include "LString.h"
  24 #include "Lsstream.h"
  25 #include "paragraph.h"
  26 #include "funcrequest.h"
  27 #include "frontends/LyXView.h"
  28 #include "undo_funcs.h"
  29 #include "buffer.h"
  30 #include "buffer_funcs.h"
  31 #include "bufferparams.h"
  32 #include "errorlist.h"
  33 #include "gettext.h"
  34 #include "BufferView.h"
  35 #include "CutAndPaste.h"
  36 #include "frontends/Painter.h"
  37 #include "frontends/font_metrics.h"
  38 #include "debug.h"
  39 #include "lyxrc.h"
  40 #include "FloatList.h"
  41 #include "language.h"
  42 #include "ParagraphParameters.h"
  43 #include "counters.h"
  44 #include "lyxrow_funcs.h"
  45 #include "metricsinfo.h"
  46 #include "paragraph_funcs.h"
  47
  48 #include "insets/insetbibitem.h"
  49 #include "insets/insetenv.h"
  50 #include "insets/insetfloat.h"
  51 #include "insets/insetwrap.h"
  52
  53 #include "support/LAssert.h"
  54 #include "support/textutils.h"
  55 #include "support/lstrings.h"
  56
  57 #include <boost/tuple/tuple.hpp>
  58
  59 #include <algorithm>
  60
  61 using namespace lyx::support;
  62
  63 using std::vector;
  64 using std::copy;
  65 using std::endl;
  66 using std::find;
  67 using std::pair;
  68 using lyx::pos_type;
  69
  70
  71 LyXText::LyXText(BufferView * bv, InsetText * inset, bool ininset,
  72           ParagraphList & paragraphs)
  73         : height(0), width(0), anchor_y_(0),
  74           inset_owner(inset), the_locking_inset(0), bv_owner(bv),
  75           in_inset_(ininset), paragraphs_(paragraphs)
  76 {
  77 }
  78
  79
  80 void LyXText::init(BufferView * bview)
  81 {
  82         bv_owner = bview;
  83
  84         ParagraphList::iterator const beg = ownerParagraphs().begin();
  85         ParagraphList::iterator const end = ownerParagraphs().end();
  86         for (ParagraphList::iterator pit = beg; pit != end; ++pit)
  87                 pit->rows.clear();
  88
  89         width = 0;
  90         height = 0;
  91
  92         anchor_y_ = 0;
  93
  94         current_font = getFont(beg, 0);
  95
  96         redoParagraphs(beg, end);
  97         setCursorIntern(beg, 0);
  98         selection.cursor = cursor;
  99
 100         updateCounters();
 101 }
 102
 103
 104 // Gets the fully instantiated font at a given position in a paragraph
 105 // Basically the same routine as Paragraph::getFont() in paragraph.C.
 106 // The difference is that this one is used for displaying, and thus we
 107 // are allowed to make cosmetic improvements. For instance make footnotes
 108 // smaller. (Asger)
 109 LyXFont LyXText::getFont(ParagraphList::iterator pit, pos_type pos) const
 110 {
 111         Assert(pos >= 0);
 112
 113         LyXLayout_ptr const & layout = pit->layout();
 114 #warning broken?
 115         BufferParams const & params = bv()->buffer()->params;
 116
 117         // We specialize the 95% common case:
 118         if (!pit->getDepth()) {
 119                 if (layout->labeltype == LABEL_MANUAL
 120                     && pos < pit->beginningOfBody()) {
 121                         // 1% goes here
 122                         LyXFont f = pit->getFontSettings(params, pos);
 123                         if (pit->inInset())
 124                                 pit->inInset()->getDrawFont(f);
 125                         return f.realize(layout->reslabelfont);
 126                 } else {
 127                         LyXFont f = pit->getFontSettings(params, pos);
 128                         if (pit->inInset())
 129                                 pit->inInset()->getDrawFont(f);
 130                         return f.realize(layout->resfont);
 131                 }
 132         }
 133
 134         // The uncommon case need not be optimized as much
 135
 136         LyXFont layoutfont;
 137
 138         if (pos < pit->beginningOfBody()) {
 139                 // 1% goes here
 140                 layoutfont = layout->labelfont;
 141         } else {
 142                 // 99% goes here
 143                 layoutfont = layout->font;
 144         }
 145
 146         LyXFont tmpfont = pit->getFontSettings(params, pos);
 147         tmpfont.realize(layoutfont);
 148
 149         if (pit->inInset())
 150                 pit->inInset()->getDrawFont(tmpfont);
 151
 152         // Realize with the fonts of lesser depth.
 153         tmpfont.realize(outerFont(pit, ownerParagraphs()));
 154         tmpfont.realize(defaultfont_);
 155
 156         return tmpfont;
 157 }
 158
 159
 160 LyXFont LyXText::getLayoutFont(ParagraphList::iterator pit) const
 161 {
 162         LyXLayout_ptr const & layout = pit->layout();
 163
 164         if (!pit->getDepth())
 165                 return layout->resfont;
 166
 167         LyXFont font = layout->font;
 168         // Realize with the fonts of lesser depth.
 169         font.realize(outerFont(pit, ownerParagraphs()));
 170         font.realize(defaultfont_);
 171
 172         return font;
 173 }
 174
 175
 176 LyXFont LyXText::getLabelFont(ParagraphList::iterator pit) const
 177 {
 178         LyXLayout_ptr const & layout = pit->layout();
 179
 180         if (!pit->getDepth())
 181                 return layout->reslabelfont;
 182
 183         LyXFont font = layout->labelfont;
 184         // Realize with the fonts of lesser depth.
 185         font.realize(outerFont(pit, ownerParagraphs()));
 186         font.realize(defaultfont_);
 187
 188         return font;
 189 }
 190
 191
 192 void LyXText::setCharFont(ParagraphList::iterator pit,
 193                           pos_type pos, LyXFont const & fnt,
 194                           bool toggleall)
 195 {
 196         BufferParams const & params = bv()->buffer()->params;
 197         LyXFont font = getFont(pit, pos);
 198         font.update(fnt, params.language, toggleall);
 199         // Let the insets convert their font
 200         if (pit->isInset(pos)) {
 201                 InsetOld * inset = pit->getInset(pos);
 202                 if (isEditableInset(inset)) {
 203                         static_cast<UpdatableInset *>(inset)
 204                                 ->setFont(bv(), fnt, toggleall, true);
 205                 }
 206         }
 207
 208         // Plug through to version below:
 209         setCharFont(pit, pos, font);
 210 }
 211
 212
 213 void LyXText::setCharFont(
 214         ParagraphList::iterator pit, pos_type pos, LyXFont const & fnt)
 215 {
 216         LyXFont font = fnt;
 217         LyXLayout_ptr const & layout = pit->layout();
 218
 219         // Get concrete layout font to reduce against
 220         LyXFont layoutfont;
 221
 222         if (pos < pit->beginningOfBody())
 223                 layoutfont = layout->labelfont;
 224         else
 225                 layoutfont = layout->font;
 226
 227         // Realize against environment font information
 228         if (pit->getDepth()) {
 229                 ParagraphList::iterator tp = pit;
 230                 while (!layoutfont.resolved() &&
 231                        tp != ownerParagraphs().end() &&
 232                        tp->getDepth()) {
 233                         tp = outerHook(tp, ownerParagraphs());
 234                         if (tp != ownerParagraphs().end())
 235                                 layoutfont.realize(tp->layout()->font);
 236                 }
 237         }
 238
 239         layoutfont.realize(defaultfont_);
 240
 241         // Now, reduce font against full layout font
 242         font.reduce(layoutfont);
 243
 244         pit->setFont(pos, font);
 245 }
 246
 247
 248 InsetOld * LyXText::getInset() const
 249 {
 250         ParagraphList::iterator pit = cursor.par();
 251         pos_type const pos = cursor.pos();
 252
 253         if (pos < pit->size() && pit->isInset(pos)) {
 254                 return pit->getInset(pos);
 255         }
 256         return 0;
 257 }
 258
 259
 260 void LyXText::toggleInset()
 261 {
 262         InsetOld * inset = getInset();
 263         // is there an editable inset at cursor position?
 264         if (!isEditableInset(inset)) {
 265                 // No, try to see if we are inside a collapsable inset
 266                 if (inset_owner && inset_owner->owner()
 267                     && inset_owner->owner()->isOpen()) {
 268                         bv()->unlockInset(inset_owner->owner());
 269                         inset_owner->owner()->close(bv());
 270                         bv()->getLyXText()->cursorRight(bv());
 271                 }
 272                 return;
 273         }
 274         //bv()->owner()->message(inset->editMessage());
 275
 276         // do we want to keep this?? (JMarc)
 277         if (!isHighlyEditableInset(inset))
 278                 recordUndo(bv(), Undo::ATOMIC);
 279
 280         if (inset->isOpen())
 281                 inset->close(bv());
 282         else
 283                 inset->open(bv());
 284
 285         bv()->updateInset(inset);
 286 }
 287
 288
 289 /* used in setlayout */
 290 // Asger is not sure we want to do this...
 291 void LyXText::makeFontEntriesLayoutSpecific(BufferParams const & params,
 292                                             Paragraph & par)
 293 {
 294         LyXLayout_ptr const & layout = par.layout();
 295         pos_type const psize = par.size();
 296
 297         LyXFont layoutfont;
 298         for (pos_type pos = 0; pos < psize; ++pos) {
 299                 if (pos < par.beginningOfBody())
 300                         layoutfont = layout->labelfont;
 301                 else
 302                         layoutfont = layout->font;
 303
 304                 LyXFont tmpfont = par.getFontSettings(params, pos);
 305                 tmpfont.reduce(layoutfont);
 306                 par.setFont(pos, tmpfont);
 307         }
 308 }
 309
 310
 311 ParagraphList::iterator
 312 LyXText::setLayout(LyXCursor & cur, LyXCursor & sstart_cur,
 313                    LyXCursor & send_cur,
 314                    string const & layout)
 315 {
 316         ParagraphList::iterator endpit = boost::next(send_cur.par());
 317         ParagraphList::iterator undoendpit = endpit;
 318         ParagraphList::iterator pars_end = ownerParagraphs().end();
 319
 320         if (endpit != pars_end && endpit->getDepth()) {
 321                 while (endpit != pars_end && endpit->getDepth()) {
 322                         ++endpit;
 323                         undoendpit = endpit;
 324                 }
 325         } else if (endpit != pars_end) {
 326                 // because of parindents etc.
 327                 ++endpit;
 328         }
 329
 330         recordUndo(bv(), Undo::ATOMIC, sstart_cur.par(), boost::prior(undoendpit));
 331
 332         // ok we have a selection. This is always between sstart_cur
 333         // and sel_end cursor
 334         cur = sstart_cur;
 335         ParagraphList::iterator pit = sstart_cur.par();
 336         ParagraphList::iterator epit = boost::next(send_cur.par());
 337
 338         LyXLayout_ptr const & lyxlayout =
 339                 bv()->buffer()->params.getLyXTextClass()[layout];
 340
 341         do {
 342                 pit->applyLayout(lyxlayout);
 343                 makeFontEntriesLayoutSpecific(bv()->buffer()->params, *pit);
 344                 pit->params().spaceTop(lyxlayout->fill_top ?
 345                                          VSpace(VSpace::VFILL)
 346                                          : VSpace(VSpace::NONE));
 347                 pit->params().spaceBottom(lyxlayout->fill_bottom ?
 348                                             VSpace(VSpace::VFILL)
 349                                             : VSpace(VSpace::NONE));
 350                 if (lyxlayout->margintype == MARGIN_MANUAL)
 351                         pit->setLabelWidthString(lyxlayout->labelstring());
 352                 cur.par(pit);
 353                 ++pit;
 354         } while (pit != epit);
 355
 356         return endpit;
 357 }
 358
 359
 360 // set layout over selection and make a total rebreak of those paragraphs
 361 void LyXText::setLayout(string const & layout)
 362 {
 363         LyXCursor tmpcursor = cursor;  // store the current cursor
 364
 365         // if there is no selection just set the layout
 366         // of the current paragraph
 367         if (!selection.set()) {
 368                 selection.start = cursor;  // dummy selection
 369                 selection.end = cursor;
 370         }
 371
 372         // special handling of new environment insets
 373         BufferParams const & params = bv()->buffer()->params;
 374         LyXLayout_ptr const & lyxlayout = params.getLyXTextClass()[layout];
 375         if (lyxlayout->is_environment) {
 376                 // move everything in a new environment inset
 377                 lyxerr << "setting layout " << layout << endl;
 378                 bv()->owner()->dispatch(FuncRequest(LFUN_HOME));
 379                 bv()->owner()->dispatch(FuncRequest(LFUN_ENDSEL));
 380                 bv()->owner()->dispatch(FuncRequest(LFUN_CUT));
 381                 InsetOld * inset = new InsetEnvironment(params, layout);
 382                 if (bv()->insertInset(inset)) {
 383                         //inset->edit(bv());
 384                         //bv()->owner()->dispatch(FuncRequest(LFUN_PASTE));
 385                 }
 386                 else
 387                         delete inset;
 388                 return;
 389         }
 390
 391         ParagraphList::iterator endpit = setLayout(cursor, selection.start,
 392                                                    selection.end, layout);
 393         redoParagraphs(selection.start.par(), endpit);
 394
 395         // we have to reset the selection, because the
 396         // geometry could have changed
 397         setCursor(selection.start.par(), selection.start.pos(), false);
 398         selection.cursor = cursor;
 399         setCursor(selection.end.par(), selection.end.pos(), false);
 400         updateCounters();
 401         clearSelection();
 402         setSelection();
 403         setCursor(tmpcursor.par(), tmpcursor.pos(), true);
 404 }
 405
 406
 407 bool LyXText::changeDepth(bv_funcs::DEPTH_CHANGE type, bool test_only)
 408 {
 409         ParagraphList::iterator pit = cursor.par();
 410         ParagraphList::iterator end = cursor.par();
 411         ParagraphList::iterator start = pit;
 412
 413         if (selection.set()) {
 414                 pit = selection.start.par();
 415                 end = selection.end.par();
 416                 start = pit;
 417         }
 418
 419         ParagraphList::iterator pastend = boost::next(end);
 420
 421         if (!test_only)
 422                 recordUndo(bv(), Undo::ATOMIC, start, end);
 423
 424         bool changed = false;
 425
 426         int prev_after_depth = 0;
 427 #warning parlist ... could be nicer ?
 428         if (start != ownerParagraphs().begin()) {
 429                 prev_after_depth = boost::prior(start)->getMaxDepthAfter();
 430         }
 431
 432         while (true) {
 433                 int const depth = pit->params().depth();
 434                 if (type == bv_funcs::INC_DEPTH) {
 435                         if (depth < prev_after_depth
 436                             && pit->layout()->labeltype != LABEL_BIBLIO) {
 437                                 changed = true;
 438                                 if (!test_only)
 439                                         pit->params().depth(depth + 1);
 440                         }
 441                 } else if (depth) {
 442                         changed = true;
 443                         if (!test_only)
 444                                 pit->params().depth(depth - 1);
 445                 }
 446
 447                 prev_after_depth = pit->getMaxDepthAfter();
 448
 449                 if (pit == end) {
 450                         break;
 451                 }
 452
 453                 ++pit;
 454         }
 455
 456         if (test_only)
 457                 return changed;
 458
 459         redoParagraphs(start, pastend);
 460
 461         // We need to actually move the text->cursor. I don't
 462         // understand why ...
 463         LyXCursor tmpcursor = cursor;
 464
 465         // we have to reset the visual selection because the
 466         // geometry could have changed
 467         if (selection.set()) {
 468                 setCursor(selection.start.par(), selection.start.pos());
 469                 selection.cursor = cursor;
 470                 setCursor(selection.end.par(), selection.end.pos());
 471         }
 472
 473         // this handles the counter labels, and also fixes up
 474         // depth values for follow-on (child) paragraphs
 475         updateCounters();
 476
 477         setSelection();
 478         setCursor(tmpcursor.par(), tmpcursor.pos());
 479
 480         return changed;
 481 }
 482
 483
 484 // set font over selection and make a total rebreak of those paragraphs
 485 void LyXText::setFont(LyXFont const & font, bool toggleall)
 486 {
 487         // if there is no selection just set the current_font
 488         if (!selection.set()) {
 489                 // Determine basis font
 490                 LyXFont layoutfont;
 491                 if (cursor.pos() < cursor.par()->beginningOfBody()) {
 492                         layoutfont = getLabelFont(cursor.par());
 493                 } else {
 494                         layoutfont = getLayoutFont(cursor.par());
 495                 }
 496                 // Update current font
 497                 real_current_font.update(font,
 498                                          bv()->buffer()->params.language,
 499                                          toggleall);
 500
 501                 // Reduce to implicit settings
 502                 current_font = real_current_font;
 503                 current_font.reduce(layoutfont);
 504                 // And resolve it completely
 505                 real_current_font.realize(layoutfont);
 506
 507                 return;
 508         }
 509
 510         LyXCursor tmpcursor = cursor; // store the current cursor
 511
 512         // ok we have a selection. This is always between sel_start_cursor
 513         // and sel_end cursor
 514
 515         recordUndo(bv(), Undo::ATOMIC, selection.start.par(), selection.end.par());
 516         freezeUndo();
 517         cursor = selection.start;
 518         while (cursor.par() != selection.end.par() ||
 519                cursor.pos() < selection.end.pos())
 520         {
 521                 if (cursor.pos() < cursor.par()->size()) {
 522                         // an open footnote should behave like a closed one
 523                         setCharFont(cursor.par(), cursor.pos(),
 524                                     font, toggleall);
 525                         cursor.pos(cursor.pos() + 1);
 526                 } else {
 527                         cursor.pos(0);
 528                         cursor.par(boost::next(cursor.par()));
 529                 }
 530         }
 531         unFreezeUndo();
 532
 533         redoParagraph(selection.start.par());
 534
 535         // we have to reset the selection, because the
 536         // geometry could have changed, but we keep
 537         // it for user convenience
 538         setCursor(selection.start.par(), selection.start.pos());
 539         selection.cursor = cursor;
 540         setCursor(selection.end.par(), selection.end.pos());
 541         setSelection();
 542         setCursor(tmpcursor.par(), tmpcursor.pos(), true,
 543                   tmpcursor.boundary());
 544 }
 545
 546
 547 int LyXText::redoParagraphInternal(ParagraphList::iterator pit)
 548 {
 549         RowList::iterator rit = pit->rows.begin();
 550         RowList::iterator end = pit->rows.end();
 551
 552         // remove rows of paragraph, keep track of height changes
 553         for (int i = 0; rit != end; ++rit, ++i)
 554                 height -= rit->height();
 555         pit->rows.clear();
 556
 557         // redo insets
 558         InsetList::iterator ii = pit->insetlist.begin();
 559         InsetList::iterator iend = pit->insetlist.end();
 560         for (; ii != iend; ++ii) {
 561                 Dimension dim;
 562                 MetricsInfo mi(bv(), getFont(pit, ii->pos), workWidth());
 563                 ii->inset->metrics(mi, dim);
 564         }
 565
 566         // rebreak the paragraph
 567         for (pos_type z = 0; z < pit->size() + 1; ) {
 568                 Row row(z);
 569                 z = rowBreakPoint(pit, row) + 1;
 570                 row.end(z);
 571                 pit->rows.push_back(row);
 572         }
 573
 574         int par_width = 0;
 575         // set height and fill and width of rows
 576         int const ww = workWidth();
 577         for (rit = pit->rows.begin(); rit != end; ++rit) {
 578                 int const f = fill(pit, rit, ww);
 579                 int const w = ww - f;
 580                 par_width = std::max(par_width, w);
 581                 rit->fill(f);
 582                 rit->width(w);
 583                 prepareToPrint(pit, rit);
 584                 setHeightOfRow(pit, rit);
 585                 height += rit->height();
 586         }
 587
 588         //lyxerr << "redoParagraph: " << pit->rows.size() << " rows\n";
 589         return par_width;
 590 }
 591
 592
 593 int LyXText::redoParagraphs(ParagraphList::iterator start,
 594   ParagraphList::iterator end)
 595 {
 596         int pars_width = 0;
 597         for ( ; start != end; ++start) {
 598                 int par_width = redoParagraphInternal(start);
 599                 pars_width = std::max(par_width, pars_width);
 600         }
 601         updateRowPositions();
 602         return pars_width;
 603 }
 604
 605
 606 void LyXText::redoParagraph(ParagraphList::iterator pit)
 607 {
 608         redoParagraphInternal(pit);
 609         updateRowPositions();
 610 }
 611
 612
 613 void LyXText::fullRebreak()
 614 {
 615         redoParagraphs(ownerParagraphs().begin(), ownerParagraphs().end());
 616         redoCursor();
 617         selection.cursor = cursor;
 618 }
 619
 620
 621 void LyXText::metrics(MetricsInfo & mi, Dimension & dim)
 622 {
 623         //lyxerr << "LyXText::metrics: width: " << mi.base.textwidth
 624         //      << " workWidth: " << workWidth() << endl;
 625         //Assert(mi.base.textwidth);
 626
 627         // rebuild row cache
 628         width  = 0;
 629         ///height = 0;
 630
 631         //anchor_y_ = 0;
 632         width = redoParagraphs(ownerParagraphs().begin(), ownerParagraphs().end());
 633
 634         // final dimension
 635         dim.asc = firstRow()->ascent_of_text();
 636         dim.des = height - dim.asc;
 637         dim.wid = std::max(mi.base.textwidth, int(width));
 638 }
 639
 640
 641 // important for the screen
 642
 643
 644 // the cursor set functions have a special mechanism. When they
 645 // realize, that you left an empty paragraph, they will delete it.
 646 // They also delete the corresponding row
 647
 648 // need the selection cursor:
 649 void LyXText::setSelection()
 650 {
 651         TextCursor::setSelection();
 652 }
 653
 654
 655
 656 void LyXText::clearSelection()
 657 {
 658         TextCursor::clearSelection();
 659
 660         // reset this in the bv_owner!
 661         if (bv_owner && bv_owner->text)
 662                 bv_owner->text->xsel_cache.set(false);
 663 }
 664
 665
 666 void LyXText::cursorHome()
 667 {
 668         setCursor(cursor.par(), cursorRow()->pos());
 669 }
 670
 671
 672 void LyXText::cursorEnd()
 673 {
 674         if (cursor.par()->empty())
 675                 return;
 676
 677         RowList::iterator rit = cursorRow();
 678         ParagraphList::iterator pit = cursor.par();
 679         pos_type pos = lastPos(*pit, rit);
 680         /* cursor should be before a hard newline only */
 681         if (!pit->isNewline(pos))
 682                 ++pos;
 683         setCursor(pit, pos);
 684 }
 685
 686
 687 void LyXText::cursorTop()
 688 {
 689         setCursor(ownerParagraphs().begin(), 0);
 690 }
 691
 692
 693 void LyXText::cursorBottom()
 694 {
 695         ParagraphList::iterator lastpit =
 696                 boost::prior(ownerParagraphs().end());
 697         setCursor(lastpit, lastpit->size());
 698 }
 699
 700
 701 void LyXText::toggleFree(LyXFont const & font, bool toggleall)
 702 {
 703         // If the mask is completely neutral, tell user
 704         if (font == LyXFont(LyXFont::ALL_IGNORE)) {
 705                 // Could only happen with user style
 706                 bv()->owner()->message(_("No font change defined. Use Character under the Layout menu to define font change."));
 707                 return;
 708         }
 709
 710         // Try implicit word selection
 711         // If there is a change in the language the implicit word selection
 712         // is disabled.
 713         LyXCursor resetCursor = cursor;
 714         bool implicitSelection = (font.language() == ignore_language
 715                                   && font.number() == LyXFont::IGNORE)
 716                 ? selectWordWhenUnderCursor(lyx::WHOLE_WORD_STRICT) : false;
 717
 718         // Set font
 719         setFont(font, toggleall);
 720
 721         // Implicit selections are cleared afterwards
 722         //and cursor is set to the original position.
 723         if (implicitSelection) {
 724                 clearSelection();
 725                 cursor = resetCursor;
 726                 setCursor(cursor.par(), cursor.pos());
 727                 selection.cursor = cursor;
 728         }
 729 }
 730
 731
 732 string LyXText::getStringToIndex()
 733 {
 734         // Try implicit word selection
 735         // If there is a change in the language the implicit word selection
 736         // is disabled.
 737         LyXCursor const reset_cursor = cursor;
 738         bool const implicitSelection =
 739                 selectWordWhenUnderCursor(lyx::PREVIOUS_WORD);
 740
 741         string idxstring;
 742         if (!selection.set())
 743                 bv()->owner()->message(_("Nothing to index!"));
 744         else if (selection.start.par() != selection.end.par())
 745                 bv()->owner()->message(_("Cannot index more than one paragraph!"));
 746         else
 747                 idxstring = selectionAsString(*bv()->buffer(), false);
 748
 749         // Reset cursors to their original position.
 750         cursor = reset_cursor;
 751         setCursor(cursor.par(), cursor.pos());
 752         selection.cursor = cursor;
 753
 754         // Clear the implicit selection.
 755         if (implicitSelection)
 756                 clearSelection();
 757
 758         return idxstring;
 759 }
 760
 761
 762 // the DTP switches for paragraphs. LyX will store them in the first
 763 // physical paragraph. When a paragraph is broken, the top settings rest,
 764 // the bottom settings are given to the new one. So I can make sure,
 765 // they do not duplicate themself and you cannnot make dirty things with
 766 // them!
 767
 768 void LyXText::setParagraph(bool line_top, bool line_bottom,
 769                            bool pagebreak_top, bool pagebreak_bottom,
 770                            VSpace const & space_top,
 771                            VSpace const & space_bottom,
 772                            Spacing const & spacing,
 773                            LyXAlignment align,
 774                            string const & labelwidthstring,
 775                            bool noindent)
 776 {
 777         LyXCursor tmpcursor = cursor;
 778         if (!selection.set()) {
 779                 selection.start = cursor;
 780                 selection.end = cursor;
 781         }
 782
 783         // make sure that the depth behind the selection are restored, too
 784         ParagraphList::iterator endpit = boost::next(selection.end.par());
 785         ParagraphList::iterator undoendpit = endpit;
 786         ParagraphList::iterator pars_end = ownerParagraphs().end();
 787
 788         if (endpit != pars_end && endpit->getDepth()) {
 789                 while (endpit != pars_end && endpit->getDepth()) {
 790                         ++endpit;
 791                         undoendpit = endpit;
 792                 }
 793         } else if (endpit != pars_end) {
 794                 // because of parindents etc.
 795                 ++endpit;
 796         }
 797
 798         recordUndo(bv(), Undo::ATOMIC, selection.start.par(),
 799                 boost::prior(undoendpit));
 800
 801
 802         ParagraphList::iterator tmppit = selection.end.par();
 803
 804         while (tmppit != boost::prior(selection.start.par())) {
 805                 setCursor(tmppit, 0);
 806
 807                 ParagraphList::iterator pit = cursor.par();
 808                 ParagraphParameters & params = pit->params();
 809
 810                 params.lineTop(line_top);
 811                 params.lineBottom(line_bottom);
 812                 params.pagebreakTop(pagebreak_top);
 813                 params.pagebreakBottom(pagebreak_bottom);
 814                 params.spaceTop(space_top);
 815                 params.spaceBottom(space_bottom);
 816                 params.spacing(spacing);
 817                 // does the layout allow the new alignment?
 818                 LyXLayout_ptr const & layout = pit->layout();
 819
 820                 if (align == LYX_ALIGN_LAYOUT)
 821                         align = layout->align;
 822                 if (align & layout->alignpossible) {
 823                         if (align == layout->align)
 824                                 params.align(LYX_ALIGN_LAYOUT);
 825                         else
 826                                 params.align(align);
 827                 }
 828                 pit->setLabelWidthString(labelwidthstring);
 829                 params.noindent(noindent);
 830                 tmppit = boost::prior(pit);
 831         }
 832
 833         redoParagraphs(selection.start.par(), endpit);
 834
 835         clearSelection();
 836         setCursor(selection.start.par(), selection.start.pos());
 837         selection.cursor = cursor;
 838         setCursor(selection.end.par(), selection.end.pos());
 839         setSelection();
 840         setCursor(tmpcursor.par(), tmpcursor.pos());
 841         if (inset_owner)
 842                 bv()->updateInset(inset_owner);
 843 }
 844
 845
 846 // set the counter of a paragraph. This includes the labels
 847 void LyXText::setCounter(Buffer const & buf, ParagraphList::iterator pit)
 848 {
 849         LyXTextClass const & textclass = buf.params.getLyXTextClass();
 850         LyXLayout_ptr const & layout = pit->layout();
 851
 852         if (pit != ownerParagraphs().begin()) {
 853
 854                 pit->params().appendix(boost::prior(pit)->params().appendix());
 855                 if (!pit->params().appendix() &&
 856                     pit->params().startOfAppendix()) {
 857                         pit->params().appendix(true);
 858                         textclass.counters().reset();
 859                 }
 860                 pit->enumdepth = boost::prior(pit)->enumdepth;
 861                 pit->itemdepth = boost::prior(pit)->itemdepth;
 862         } else {
 863                 pit->params().appendix(pit->params().startOfAppendix());
 864                 pit->enumdepth = 0;
 865                 pit->itemdepth = 0;
 866         }
 867
 868         // Maybe we have to increment the enumeration depth.
 869         // BUT, enumeration in a footnote is considered in isolation from its
 870         //      surrounding paragraph so don't increment if this is the
 871         //      first line of the footnote
 872         // AND, bibliographies can't have their depth changed ie. they
 873         //      are always of depth 0
 874         if (pit != ownerParagraphs().begin()
 875             && boost::prior(pit)->getDepth() < pit->getDepth()
 876             && boost::prior(pit)->layout()->labeltype == LABEL_COUNTER_ENUMI
 877             && pit->enumdepth < 3
 878             && layout->labeltype != LABEL_BIBLIO) {
 879                 pit->enumdepth++;
 880         }
 881
 882         // Maybe we have to decrement the enumeration depth, see note above
 883         if (pit != ownerParagraphs().begin()
 884             && boost::prior(pit)->getDepth() > pit->getDepth()
 885             && layout->labeltype != LABEL_BIBLIO) {
 886                 pit->enumdepth = depthHook(pit, ownerParagraphs(),
 887                                            pit->getDepth())->enumdepth;
 888         }
 889
 890         if (!pit->params().labelString().empty()) {
 891                 pit->params().labelString(string());
 892         }
 893
 894         if (layout->margintype == MARGIN_MANUAL) {
 895                 if (pit->params().labelWidthString().empty())
 896                         pit->setLabelWidthString(layout->labelstring());
 897         } else {
 898                 pit->setLabelWidthString(string());
 899         }
 900
 901         // is it a layout that has an automatic label?
 902         if (layout->labeltype >= LABEL_COUNTER_CHAPTER) {
 903                 int const i = layout->labeltype - LABEL_COUNTER_CHAPTER;
 904
 905                 ostringstream s;
 906
 907                 if (i >= 0 && i <= buf.params.secnumdepth) {
 908                         string numbertype;
 909                         string langtype;
 910
 911                         textclass.counters().step(layout->latexname());
 912
 913                         // Is there a label? Useful for Chapter layout
 914                         if (!pit->params().appendix()) {
 915                                 s << buf.B_(layout->labelstring());
 916                         } else {
 917                                 s << buf.B_(layout->labelstring_appendix());
 918                         }
 919
 920                         // Use of an integer is here less than elegant. For now.
 921                         int head = textclass.maxcounter() - LABEL_COUNTER_CHAPTER;
 922                         if (!pit->params().appendix()) {
 923                                 numbertype = "sectioning";
 924                         } else {
 925                                 numbertype = "appendix";
 926                                 if (pit->isRightToLeftPar(buf.params))
 927                                         langtype = "hebrew";
 928                                 else
 929                                         langtype = "latin";
 930                         }
 931
 932                         s << " "
 933                           << textclass.counters()
 934                                 .numberLabel(layout->latexname(),
 935                                              numbertype, langtype, head);
 936
 937                         pit->params().labelString(STRCONV(s.str()));
 938
 939                         // reset enum counters
 940                         textclass.counters().reset("enum");
 941                 } else if (layout->labeltype < LABEL_COUNTER_ENUMI) {
 942                         textclass.counters().reset("enum");
 943                 } else if (layout->labeltype == LABEL_COUNTER_ENUMI) {
 944                         // FIXME
 945                         // Yes I know this is a really, really! bad solution
 946                         // (Lgb)
 947                         string enumcounter("enum");
 948
 949                         switch (pit->enumdepth) {
 950                         case 2:
 951                                 enumcounter += 'i';
 952                         case 1:
 953                                 enumcounter += 'i';
 954                         case 0:
 955                                 enumcounter += 'i';
 956                                 break;
 957                         case 3:
 958                                 enumcounter += "iv";
 959                                 break;
 960                         default:
 961                                 // not a valid enumdepth...
 962                                 break;
 963                         }
 964
 965                         textclass.counters().step(enumcounter);
 966
 967                         s << textclass.counters()
 968                                 .numberLabel(enumcounter, "enumeration");
 969                         pit->params().labelString(STRCONV(s.str()));
 970                 }
 971         } else if (layout->labeltype == LABEL_BIBLIO) {// ale970302
 972                 textclass.counters().step("bibitem");
 973                 int number = textclass.counters().value("bibitem");
 974                 if (pit->bibitem()) {
 975                         pit->bibitem()->setCounter(number);
 976                         pit->params().labelString(layout->labelstring());
 977                 }
 978                 // In biblio should't be following counters but...
 979         } else {
 980                 string s = buf.B_(layout->labelstring());
 981
 982                 // the caption hack:
 983                 if (layout->labeltype == LABEL_SENSITIVE) {
 984                         ParagraphList::iterator end = ownerParagraphs().end();
 985                         ParagraphList::iterator tmppit = pit;
 986                         InsetOld * in = 0;
 987                         bool isOK = false;
 988                         while (tmppit != end && tmppit->inInset()
 989                                // the single '=' is intended below
 990                                && (in = tmppit->inInset()->owner()))
 991                         {
 992                                 if (in->lyxCode() == InsetOld::FLOAT_CODE ||
 993                                     in->lyxCode() == InsetOld::WRAP_CODE) {
 994                                         isOK = true;
 995                                         break;
 996                                 } else {
 997                                         Paragraph const * owner = &ownerPar(buf, in);
 998                                         tmppit = ownerParagraphs().begin();
 999                                         for ( ; tmppit != end; ++tmppit)
1000                                                 if (&*tmppit == owner)
1001                                                         break;
1002                                 }
1003                         }
1004
1005                         if (isOK) {
1006                                 string type;
1007
1008                                 if (in->lyxCode() == InsetOld::FLOAT_CODE)
1009                                         type = static_cast<InsetFloat*>(in)->params().type;
1010                                 else if (in->lyxCode() == InsetOld::WRAP_CODE)
1011                                         type = static_cast<InsetWrap*>(in)->params().type;
1012                                 else
1013                                         Assert(0);
1014
1015                                 Floating const & fl = textclass.floats().getType(type);
1016
1017                                 textclass.counters().step(fl.type());
1018
1019                                 // Doesn't work... yet.
1020                                 s = bformat(_("%1$s #:"), buf.B_(fl.name()));
1021                         } else {
1022                                 // par->SetLayout(0);
1023                                 // s = layout->labelstring;
1024                                 s = _("Senseless: ");
1025                         }
1026                 }
1027                 pit->params().labelString(s);
1028
1029                 // reset the enumeration counter. They are always reset
1030                 // when there is any other layout between
1031                 // Just fall-through between the cases so that all
1032                 // enum counters deeper than enumdepth is also reset.
1033                 switch (pit->enumdepth) {
1034                 case 0:
1035                         textclass.counters().reset("enumi");
1036                 case 1:
1037                         textclass.counters().reset("enumii");
1038                 case 2:
1039                         textclass.counters().reset("enumiii");
1040                 case 3:
1041                         textclass.counters().reset("enumiv");
1042                 }
1043         }
1044 }
1045
1046
1047 // Updates all counters. Paragraphs with changed label string will be rebroken
1048 void LyXText::updateCounters()
1049 {
1050         // start over
1051         bv()->buffer()->params.getLyXTextClass().counters().reset();
1052
1053         ParagraphList::iterator beg = ownerParagraphs().begin();
1054         ParagraphList::iterator end = ownerParagraphs().end();
1055         for (ParagraphList::iterator pit = beg; pit != end; ++pit) {
1056                 string const oldLabel = pit->params().labelString();
1057
1058                 size_t maxdepth = 0;
1059                 if (pit != beg)
1060                         maxdepth = boost::prior(pit)->getMaxDepthAfter();
1061
1062                 if (pit->params().depth() > maxdepth)
1063                         pit->params().depth(maxdepth);
1064
1065                 // setCounter can potentially change the labelString.
1066                 setCounter(*bv()->buffer(), pit);
1067
1068                 string const & newLabel = pit->params().labelString();
1069
1070                 if (oldLabel != newLabel)
1071                         redoParagraph(pit);
1072         }
1073 }
1074
1075
1076 void LyXText::insertInset(InsetOld * inset)
1077 {
1078         if (!cursor.par()->insetAllowed(inset->lyxCode()))
1079                 return;
1080         recordUndo(bv(), Undo::ATOMIC, cursor.par());
1081         freezeUndo();
1082         cursor.par()->insertInset(cursor.pos(), inset);
1083         // Just to rebreak and refresh correctly.
1084         // The character will not be inserted a second time
1085         insertChar(Paragraph::META_INSET);
1086         // If we enter a highly editable inset the cursor should be before
1087         // the inset. After an Undo LyX tries to call inset->edit(...)
1088         // and fails if the cursor is behind the inset and getInset
1089         // does not return the inset!
1090         if (isHighlyEditableInset(inset))
1091                 cursorLeft(true);
1092         unFreezeUndo();
1093 }
1094
1095
1096 void LyXText::cutSelection(bool doclear, bool realcut)
1097 {
1098         // Stuff what we got on the clipboard. Even if there is no selection.
1099
1100         // There is a problem with having the stuffing here in that the
1101         // larger the selection the slower LyX will get. This can be
1102         // solved by running the line below only when the selection has
1103         // finished. The solution used currently just works, to make it
1104         // faster we need to be more clever and probably also have more
1105         // calls to stuffClipboard. (Lgb)
1106         bv()->stuffClipboard(selectionAsString(*bv()->buffer(), true));
1107
1108         // This doesn't make sense, if there is no selection
1109         if (!selection.set())
1110                 return;
1111
1112         // OK, we have a selection. This is always between selection.start
1113         // and selection.end
1114
1115         // make sure that the depth behind the selection are restored, too
1116         ParagraphList::iterator endpit = boost::next(selection.end.par());
1117         ParagraphList::iterator undoendpit = endpit;
1118         ParagraphList::iterator pars_end = ownerParagraphs().end();
1119
1120         if (endpit != pars_end && endpit->getDepth()) {
1121                 while (endpit != pars_end && endpit->getDepth()) {
1122                         ++endpit;
1123                         undoendpit = endpit;
1124                 }
1125         } else if (endpit != pars_end) {
1126                 // because of parindents etc.
1127                 ++endpit;
1128         }
1129
1130         recordUndo(bv(), Undo::DELETE, selection.start.par(),
1131                    boost::prior(undoendpit));
1132
1133         endpit = selection.end.par();
1134         int endpos = selection.end.pos();
1135
1136         boost::tie(endpit, endpos) = realcut ?
1137                 CutAndPaste::cutSelection(bv()->buffer()->params,
1138                                           ownerParagraphs(),
1139                                           selection.start.par(), endpit,
1140                                           selection.start.pos(), endpos,
1141                                           bv()->buffer()->params.textclass,
1142                                           doclear)
1143                 : CutAndPaste::eraseSelection(bv()->buffer()->params,
1144                                               ownerParagraphs(),
1145                                               selection.start.par(), endpit,
1146                                               selection.start.pos(), endpos,
1147                                               doclear);
1148         // sometimes necessary
1149         if (doclear)
1150                 selection.start.par()->stripLeadingSpaces();
1151
1152         redoParagraphs(selection.start.par(), boost::next(endpit));
1153         // cutSelection can invalidate the cursor so we need to set
1154         // it anew. (Lgb)
1155         // we prefer the end for when tracking changes
1156         cursor.pos(endpos);
1157         cursor.par(endpit);
1158
1159         // need a valid cursor. (Lgb)
1160         clearSelection();
1161
1162         setCursor(cursor.par(), cursor.pos());
1163         selection.cursor = cursor;
1164         updateCounters();
1165 }
1166
1167
1168 void LyXText::copySelection()
1169 {
1170         // stuff the selection onto the X clipboard, from an explicit copy request
1171         bv()->stuffClipboard(selectionAsString(*bv()->buffer(), true));
1172
1173         // this doesnt make sense, if there is no selection
1174         if (!selection.set())
1175                 return;
1176
1177         // ok we have a selection. This is always between selection.start
1178         // and sel_end cursor
1179
1180         // copy behind a space if there is one
1181         while (selection.start.par()->size() > selection.start.pos()
1182                && selection.start.par()->isLineSeparator(selection.start.pos())
1183                && (selection.start.par() != selection.end.par()
1184                    || selection.start.pos() < selection.end.pos()))
1185                 selection.start.pos(selection.start.pos() + 1);
1186
1187         CutAndPaste::copySelection(selection.start.par(),
1188                                    selection.end.par(),
1189                                    selection.start.pos(), selection.end.pos(),
1190                                    bv()->buffer()->params.textclass);
1191 }
1192
1193
1194 void LyXText::pasteSelection(size_t sel_index)
1195 {
1196         // this does not make sense, if there is nothing to paste
1197         if (!CutAndPaste::checkPastePossible())
1198                 return;
1199
1200         recordUndo(bv(), Undo::INSERT, cursor.par());
1201
1202         ParagraphList::iterator endpit;
1203         PitPosPair ppp;
1204
1205         ErrorList el;
1206
1207         boost::tie(ppp, endpit) =
1208                 CutAndPaste::pasteSelection(*bv()->buffer(),
1209                                             ownerParagraphs(),
1210                                             cursor.par(), cursor.pos(),
1211                                             bv()->buffer()->params.textclass,
1212                                             sel_index, el);
1213         bufferErrors(*bv()->buffer(), el);
1214         bv()->showErrorList(_("Paste"));
1215
1216         redoParagraphs(cursor.par(), endpit);
1217
1218         setCursor(cursor.par(), cursor.pos());
1219         clearSelection();
1220
1221         selection.cursor = cursor;
1222         setCursor(ppp.first, ppp.second);
1223         setSelection();
1224         updateCounters();
1225 }
1226
1227
1228 void LyXText::setSelectionRange(lyx::pos_type length)
1229 {
1230         if (!length)
1231                 return;
1232
1233         selection.cursor = cursor;
1234         while (length--)
1235                 cursorRight(bv());
1236         setSelection();
1237 }
1238
1239
1240 // simple replacing. The font of the first selected character is used
1241 void LyXText::replaceSelectionWithString(string const & str)
1242 {
1243         recordUndo(bv(), Undo::ATOMIC);
1244         freezeUndo();
1245
1246         if (!selection.set()) { // create a dummy selection
1247                 selection.end = cursor;
1248                 selection.start = cursor;
1249         }
1250
1251         // Get font setting before we cut
1252         pos_type pos = selection.end.pos();
1253         LyXFont const font = selection.start.par()
1254                 ->getFontSettings(bv()->buffer()->params,
1255                                   selection.start.pos());
1256
1257         // Insert the new string
1258         string::const_iterator cit = str.begin();
1259         string::const_iterator end = str.end();
1260         for (; cit != end; ++cit) {
1261                 selection.end.par()->insertChar(pos, (*cit), font);
1262                 ++pos;
1263         }
1264
1265         // Cut the selection
1266         cutSelection(true, false);
1267
1268         unFreezeUndo();
1269 }
1270
1271
1272 // needed to insert the selection
1273 void LyXText::insertStringAsLines(string const & str)
1274 {
1275         ParagraphList::iterator pit = cursor.par();
1276         pos_type pos = cursor.pos();
1277         ParagraphList::iterator endpit = boost::next(cursor.par());
1278
1279         recordUndo(bv(), Undo::ATOMIC);
1280
1281         // only to be sure, should not be neccessary
1282         clearSelection();
1283
1284         bv()->buffer()->insertStringAsLines(pit, pos, current_font, str);
1285
1286         redoParagraphs(cursor.par(), endpit);
1287         setCursor(cursor.par(), cursor.pos());
1288         selection.cursor = cursor;
1289         setCursor(pit, pos);
1290         setSelection();
1291 }
1292
1293
1294 // turns double-CR to single CR, others where converted into one
1295 // blank. Then InsertStringAsLines is called
1296 void LyXText::insertStringAsParagraphs(string const & str)
1297 {
1298         string linestr(str);
1299         bool newline_inserted = false;
1300         string::size_type const siz = linestr.length();
1301
1302         for (string::size_type i = 0; i < siz; ++i) {
1303                 if (linestr[i] == '\n') {
1304                         if (newline_inserted) {
1305                                 // we know that \r will be ignored by
1306                                 // InsertStringA. Of course, it is a dirty
1307                                 // trick, but it works...
1308                                 linestr[i - 1] = '\r';
1309                                 linestr[i] = '\n';
1310                         } else {
1311                                 linestr[i] = ' ';
1312                                 newline_inserted = true;
1313                         }
1314                 } else if (IsPrintable(linestr[i])) {
1315                         newline_inserted = false;
1316                 }
1317         }
1318         insertStringAsLines(linestr);
1319 }
1320
1321
1322 bool LyXText::setCursor(ParagraphList::iterator pit,
1323                         pos_type pos,
1324                         bool setfont, bool boundary)
1325 {
1326         LyXCursor old_cursor = cursor;
1327         setCursorIntern(pit, pos, setfont, boundary);
1328         return deleteEmptyParagraphMechanism(old_cursor);
1329 }
1330
1331
1332 void LyXText::redoCursor()
1333 {
1334 #warning maybe the same for selections?
1335         setCursor(cursor, cursor.par(), cursor.pos(), cursor.boundary());
1336 }
1337
1338
1339 void LyXText::setCursor(LyXCursor & cur, ParagraphList::iterator pit,
1340                         pos_type pos, bool boundary)
1341 {
1342         Assert(pit != ownerParagraphs().end());
1343
1344         cur.par(pit);
1345         cur.pos(pos);
1346         cur.boundary(boundary);
1347         if (noRows())
1348                 return;
1349
1350         // get the cursor y position in text
1351
1352         RowList::iterator row = getRow(pit, pos);
1353         int y = row->y();
1354
1355         RowList::iterator old_row = row;
1356         // if we are before the first char of this row and are still in the
1357         // same paragraph and there is a previous row then put the cursor on
1358         // the end of the previous row
1359         cur.iy(y + row->baseline());
1360
1361         // y is now the beginning of the cursor row
1362         y += row->baseline();
1363         // y is now the cursor baseline
1364         cur.y(y);
1365
1366         pos_type last = lastPrintablePos(*pit, old_row);
1367
1368         // None of these should happen, but we're scaredy-cats
1369         if (pos > pit->size()) {
1370                 lyxerr << "dont like 1, pos: " << pos << " size: " << pit->size() << endl;
1371                 pos = 0;
1372                 cur.pos(0);
1373         } else if (pos > last + 1) {
1374                 lyxerr << "dont like 2 please report" << endl;
1375                 // This shouldn't happen.
1376                 pos = last + 1;
1377                 cur.pos(pos);
1378         } else if (pos < row->pos()) {
1379                 lyxerr << "dont like 3 please report" << endl;
1380                 pos = row->pos();
1381                 cur.pos(pos);
1382         }
1383
1384         // now get the cursors x position
1385         float x = getCursorX(pit, row, pos, last, boundary);
1386         cur.x(int(x));
1387         cur.x_fix(cur.x());
1388         if (old_row != row) {
1389                 x = getCursorX(pit, old_row, pos, last, boundary);
1390                 cur.ix(int(x));
1391         } else
1392                 cur.ix(cur.x());
1393 }
1394
1395
1396 float LyXText::getCursorX(ParagraphList::iterator pit, RowList::iterator rit,
1397                           pos_type pos, pos_type last, bool boundary) const
1398 {
1399         pos_type cursor_vpos    = 0;
1400         double x                = rit->x();
1401         double fill_separator   = rit->fill_separator();
1402         double fill_hfill       = rit->fill_hfill();
1403         double fill_label_hfill = rit->fill_label_hfill();
1404         pos_type const rit_pos  = rit->pos();
1405
1406         if (last < rit_pos)
1407                 cursor_vpos = rit_pos;
1408         else if (pos > last && !boundary)
1409                 cursor_vpos = (pit->isRightToLeftPar(bv()->buffer()->params))
1410                         ? rit_pos : last + 1;
1411         else if (pos > rit_pos && (pos > last || boundary))
1412                 // Place cursor after char at (logical) position pos - 1
1413                 cursor_vpos = (bidi_level(pos - 1) % 2 == 0)
1414                         ? log2vis(pos - 1) + 1 : log2vis(pos - 1);
1415         else
1416                 // Place cursor before char at (logical) position pos
1417                 cursor_vpos = (bidi_level(pos) % 2 == 0)
1418                         ? log2vis(pos) : log2vis(pos) + 1;
1419
1420         pos_type body_pos = pit->beginningOfBody();
1421         if (body_pos > 0 &&
1422             (body_pos - 1 > last || !pit->isLineSeparator(body_pos - 1)))
1423                 body_pos = 0;
1424
1425         for (pos_type vpos = rit_pos; vpos < cursor_vpos; ++vpos) {
1426                 pos_type pos = vis2log(vpos);
1427                 if (body_pos > 0 && pos == body_pos - 1) {
1428                         x += fill_label_hfill +
1429                                 font_metrics::width(
1430                                         pit->layout()->labelsep, getLabelFont(pit));
1431                         if (pit->isLineSeparator(body_pos - 1))
1432                                 x -= singleWidth(pit, body_pos - 1);
1433                 }
1434
1435                 if (hfillExpansion(*pit, rit, pos)) {
1436                         x += singleWidth(pit, pos);
1437                         if (pos >= body_pos)
1438                                 x += fill_hfill;
1439                         else
1440                                 x += fill_label_hfill;
1441                 } else if (pit->isSeparator(pos)) {
1442                         x += singleWidth(pit, pos);
1443                         if (pos >= body_pos)
1444                                 x += fill_separator;
1445                 } else
1446                         x += singleWidth(pit, pos);
1447         }
1448         return x;
1449 }
1450
1451
1452 void LyXText::setCursorIntern(ParagraphList::iterator pit,
1453                               pos_type pos, bool setfont, bool boundary)
1454 {
1455         setCursor(cursor, pit, pos, boundary);
1456         if (setfont)
1457                 setCurrentFont();
1458 }
1459
1460
1461 void LyXText::setCurrentFont()
1462 {
1463         pos_type pos = cursor.pos();
1464         ParagraphList::iterator pit = cursor.par();
1465
1466         if (cursor.boundary() && pos > 0)
1467                 --pos;
1468
1469         if (pos > 0) {
1470                 if (pos == pit->size())
1471                         --pos;
1472                 else // potentional bug... BUG (Lgb)
1473                         if (pit->isSeparator(pos)) {
1474                                 if (pos > cursorRow()->pos() &&
1475                                     bidi_level(pos) % 2 ==
1476                                     bidi_level(pos - 1) % 2)
1477                                         --pos;
1478                                 else if (pos + 1 < pit->size())
1479                                         ++pos;
1480                         }
1481         }
1482
1483         current_font = pit->getFontSettings(bv()->buffer()->params, pos);
1484         real_current_font = getFont(pit, pos);
1485
1486         if (cursor.pos() == pit->size() &&
1487             isBoundary(*bv()->buffer(), *pit, cursor.pos()) &&
1488             !cursor.boundary()) {
1489                 Language const * lang =
1490                         pit->getParLanguage(bv()->buffer()->params);
1491                 current_font.setLanguage(lang);
1492                 current_font.setNumber(LyXFont::OFF);
1493                 real_current_font.setLanguage(lang);
1494                 real_current_font.setNumber(LyXFont::OFF);
1495         }
1496 }
1497
1498
1499 // returns the column near the specified x-coordinate of the row
1500 // x is set to the real beginning of this column
1501 pos_type LyXText::getColumnNearX(ParagraphList::iterator pit,
1502         RowList::iterator rit, int & x, bool & boundary) const
1503 {
1504         double tmpx             = rit->x();
1505         double fill_separator   = rit->fill_separator();
1506         double fill_hfill       = rit->fill_hfill();
1507         double fill_label_hfill = rit->fill_label_hfill();
1508
1509         pos_type vc = rit->pos();
1510         pos_type last = lastPrintablePos(*pit, rit);
1511         pos_type c = 0;
1512         LyXLayout_ptr const & layout = pit->layout();
1513
1514         bool left_side = false;
1515
1516         pos_type body_pos = pit->beginningOfBody();
1517         double last_tmpx = tmpx;
1518
1519         if (body_pos > 0 &&
1520             (body_pos - 1 > last ||
1521              !pit->isLineSeparator(body_pos - 1)))
1522                 body_pos = 0;
1523
1524         // check for empty row
1525         if (!pit->size()) {
1526                 x = int(tmpx);
1527                 return 0;
1528         }
1529
1530         while (vc <= last && tmpx <= x) {
1531                 c = vis2log(vc);
1532                 last_tmpx = tmpx;
1533                 if (body_pos > 0 && c == body_pos - 1) {
1534                         tmpx += fill_label_hfill +
1535                                 font_metrics::width(layout->labelsep, getLabelFont(pit));
1536                         if (pit->isLineSeparator(body_pos - 1))
1537                                 tmpx -= singleWidth(pit, body_pos - 1);
1538                 }
1539
1540                 if (hfillExpansion(*pit, rit, c)) {
1541                         tmpx += singleWidth(pit, c);
1542                         if (c >= body_pos)
1543                                 tmpx += fill_hfill;
1544                         else
1545                                 tmpx += fill_label_hfill;
1546                 } else if (pit->isSeparator(c)) {
1547                         tmpx += singleWidth(pit, c);
1548                         if (c >= body_pos)
1549                                 tmpx += fill_separator;
1550                 } else {
1551                         tmpx += singleWidth(pit, c);
1552                 }
1553                 ++vc;
1554         }
1555
1556         if ((tmpx + last_tmpx) / 2 > x) {
1557                 tmpx = last_tmpx;
1558                 left_side = true;
1559         }
1560
1561         if (vc > last + 1)  // This shouldn't happen.
1562                 vc = last + 1;
1563
1564         boundary = false;
1565         // This (rtl_support test) is not needed, but gives
1566         // some speedup if rtl_support == false
1567         bool const lastrow = lyxrc.rtl_support
1568                         && boost::next(rit) == pit->rows.end();
1569
1570         // If lastrow is false, we don't need to compute
1571         // the value of rtl.
1572         bool const rtl = (lastrow)
1573                 ? pit->isRightToLeftPar(bv()->buffer()->params)
1574                 : false;
1575         if (lastrow &&
1576                  ((rtl  &&  left_side && vc == rit->pos() && x < tmpx - 5) ||
1577                   (!rtl && !left_side && vc == last + 1   && x > tmpx + 5)))
1578                 c = last + 1;
1579         else if (vc == rit->pos()) {
1580                 c = vis2log(vc);
1581                 if (bidi_level(c) % 2 == 1)
1582                         ++c;
1583         } else {
1584                 c = vis2log(vc - 1);
1585                 bool const rtl = (bidi_level(c) % 2 == 1);
1586                 if (left_side == rtl) {
1587                         ++c;
1588                         boundary = isBoundary(*bv()->buffer(), *pit, c);
1589                 }
1590         }
1591
1592         if (rit->pos() <= last && c > last && pit->isNewline(last)) {
1593                 if (bidi_level(last) % 2 == 0)
1594                         tmpx -= singleWidth(pit, last);
1595                 else
1596                         tmpx += singleWidth(pit, last);
1597                 c = last;
1598         }
1599
1600         c -= rit->pos();
1601         x = int(tmpx);
1602         return c;
1603 }
1604
1605
1606 void LyXText::setCursorFromCoordinates(int x, int y)
1607 {
1608         LyXCursor old_cursor = cursor;
1609         setCursorFromCoordinates(cursor, x, y);
1610         setCurrentFont();
1611         deleteEmptyParagraphMechanism(old_cursor);
1612 }
1613
1614
1615 void LyXText::setCursorFromCoordinates(LyXCursor & cur, int x, int y)
1616 {
1617         // Get the row first.
1618         ParagraphList::iterator pit;
1619         RowList::iterator rit = getRowNearY(y, pit);
1620         y = rit->y();
1621
1622         bool bound = false;
1623         pos_type const column = getColumnNearX(pit, rit, x, bound);
1624         cur.par(pit);
1625         cur.pos(rit->pos() + column);
1626         cur.x(x);
1627         cur.y(y + rit->baseline());
1628
1629         cur.iy(cur.y());
1630         cur.ix(cur.x());
1631
1632         cur.boundary(bound);
1633 }
1634
1635
1636 void LyXText::cursorLeft(bool internal)
1637 {
1638         if (cursor.pos() > 0) {
1639                 bool boundary = cursor.boundary();
1640                 setCursor(cursor.par(), cursor.pos() - 1, true, false);
1641                 if (!internal && !boundary &&
1642                     isBoundary(*bv()->buffer(), *cursor.par(), cursor.pos() + 1))
1643                         setCursor(cursor.par(), cursor.pos() + 1, true, true);
1644         } else if (cursor.par() != ownerParagraphs().begin()) {
1645                 // steps into the paragraph above
1646                 ParagraphList::iterator pit = boost::prior(cursor.par());
1647                 setCursor(pit, pit->size());
1648         }
1649 }
1650
1651
1652 void LyXText::cursorRight(bool internal)
1653 {
1654         bool const at_end = (cursor.pos() == cursor.par()->size());
1655         bool const at_newline = !at_end &&
1656                 cursor.par()->isNewline(cursor.pos());
1657
1658         if (!internal && cursor.boundary() && !at_newline)
1659                 setCursor(cursor.par(), cursor.pos(), true, false);
1660         else if (!at_end) {
1661                 setCursor(cursor.par(), cursor.pos() + 1, true, false);
1662                 if (!internal &&
1663                     isBoundary(*bv()->buffer(), *cursor.par(), cursor.pos()))
1664                         setCursor(cursor.par(), cursor.pos(), true, true);
1665         } else if (boost::next(cursor.par()) != ownerParagraphs().end())
1666                 setCursor(boost::next(cursor.par()), 0);
1667 }
1668
1669
1670 void LyXText::cursorUp(bool selecting)
1671 {
1672 #if 1
1673         int x = cursor.x_fix();
1674         int y = cursor.y() - cursorRow()->baseline() - 1;
1675         setCursorFromCoordinates(x, y);
1676         if (!selecting) {
1677                 int topy = bv_owner->top_y();
1678                 int y1 = cursor.iy() - topy;
1679                 int y2 = y1;
1680                 y -= topy;
1681                 InsetOld * inset_hit = checkInsetHit(x, y1);
1682                 if (inset_hit && isHighlyEditableInset(inset_hit)) {
1683                         inset_hit->localDispatch(
1684                                 FuncRequest(bv(), LFUN_INSET_EDIT, x, y - (y2 - y1), mouse_button::none));
1685                 }
1686         }
1687 #else
1688         lyxerr << "cursorUp: y " << cursor.y() << " bl: " <<
1689                 cursorRow()->baseline() << endl;
1690         setCursorFromCoordinates(cursor.x_fix(),
1691                 cursor.y() - cursorRow()->baseline() - 1);
1692 #endif
1693 }
1694
1695
1696 void LyXText::cursorDown(bool selecting)
1697 {
1698 #if 1
1699         int x = cursor.x_fix();
1700         int y = cursor.y() - cursorRow()->baseline() + cursorRow()->height() + 1;
1701         setCursorFromCoordinates(x, y);
1702         if (!selecting && cursorRow() == cursorIRow()) {
1703                 int topy = bv_owner->top_y();
1704                 int y1 = cursor.iy() - topy;
1705                 int y2 = y1;
1706                 y -= topy;
1707                 InsetOld * inset_hit = checkInsetHit(x, y1);
1708                 if (inset_hit && isHighlyEditableInset(inset_hit)) {
1709                         FuncRequest cmd(bv(), LFUN_INSET_EDIT, x, y - (y2 - y1), mouse_button::none);
1710                         inset_hit->localDispatch(cmd);
1711                 }
1712         }
1713 #else
1714         setCursorFromCoordinates(cursor.x_fix(),
1715                  cursor.y() - cursorRow()->baseline() + cursorRow()->height() + 1);
1716 #endif
1717 }
1718
1719
1720 void LyXText::cursorUpParagraph()
1721 {
1722         if (cursor.pos() > 0)
1723                 setCursor(cursor.par(), 0);
1724         else if (cursor.par() != ownerParagraphs().begin())
1725                 setCursor(boost::prior(cursor.par()), 0);
1726 }
1727
1728
1729 void LyXText::cursorDownParagraph()
1730 {
1731         ParagraphList::iterator par = cursor.par();
1732         ParagraphList::iterator next_par = boost::next(par);
1733
1734         if (next_par != ownerParagraphs().end())
1735                 setCursor(next_par, 0);
1736         else
1737                 setCursor(par, par->size());
1738 }
1739
1740
1741 // fix the cursor `cur' after a characters has been deleted at `where'
1742 // position. Called by deleteEmptyParagraphMechanism
1743 void LyXText::fixCursorAfterDelete(LyXCursor & cur, LyXCursor const & where)
1744 {
1745         // if cursor is not in the paragraph where the delete occured,
1746         // do nothing
1747         if (cur.par() != where.par())
1748                 return;
1749
1750         // if cursor position is after the place where the delete occured,
1751         // update it
1752         if (cur.pos() > where.pos())
1753                 cur.pos(cur.pos()-1);
1754
1755         // check also if we don't want to set the cursor on a spot behind the
1756         // pagragraph because we erased the last character.
1757         if (cur.pos() > cur.par()->size())
1758                 cur.pos(cur.par()->size());
1759
1760         // recompute row et al. for this cursor
1761         setCursor(cur, cur.par(), cur.pos(), cur.boundary());
1762 }
1763
1764
1765 bool LyXText::deleteEmptyParagraphMechanism(LyXCursor const & old_cursor)
1766 {
1767         // Would be wrong to delete anything if we have a selection.
1768         if (selection.set())
1769                 return false;
1770
1771         // We allow all kinds of "mumbo-jumbo" when freespacing.
1772         if (old_cursor.par()->isFreeSpacing())
1773                 return false;
1774
1775         /* Ok I'll put some comments here about what is missing.
1776            I have fixed BackSpace (and thus Delete) to not delete
1777            double-spaces automagically. I have also changed Cut,
1778            Copy and Paste to hopefully do some sensible things.
1779            There are still some small problems that can lead to
1780            double spaces stored in the document file or space at
1781            the beginning of paragraphs. This happens if you have
1782            the cursor between to spaces and then save. Or if you
1783            cut and paste and the selection have a space at the
1784            beginning and then save right after the paste. I am
1785            sure none of these are very hard to fix, but I will
1786            put out 1.1.4pre2 with FIX_DOUBLE_SPACE defined so
1787            that I can get some feedback. (Lgb)
1788         */
1789
1790         // If old_cursor.pos() == 0 and old_cursor.pos()(1) == LineSeparator
1791         // delete the LineSeparator.
1792         // MISSING
1793
1794         // If old_cursor.pos() == 1 and old_cursor.pos()(0) == LineSeparator
1795         // delete the LineSeparator.
1796         // MISSING
1797
1798         // If the pos around the old_cursor were spaces, delete one of them.
1799         if (old_cursor.par() != cursor.par()
1800             || old_cursor.pos() != cursor.pos()) {
1801
1802                 // Only if the cursor has really moved
1803                 if (old_cursor.pos() > 0
1804                     && old_cursor.pos() < old_cursor.par()->size()
1805                     && old_cursor.par()->isLineSeparator(old_cursor.pos())
1806                     && old_cursor.par()->isLineSeparator(old_cursor.pos() - 1)) {
1807                         bool erased = old_cursor.par()->erase(old_cursor.pos() - 1);
1808                         redoParagraph(old_cursor.par());
1809
1810                         if (!erased)
1811                                 return false;
1812 #ifdef WITH_WARNINGS
1813 #warning This will not work anymore when we have multiple views of the same buffer
1814 // In this case, we will have to correct also the cursors held by
1815 // other bufferviews. It will probably be easier to do that in a more
1816 // automated way in LyXCursor code. (JMarc 26/09/2001)
1817 #endif
1818                         // correct all cursors held by the LyXText
1819                         fixCursorAfterDelete(cursor, old_cursor);
1820                         fixCursorAfterDelete(selection.cursor, old_cursor);
1821                         fixCursorAfterDelete(selection.start, old_cursor);
1822                         fixCursorAfterDelete(selection.end, old_cursor);
1823                         return false;
1824                 }
1825         }
1826
1827         // don't delete anything if this is the ONLY paragraph!
1828         if (ownerParagraphs().size() == 1)
1829                 return false;
1830
1831         // Do not delete empty paragraphs with keepempty set.
1832         if (old_cursor.par()->allowEmpty())
1833                 return false;
1834
1835         // only do our magic if we changed paragraph
1836         if (old_cursor.par() == cursor.par())
1837                 return false;
1838
1839         // record if we have deleted a paragraph
1840         // we can't possibly have deleted a paragraph before this point
1841         bool deleted = false;
1842
1843         if (old_cursor.par()->empty() ||
1844             (old_cursor.par()->size() == 1 &&
1845              old_cursor.par()->isLineSeparator(0))) {
1846                 // ok, we will delete something
1847                 LyXCursor tmpcursor;
1848
1849                 deleted = true;
1850
1851                 bool selection_position_was_oldcursor_position = (
1852                         selection.cursor.par()  == old_cursor.par()
1853                         && selection.cursor.pos() == old_cursor.pos());
1854
1855                 tmpcursor = cursor;
1856                 cursor = old_cursor; // that undo can restore the right cursor position
1857
1858                 ParagraphList::iterator endpit = boost::next(old_cursor.par());
1859                 while (endpit != ownerParagraphs().end() && endpit->getDepth())
1860                         ++endpit;
1861
1862                 recordUndo(bv(), Undo::DELETE, old_cursor.par(), boost::prior(endpit));
1863                 cursor = tmpcursor;
1864
1865                 // delete old par
1866                 ownerParagraphs().erase(old_cursor.par());
1867                 redoParagraph();
1868
1869                 // correct cursor y
1870                 setCursorIntern(cursor.par(), cursor.pos());
1871
1872                 if (selection_position_was_oldcursor_position) {
1873                         // correct selection
1874                         selection.cursor = cursor;
1875                 }
1876         }
1877         if (!deleted) {
1878                 if (old_cursor.par()->stripLeadingSpaces()) {
1879                         redoParagraph(old_cursor.par());
1880                         // correct cursor y
1881                         setCursorIntern(cursor.par(), cursor.pos());
1882                         selection.cursor = cursor;
1883                 }
1884         }
1885         return deleted;
1886 }
1887
1888
1889 ParagraphList & LyXText::ownerParagraphs() const
1890 {
1891         return paragraphs_;
1892 }
1893
1894
1895 bool LyXText::isInInset() const
1896 {
1897         // Sub-level has non-null bv owner and non-null inset owner.
1898         return inset_owner != 0;
1899 }
1900
1901
1902 int defaultRowHeight()
1903 {
1904         LyXFont const font(LyXFont::ALL_SANE);
1905         return int(font_metrics::maxAscent(font)
1906                  + font_metrics::maxDescent(font) * 1.5);
1907 }