src/text2.C

   1 /* This file is part of
   2  * ======================================================
   3  *
   4  *           LyX, The Document Processor
   5  *
   6  *           Copyright 1995 Matthias Ettrich
   7  *           Copyright 1995-2001 The LyX Team.
   8  *
   9  * ====================================================== */
  10
  11 #include <config.h>
  12
  13 #include "lyxtext.h"
  14 #include "LString.h"
  15 #include "paragraph.h"
  16 #include "frontends/LyXView.h"
  17 #include "undo_funcs.h"
  18 #include "buffer.h"
  19 #include "bufferparams.h"
  20 #include "gettext.h"
  21 #include "BufferView.h"
  22 #include "CutAndPaste.h"
  23 #include "frontends/Painter.h"
  24 #include "frontends/font_metrics.h"
  25 #include "debug.h"
  26 #include "lyxrc.h"
  27 #include "lyxrow.h"
  28 #include "FloatList.h"
  29 #include "language.h"
  30 #include "ParagraphParameters.h"
  31 #include "counters.h"
  32 #include "lyxrow_funcs.h"
  33 #include "paragraph_funcs.h"
  34
  35 #include "insets/insetbibitem.h"
  36 #include "insets/insetfloat.h"
  37
  38 #include "support/LAssert.h"
  39 #include "support/textutils.h"
  40 #include "support/lstrings.h"
  41
  42 #include "support/BoostFormat.h"
  43 #include <boost/tuple/tuple.hpp>
  44
  45 using std::vector;
  46 using std::copy;
  47 using std::endl;
  48 using std::find;
  49 using std::pair;
  50 using lyx::pos_type;
  51
  52
  53 LyXText::LyXText(BufferView * bv)
  54         : height(0), width(0), anchor_row_offset_(0),
  55           inset_owner(0), the_locking_inset(0), bv_owner(bv)
  56 {
  57         anchor_row_ = rows().end();
  58         need_break_row = rows().end();
  59         refresh_row = rows().end();
  60
  61         clearPaint();
  62 }
  63
  64
  65 LyXText::LyXText(BufferView * bv, InsetText * inset)
  66         : height(0), width(0), anchor_row_offset_(0),
  67           inset_owner(inset), the_locking_inset(0), bv_owner(bv)
  68 {
  69         anchor_row_ = rows().end();
  70         need_break_row = rows().end();
  71         refresh_row = rows().end();
  72
  73         clearPaint();
  74 }
  75
  76
  77 void LyXText::init(BufferView * bview, bool reinit)
  78 {
  79         if (reinit) {
  80                 rowlist_.clear();
  81                 need_break_row = rows().end();
  82                 width = height = 0;
  83                 top_y(0);
  84                 clearPaint();
  85         } else if (!rowlist_.empty())
  86                 return;
  87
  88         ParagraphList::iterator pit = ownerParagraphs().begin();
  89         ParagraphList::iterator end = ownerParagraphs().end();
  90
  91         current_font = getFont(bview->buffer(), pit, 0);
  92
  93         for (; pit != end; ++pit) {
  94                 insertParagraph(pit, rowlist_.end());
  95         }
  96         setCursorIntern(rowlist_.begin()->par(), 0);
  97         selection.cursor = cursor;
  98
  99         updateCounters();
 100 }
 101
 102
 103 // Gets the fully instantiated font at a given position in a paragraph
 104 // Basically the same routine as Paragraph::getFont() in paragraph.C.
 105 // The difference is that this one is used for displaying, and thus we
 106 // are allowed to make cosmetic improvements. For instance make footnotes
 107 // smaller. (Asger)
 108 // If position is -1, we get the layout font of the paragraph.
 109 // If position is -2, we get the font of the manual label of the paragraph.
 110 LyXFont const LyXText::getFont(Buffer const * buf, ParagraphList::iterator pit,
 111                                pos_type pos) const
 112 {
 113         lyx::Assert(pos >= 0);
 114
 115         LyXLayout_ptr const & layout = pit->layout();
 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(buf->params, pos);
 123                         if (pit->inInset())
 124                                 pit->inInset()->getDrawFont(f);
 125                         return f.realize(layout->reslabelfont);
 126                 } else {
 127                         LyXFont f = pit->getFontSettings(buf->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(buf->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
 155         return realizeFont(tmpfont, buf->params);
 156 }
 157
 158
 159 LyXFont const LyXText::getLayoutFont(Buffer const * buf,
 160                                      ParagraphList::iterator pit) const
 161 {
 162         LyXLayout_ptr const & layout = pit->layout();
 163
 164         if (!pit->getDepth()) {
 165                 return layout->resfont;
 166         }
 167
 168         LyXFont font(layout->font);
 169         // Realize with the fonts of lesser depth.
 170         font.realize(outerFont(pit, ownerParagraphs()));
 171
 172         return realizeFont(font, buf->params);
 173 }
 174
 175
 176 LyXFont const LyXText::getLabelFont(Buffer const * buf,
 177                                     ParagraphList::iterator pit) const
 178 {
 179         LyXLayout_ptr const & layout = pit->layout();
 180
 181         if (!pit->getDepth()) {
 182                 return layout->reslabelfont;
 183         }
 184
 185         LyXFont font(layout->labelfont);
 186         // Realize with the fonts of lesser depth.
 187         font.realize(outerFont(pit, ownerParagraphs()));
 188
 189         return realizeFont(layout->labelfont, buf->params);
 190 }
 191
 192
 193 void LyXText::setCharFont(ParagraphList::iterator pit,
 194                           pos_type pos, LyXFont const & fnt,
 195                           bool toggleall)
 196 {
 197         Buffer const * buf = bv()->buffer();
 198         LyXFont font = getFont(buf, pit, pos);
 199         font.update(fnt, buf->params.language, toggleall);
 200         // Let the insets convert their font
 201         if (pit->isInset(pos)) {
 202                 Inset * inset = pit->getInset(pos);
 203                 if (isEditableInset(inset)) {
 204                         UpdatableInset * uinset =
 205                                 static_cast<UpdatableInset *>(inset);
 206                         uinset->setFont(bv(), fnt, toggleall, true);
 207                 }
 208         }
 209
 210         // Plug thru to version below:
 211         setCharFont(buf, pit, pos, font);
 212 }
 213
 214
 215 void LyXText::setCharFont(Buffer const * buf, ParagraphList::iterator pit,
 216                           pos_type pos, LyXFont const & fnt)
 217 {
 218         LyXFont font(fnt);
 219
 220         LyXTextClass const & tclass = buf->params.getLyXTextClass();
 221         LyXLayout_ptr const & layout = pit->layout();
 222
 223         // Get concrete layout font to reduce against
 224         LyXFont layoutfont;
 225
 226         if (pos < pit->beginningOfBody())
 227                 layoutfont = layout->labelfont;
 228         else
 229                 layoutfont = layout->font;
 230
 231         // Realize against environment font information
 232         if (pit->getDepth()) {
 233                 ParagraphList::iterator tp = pit;
 234                 while (!layoutfont.resolved() &&
 235                        tp != ownerParagraphs().end() &&
 236                        tp->getDepth()) {
 237                         tp = outerHook(tp, ownerParagraphs());
 238                         if (tp != ownerParagraphs().end())
 239                                 layoutfont.realize(tp->layout()->font);
 240                 }
 241         }
 242
 243         layoutfont.realize(tclass.defaultfont());
 244
 245         // Now, reduce font against full layout font
 246         font.reduce(layoutfont);
 247
 248         pit->setFont(pos, font);
 249 }
 250
 251
 252 // removes the row and reset the touched counters
 253 void LyXText::removeRow(RowList::iterator rit)
 254 {
 255         /* FIXME: when we cache the bview, this should just
 256          * become a postPaint(), I think */
 257         if (refresh_row == rit) {
 258                 if (rit == rows().begin())
 259                         refresh_row = boost::next(rit);
 260                 else
 261                         refresh_row = boost::prior(rit);
 262
 263                 // what about refresh_y
 264         }
 265
 266         if (anchor_row_ == rit) {
 267                 if (rit != rows().begin()) {
 268                         anchor_row_ = boost::prior(rit);
 269                         anchor_row_offset_ += anchor_row_->height();
 270                 } else {
 271                         anchor_row_ = boost::next(rit);
 272                         anchor_row_offset_ -= rit->height();
 273                 }
 274         }
 275
 276         // the text becomes smaller
 277         height -= rit->height();
 278
 279         rowlist_.erase(rit);
 280 }
 281
 282
 283 // remove all following rows of the paragraph of the specified row.
 284 void LyXText::removeParagraph(RowList::iterator rit)
 285 {
 286         ParagraphList::iterator tmppit = rit->par();
 287         ++rit;
 288
 289         while (rit != rows().end() && rit->par() == tmppit) {
 290                 RowList::iterator tmprit = boost::next(rit);
 291                 removeRow(rit);
 292                 rit = tmprit;
 293         }
 294 }
 295
 296
 297 void LyXText::insertParagraph(ParagraphList::iterator pit,
 298                               RowList::iterator rowit)
 299 {
 300         // insert a new row, starting at position 0
 301         Row newrow(pit, 0);
 302         RowList::iterator rit = rowlist_.insert(rowit, newrow);
 303
 304         // and now append the whole paragraph before the new row
 305         appendParagraph(rit);
 306 }
 307
 308
 309 Inset * LyXText::getInset() const
 310 {
 311         ParagraphList::iterator pit = cursor.par();
 312         pos_type const pos = cursor.pos();
 313
 314         if (pos < pit->size() && pit->isInset(pos)) {
 315                 return pit->getInset(pos);
 316         }
 317         return 0;
 318 }
 319
 320
 321 void LyXText::toggleInset()
 322 {
 323         Inset * inset = getInset();
 324         // is there an editable inset at cursor position?
 325         if (!isEditableInset(inset)) {
 326                 // No, try to see if we are inside a collapsable inset
 327                 if (inset_owner && inset_owner->owner()
 328                     && inset_owner->owner()->isOpen()) {
 329                         bv()->unlockInset(static_cast<UpdatableInset *>(inset_owner->owner()));
 330                         inset_owner->owner()->close(bv());
 331                         bv()->getLyXText()->cursorRight(bv());
 332                 }
 333                 return;
 334         }
 335         //bv()->owner()->message(inset->editMessage());
 336
 337         // do we want to keep this?? (JMarc)
 338         if (!isHighlyEditableInset(inset))
 339                 setCursorParUndo(bv());
 340
 341         if (inset->isOpen()) {
 342                 inset->close(bv());
 343         } else {
 344                 inset->open(bv());
 345         }
 346
 347         bv()->updateInset(inset);
 348 }
 349
 350
 351 /* used in setlayout */
 352 // Asger is not sure we want to do this...
 353 void LyXText::makeFontEntriesLayoutSpecific(Buffer const & buf,
 354                                             Paragraph & par)
 355 {
 356         LyXLayout_ptr const & layout = par.layout();
 357         pos_type const psize = par.size();
 358
 359         LyXFont layoutfont;
 360         for (pos_type pos = 0; pos < psize; ++pos) {
 361                 if (pos < par.beginningOfBody())
 362                         layoutfont = layout->labelfont;
 363                 else
 364                         layoutfont = layout->font;
 365
 366                 LyXFont tmpfont = par.getFontSettings(buf.params, pos);
 367                 tmpfont.reduce(layoutfont);
 368                 par.setFont(pos, tmpfont);
 369         }
 370 }
 371
 372
 373 ParagraphList::iterator
 374 LyXText::setLayout(LyXCursor & cur, LyXCursor & sstart_cur,
 375                    LyXCursor & send_cur,
 376                    string const & layout)
 377 {
 378         ParagraphList::iterator endpit = boost::next(send_cur.par());
 379         ParagraphList::iterator undoendpit = endpit;
 380         ParagraphList::iterator pars_end = ownerParagraphs().end();
 381
 382         if (endpit != pars_end && endpit->getDepth()) {
 383                 while (endpit != pars_end && endpit->getDepth()) {
 384                         ++endpit;
 385                         undoendpit = endpit;
 386                 }
 387         } else if (endpit != pars_end) {
 388                 // because of parindents etc.
 389                 ++endpit;
 390         }
 391
 392         setUndo(bv(), Undo::EDIT, sstart_cur.par(), undoendpit);
 393
 394         // ok we have a selection. This is always between sstart_cur
 395         // and sel_end cursor
 396         cur = sstart_cur;
 397         ParagraphList::iterator pit = sstart_cur.par();
 398         ParagraphList::iterator epit = boost::next(send_cur.par());
 399
 400         LyXLayout_ptr const & lyxlayout =
 401                 bv()->buffer()->params.getLyXTextClass()[layout];
 402
 403         do {
 404                 pit->applyLayout(lyxlayout);
 405                 makeFontEntriesLayoutSpecific(*bv()->buffer(), *pit);
 406                 ParagraphList::iterator fppit = pit;
 407                 fppit->params().spaceTop(lyxlayout->fill_top ?
 408                                          VSpace(VSpace::VFILL)
 409                                          : VSpace(VSpace::NONE));
 410                 fppit->params().spaceBottom(lyxlayout->fill_bottom ?
 411                                             VSpace(VSpace::VFILL)
 412                                             : VSpace(VSpace::NONE));
 413                 if (lyxlayout->margintype == MARGIN_MANUAL)
 414                         pit->setLabelWidthString(lyxlayout->labelstring());
 415                 cur.par(pit);
 416                 ++pit;
 417         } while (pit != epit);
 418
 419         return endpit;
 420 }
 421
 422
 423 // set layout over selection and make a total rebreak of those paragraphs
 424 void LyXText::setLayout(string const & layout)
 425 {
 426         LyXCursor tmpcursor = cursor;  /* store the current cursor  */
 427
 428         // if there is no selection just set the layout
 429         // of the current paragraph  */
 430         if (!selection.set()) {
 431                 selection.start = cursor;  // dummy selection
 432                 selection.end = cursor;
 433         }
 434         ParagraphList::iterator endpit = setLayout(cursor, selection.start,
 435                                                    selection.end, layout);
 436         redoParagraphs(selection.start, endpit);
 437
 438         // we have to reset the selection, because the
 439         // geometry could have changed
 440         setCursor(selection.start.par(),
 441                   selection.start.pos(), false);
 442         selection.cursor = cursor;
 443         setCursor(selection.end.par(), selection.end.pos(), false);
 444         updateCounters();
 445         clearSelection();
 446         setSelection();
 447         setCursor(tmpcursor.par(), tmpcursor.pos(), true);
 448 }
 449
 450
 451 bool LyXText::changeDepth(bv_funcs::DEPTH_CHANGE type, bool test_only)
 452 {
 453         ParagraphList::iterator pit(cursor.par());
 454         ParagraphList::iterator end(cursor.par());
 455         ParagraphList::iterator start = pit;
 456
 457         if (selection.set()) {
 458                 pit = selection.start.par();
 459                 end = selection.end.par();
 460                 start = pit;
 461         }
 462
 463         ParagraphList::iterator pastend = boost::next(end);
 464
 465         if (!test_only)
 466                 setUndo(bv(), Undo::EDIT, start, pastend);
 467
 468         bool changed = false;
 469
 470         int prev_after_depth = 0;
 471 #warning parlist ... could be nicer ?
 472         if (start != ownerParagraphs().begin()) {
 473                 prev_after_depth = boost::prior(start)->getMaxDepthAfter();
 474         }
 475
 476         while (true) {
 477                 int const depth = pit->params().depth();
 478                 if (type == bv_funcs::INC_DEPTH) {
 479                         if (depth < prev_after_depth
 480                             && pit->layout()->labeltype != LABEL_BIBLIO) {
 481                                 changed = true;
 482                                 if (!test_only) {
 483                                         pit->params().depth(depth + 1);
 484                                 }
 485
 486                         }
 487                 } else if (depth) {
 488                         changed = true;
 489                         if (!test_only)
 490                                 pit->params().depth(depth - 1);
 491                 }
 492
 493                 prev_after_depth = pit->getMaxDepthAfter();
 494
 495                 if (pit == end) {
 496                         break;
 497                 }
 498
 499                 ++pit;
 500         }
 501
 502         if (test_only)
 503                 return changed;
 504
 505         // Wow, redoParagraphs is stupid.
 506         LyXCursor tmpcursor;
 507         setCursor(tmpcursor, &(*start), 0);
 508
 509         //redoParagraphs(tmpcursor, &(*pastend));
 510         redoParagraphs(tmpcursor, &(*pastend));
 511
 512         // We need to actually move the text->cursor. I don't
 513         // understand why ...
 514         tmpcursor = cursor;
 515
 516         // we have to reset the visual selection because the
 517         // geometry could have changed
 518         if (selection.set()) {
 519                 setCursor(selection.start.par(), selection.start.pos());
 520                 selection.cursor = cursor;
 521                 setCursor(selection.end.par(), selection.end.pos());
 522         }
 523
 524         // this handles the counter labels, and also fixes up
 525         // depth values for follow-on (child) paragraphs
 526         updateCounters();
 527
 528         setSelection();
 529         setCursor(tmpcursor.par(), tmpcursor.pos());
 530
 531         return changed;
 532 }
 533
 534
 535 // set font over selection and make a total rebreak of those paragraphs
 536 void LyXText::setFont(LyXFont const & font, bool toggleall)
 537 {
 538         // if there is no selection just set the current_font
 539         if (!selection.set()) {
 540                 // Determine basis font
 541                 LyXFont layoutfont;
 542                 if (cursor.pos() < cursor.par()->beginningOfBody()) {
 543                         layoutfont = getLabelFont(bv()->buffer(),
 544                                                   cursor.par());
 545                 } else {
 546                         layoutfont = getLayoutFont(bv()->buffer(),
 547                                                    cursor.par());
 548                 }
 549                 // Update current font
 550                 real_current_font.update(font,
 551                                          bv()->buffer()->params.language,
 552                                          toggleall);
 553
 554                 // Reduce to implicit settings
 555                 current_font = real_current_font;
 556                 current_font.reduce(layoutfont);
 557                 // And resolve it completely
 558                 real_current_font.realize(layoutfont);
 559
 560                 return;
 561         }
 562
 563         LyXCursor tmpcursor = cursor; // store the current cursor
 564
 565         // ok we have a selection. This is always between sel_start_cursor
 566         // and sel_end cursor
 567
 568         setUndo(bv(), Undo::EDIT,
 569                 selection.start.par(), boost::next(selection.end.par()));
 570         freezeUndo();
 571         cursor = selection.start;
 572         while (cursor.par() != selection.end.par() ||
 573                cursor.pos() < selection.end.pos())
 574         {
 575                 if (cursor.pos() < cursor.par()->size()) {
 576                         // an open footnote should behave like a closed one
 577                         setCharFont(cursor.par(), cursor.pos(),
 578                                     font, toggleall);
 579                         cursor.pos(cursor.pos() + 1);
 580                 } else {
 581                         cursor.pos(0);
 582                         cursor.par(boost::next(cursor.par()));
 583                 }
 584         }
 585         unFreezeUndo();
 586
 587         redoParagraphs(selection.start, boost::next(selection.end.par()));
 588
 589         // we have to reset the selection, because the
 590         // geometry could have changed, but we keep
 591         // it for user convenience
 592         setCursor(selection.start.par(), selection.start.pos());
 593         selection.cursor = cursor;
 594         setCursor(selection.end.par(), selection.end.pos());
 595         setSelection();
 596         setCursor(tmpcursor.par(), tmpcursor.pos(), true,
 597                   tmpcursor.boundary());
 598 }
 599
 600
 601 void LyXText::redoHeightOfParagraph()
 602 {
 603         RowList::iterator tmprow = cursor.row();
 604         int y = cursor.y() - tmprow->baseline();
 605
 606         setHeightOfRow(tmprow);
 607
 608         while (tmprow != rows().begin()
 609                && boost::prior(tmprow)->par() == tmprow->par()) {
 610                 --tmprow;
 611                 y -= tmprow->height();
 612                 setHeightOfRow(tmprow);
 613         }
 614
 615         postPaint(y);
 616
 617         setCursor(cursor.par(), cursor.pos(), false, cursor.boundary());
 618 }
 619
 620
 621 void LyXText::redoDrawingOfParagraph(LyXCursor const & cur)
 622 {
 623         RowList::iterator tmprow = cur.row();
 624
 625         int y = cur.y() - tmprow->baseline();
 626         setHeightOfRow(tmprow);
 627
 628         while (tmprow != rows().begin()
 629                && boost::prior(tmprow)->par() == tmprow->par())  {
 630                 --tmprow;
 631                 y -= tmprow->height();
 632         }
 633
 634         postPaint(y);
 635         setCursor(cur.par(), cur.pos());
 636 }
 637
 638
 639 // deletes and inserts again all paragaphs between the cursor
 640 // and the specified par
 641 // This function is needed after SetLayout and SetFont etc.
 642 void LyXText::redoParagraphs(LyXCursor const & cur,
 643                              ParagraphList::iterator endpit)
 644 {
 645         RowList::iterator tmprit = cur.row();
 646         int y = cur.y() - tmprit->baseline();
 647
 648         ParagraphList::iterator first_phys_pit;
 649         RowList::iterator prevrit;
 650         if (tmprit == rows().begin()) {
 651                 // A trick/hack for UNDO.
 652                 // This is needed because in an UNDO/REDO we could have
 653                 // changed the ownerParagrah() so the paragraph inside
 654                 // the row is NOT my really first par anymore.
 655                 // Got it Lars ;) (Jug 20011206)
 656                 first_phys_pit = ownerParagraphs().begin();
 657                 prevrit = rows().end();
 658         } else {
 659                 first_phys_pit = tmprit->par();
 660                 while (tmprit != rows().begin()
 661                        && boost::prior(tmprit)->par() == first_phys_pit)
 662                 {
 663                         --tmprit;
 664                         y -= tmprit->height();
 665                 }
 666                 prevrit = boost::prior(tmprit);
 667         }
 668
 669         // remove it
 670         while (tmprit != rows().end() && tmprit->par() != endpit) {
 671                 RowList::iterator tmprit2 = tmprit++;
 672                 removeRow(tmprit2);
 673         }
 674
 675         // Reinsert the paragraphs.
 676         ParagraphList::iterator tmppit = first_phys_pit;
 677
 678         while (tmppit != ownerParagraphs().end()) {
 679                 insertParagraph(tmppit, tmprit);
 680                 while (tmprit != rows().end()
 681                        && tmprit->par() == tmppit) {
 682                         ++tmprit;
 683                 }
 684                 ++tmppit;
 685                 if (tmppit == endpit)
 686                         break;
 687         }
 688         if (prevrit != rows().end()) {
 689                 setHeightOfRow(prevrit);
 690                 const_cast<LyXText *>(this)->postPaint(y - prevrit->height());
 691         } else {
 692                 setHeightOfRow(rows().begin());
 693                 const_cast<LyXText *>(this)->postPaint(0);
 694         }
 695         if (tmprit != rows().end())
 696                 setHeightOfRow(tmprit);
 697
 698         updateCounters();
 699 }
 700
 701
 702 void LyXText::fullRebreak()
 703 {
 704         if (rows().empty()) {
 705                 init(bv());
 706                 return;
 707         }
 708
 709         RowList::iterator rows_end = rows().end();
 710
 711         if (need_break_row != rows_end) {
 712                 breakAgain(need_break_row);
 713                 need_break_row = rows_end;
 714                 return;
 715         }
 716 }
 717
 718
 719 // important for the screen
 720
 721
 722 // the cursor set functions have a special mechanism. When they
 723 // realize, that you left an empty paragraph, they will delete it.
 724 // They also delete the corresponding row
 725
 726 // need the selection cursor:
 727 void LyXText::setSelection()
 728 {
 729         bool const lsel = selection.set();
 730
 731         if (!selection.set()) {
 732                 last_sel_cursor = selection.cursor;
 733                 selection.start = selection.cursor;
 734                 selection.end = selection.cursor;
 735         }
 736
 737         selection.set(true);
 738
 739         // first the toggling area
 740         if (cursor.y() < last_sel_cursor.y()
 741             || (cursor.y() == last_sel_cursor.y()
 742                 && cursor.x() < last_sel_cursor.x())) {
 743                 toggle_end_cursor = last_sel_cursor;
 744                 toggle_cursor = cursor;
 745         } else {
 746                 toggle_end_cursor = cursor;
 747                 toggle_cursor = last_sel_cursor;
 748         }
 749
 750         last_sel_cursor = cursor;
 751
 752         // and now the whole selection
 753
 754         if (selection.cursor.par() == cursor.par())
 755                 if (selection.cursor.pos() < cursor.pos()) {
 756                         selection.end = cursor;
 757                         selection.start = selection.cursor;
 758                 } else {
 759                         selection.end = selection.cursor;
 760                         selection.start = cursor;
 761                 }
 762         else if (selection.cursor.y() < cursor.y() ||
 763                  (selection.cursor.y() == cursor.y()
 764                   && selection.cursor.x() < cursor.x())) {
 765                 selection.end = cursor;
 766                 selection.start = selection.cursor;
 767         }
 768         else {
 769                 selection.end = selection.cursor;
 770                 selection.start = cursor;
 771         }
 772
 773         // a selection with no contents is not a selection
 774         if (selection.start.par() == selection.end.par() &&
 775             selection.start.pos() == selection.end.pos())
 776                 selection.set(false);
 777
 778         if (inset_owner && (selection.set() || lsel))
 779                 inset_owner->setUpdateStatus(bv(), InsetText::SELECTION);
 780 }
 781
 782
 783 string const LyXText::selectionAsString(Buffer const * buffer,
 784                                         bool label) const
 785 {
 786         if (!selection.set()) return string();
 787
 788         // should be const ...
 789         ParagraphList::iterator startpit = selection.start.par();
 790         ParagraphList::iterator endpit = selection.end.par();
 791         pos_type const startpos(selection.start.pos());
 792         pos_type const endpos(selection.end.pos());
 793
 794         if (startpit == endpit) {
 795                 return startpit->asString(buffer, startpos, endpos, label);
 796         }
 797
 798         string result;
 799
 800         // First paragraph in selection
 801         result += startpit->asString(buffer, startpos, startpit->size(), label) + "\n\n";
 802
 803         // The paragraphs in between (if any)
 804         ParagraphList::iterator pit = boost::next(startpit);
 805         for (; pit != endpit; ++pit) {
 806                 result += pit->asString(buffer, 0, pit->size(), label) + "\n\n";
 807         }
 808
 809         // Last paragraph in selection
 810         result += endpit->asString(buffer, 0, endpos, label);
 811
 812         return result;
 813 }
 814
 815
 816 void LyXText::clearSelection()
 817 {
 818         selection.set(false);
 819         selection.mark(false);
 820         last_sel_cursor = selection.end = selection.start = selection.cursor = cursor;
 821         // reset this in the bv_owner!
 822         if (bv_owner && bv_owner->text)
 823                 bv_owner->text->xsel_cache.set(false);
 824 }
 825
 826
 827 void LyXText::cursorHome()
 828 {
 829         setCursor(cursor.par(), cursor.row()->pos());
 830 }
 831
 832
 833 void LyXText::cursorEnd()
 834 {
 835         if (cursor.par()->empty())
 836                 return;
 837
 838         RowList::iterator rit = cursor.row();
 839         RowList::iterator next_rit = boost::next(rit);
 840         ParagraphList::iterator pit = rit->par();
 841         pos_type last_pos = lastPos(*this, rit);
 842
 843         if (next_rit == rows().end() || next_rit->par() != pit) {
 844                 ++last_pos;
 845         } else {
 846                 if (pit->empty() ||
 847                     (pit->getChar(last_pos) != ' ' && !pit->isNewline(last_pos))) {
 848                         ++last_pos;
 849                 }
 850         }
 851
 852         setCursor(pit, last_pos);
 853 }
 854
 855
 856 void LyXText::cursorTop()
 857 {
 858         setCursor(ownerParagraphs().begin(), 0);
 859 }
 860
 861
 862 void LyXText::cursorBottom()
 863 {
 864 #warning FIXME
 865         // This is how it should be:
 866         // ParagraphList::iterator lastpit = boost::prior(ownerParagraphs().end());
 867         ParagraphList::iterator lastpit = &ownerParagraphs().back();
 868         int pos = lastpit->size();
 869         setCursor(lastpit, pos);
 870 }
 871
 872
 873 void LyXText::toggleFree(LyXFont const & font, bool toggleall)
 874 {
 875         // If the mask is completely neutral, tell user
 876         if (font == LyXFont(LyXFont::ALL_IGNORE)) {
 877                 // Could only happen with user style
 878                 bv()->owner()->message(_("No font change defined. Use Character under the Layout menu to define font change."));
 879                 return;
 880         }
 881
 882         // Try implicit word selection
 883         // If there is a change in the language the implicit word selection
 884         // is disabled.
 885         LyXCursor resetCursor = cursor;
 886         bool implicitSelection = (font.language() == ignore_language
 887                                   && font.number() == LyXFont::IGNORE)
 888                 ? selectWordWhenUnderCursor(WHOLE_WORD_STRICT) : false;
 889
 890         // Set font
 891         setFont(font, toggleall);
 892
 893         // Implicit selections are cleared afterwards
 894         //and cursor is set to the original position.
 895         if (implicitSelection) {
 896                 clearSelection();
 897                 cursor = resetCursor;
 898                 setCursor(cursor.par(), cursor.pos());
 899                 selection.cursor = cursor;
 900         }
 901         if (inset_owner)
 902                 inset_owner->setUpdateStatus(bv(), InsetText::CURSOR_PAR);
 903 }
 904
 905
 906 string LyXText::getStringToIndex()
 907 {
 908         // Try implicit word selection
 909         // If there is a change in the language the implicit word selection
 910         // is disabled.
 911         LyXCursor const reset_cursor = cursor;
 912         bool const implicitSelection = selectWordWhenUnderCursor(PREVIOUS_WORD);
 913
 914         string idxstring;
 915         if (!selection.set())
 916                 bv()->owner()->message(_("Nothing to index!"));
 917         else if (selection.start.par() != selection.end.par())
 918                 bv()->owner()->message(_("Cannot index more than one paragraph!"));
 919         else
 920                 idxstring = selectionAsString(bv()->buffer(), false);
 921
 922         // Reset cursors to their original position.
 923         cursor = reset_cursor;
 924         setCursor(cursor.par(), cursor.pos());
 925         selection.cursor = cursor;
 926
 927         // Clear the implicit selection.
 928         if (implicitSelection)
 929                 clearSelection();
 930
 931         return idxstring;
 932 }
 933
 934
 935 // the DTP switches for paragraphs. LyX will store them in the first
 936 // physicla paragraph. When a paragraph is broken, the top settings rest,
 937 // the bottom settings are given to the new one. So I can make shure,
 938 // they do not duplicate themself and you cannnot make dirty things with
 939 // them!
 940
 941 void LyXText::setParagraph(bool line_top, bool line_bottom,
 942                            bool pagebreak_top, bool pagebreak_bottom,
 943                            VSpace const & space_top,
 944                            VSpace const & space_bottom,
 945                            Spacing const & spacing,
 946                            LyXAlignment align,
 947                            string const & labelwidthstring,
 948                            bool noindent)
 949 {
 950         LyXCursor tmpcursor = cursor;
 951         if (!selection.set()) {
 952                 selection.start = cursor;
 953                 selection.end = cursor;
 954         }
 955
 956         // make sure that the depth behind the selection are restored, too
 957         ParagraphList::iterator endpit = boost::next(selection.end.par());
 958         ParagraphList::iterator undoendpit = endpit;
 959         ParagraphList::iterator pars_end = ownerParagraphs().end();
 960
 961         if (endpit != pars_end && endpit->getDepth()) {
 962                 while (endpit != pars_end && endpit->getDepth()) {
 963                         ++endpit;
 964                         undoendpit = endpit;
 965                 }
 966         } else if (endpit != pars_end) {
 967                 // because of parindents etc.
 968                 ++endpit;
 969         }
 970
 971         setUndo(bv(), Undo::EDIT, selection.start.par(), undoendpit);
 972
 973
 974         ParagraphList::iterator tmppit = selection.end.par();
 975
 976         while (tmppit != boost::prior(selection.start.par())) {
 977                 setCursor(tmppit, 0);
 978                 postPaint(cursor.y() - cursor.row()->baseline());
 979
 980                 ParagraphList::iterator pit = cursor.par();
 981                 ParagraphParameters & params = pit->params();
 982
 983                 params.lineTop(line_top);
 984                 params.lineBottom(line_bottom);
 985                 params.pagebreakTop(pagebreak_top);
 986                 params.pagebreakBottom(pagebreak_bottom);
 987                 params.spaceTop(space_top);
 988                 params.spaceBottom(space_bottom);
 989                 params.spacing(spacing);
 990                 // does the layout allow the new alignment?
 991                 LyXLayout_ptr const & layout = pit->layout();
 992
 993                 if (align == LYX_ALIGN_LAYOUT)
 994                         align = layout->align;
 995                 if (align & layout->alignpossible) {
 996                         if (align == layout->align)
 997                                 params.align(LYX_ALIGN_LAYOUT);
 998                         else
 999                                 params.align(align);
1000                 }
1001                 pit->setLabelWidthString(labelwidthstring);
1002                 params.noindent(noindent);
1003                 tmppit = boost::prior(pit);
1004         }
1005
1006         redoParagraphs(selection.start, endpit);
1007
1008         clearSelection();
1009         setCursor(selection.start.par(), selection.start.pos());
1010         selection.cursor = cursor;
1011         setCursor(selection.end.par(), selection.end.pos());
1012         setSelection();
1013         setCursor(tmpcursor.par(), tmpcursor.pos());
1014         if (inset_owner)
1015                 bv()->updateInset(inset_owner);
1016 }
1017
1018
1019 // set the counter of a paragraph. This includes the labels
1020 void LyXText::setCounter(Buffer const * buf, ParagraphList::iterator pit)
1021 {
1022         LyXTextClass const & textclass = buf->params.getLyXTextClass();
1023         LyXLayout_ptr const & layout = pit->layout();
1024
1025         if (pit != ownerParagraphs().begin()) {
1026
1027                 pit->params().appendix(boost::prior(pit)->params().appendix());
1028                 if (!pit->params().appendix() &&
1029                     pit->params().startOfAppendix()) {
1030                         pit->params().appendix(true);
1031                         textclass.counters().reset();
1032                 }
1033                 pit->enumdepth = boost::prior(pit)->enumdepth;
1034                 pit->itemdepth = boost::prior(pit)->itemdepth;
1035         } else {
1036                 pit->params().appendix(pit->params().startOfAppendix());
1037                 pit->enumdepth = 0;
1038                 pit->itemdepth = 0;
1039         }
1040
1041         /* Maybe we have to increment the enumeration depth.
1042          * BUT, enumeration in a footnote is considered in isolation from its
1043          *      surrounding paragraph so don't increment if this is the
1044          *      first line of the footnote
1045          * AND, bibliographies can't have their depth changed ie. they
1046          *      are always of depth 0
1047          */
1048         if (pit != ownerParagraphs().begin()
1049             && boost::prior(pit)->getDepth() < pit->getDepth()
1050             && boost::prior(pit)->layout()->labeltype == LABEL_COUNTER_ENUMI
1051             && pit->enumdepth < 3
1052             && layout->labeltype != LABEL_BIBLIO) {
1053                 pit->enumdepth++;
1054         }
1055
1056         // Maybe we have to decrement the enumeration depth, see note above
1057         if (pit != ownerParagraphs().begin()
1058             && boost::prior(pit)->getDepth() > pit->getDepth()
1059             && layout->labeltype != LABEL_BIBLIO) {
1060                 pit->enumdepth = depthHook(pit, ownerParagraphs(),
1061                                            pit->getDepth())->enumdepth;
1062         }
1063
1064         if (!pit->params().labelString().empty()) {
1065                 pit->params().labelString(string());
1066         }
1067
1068         if (layout->margintype == MARGIN_MANUAL) {
1069                 if (pit->params().labelWidthString().empty()) {
1070                         pit->setLabelWidthString(layout->labelstring());
1071                 }
1072         } else {
1073                 pit->setLabelWidthString(string());
1074         }
1075
1076         // is it a layout that has an automatic label?
1077         if (layout->labeltype >= LABEL_COUNTER_CHAPTER) {
1078                 int const i = layout->labeltype - LABEL_COUNTER_CHAPTER;
1079
1080                 ostringstream s;
1081
1082                 if (i >= 0 && i <= buf->params.secnumdepth) {
1083                         string numbertype;
1084                         string langtype;
1085
1086                         textclass.counters().step(layout->latexname());
1087
1088                         // Is there a label? Useful for Chapter layout
1089                         if (!pit->params().appendix()) {
1090                                 s << buf->B_(layout->labelstring());
1091                         } else {
1092                                 s << buf->B_(layout->labelstring_appendix());
1093                         }
1094
1095                         // Use of an integer is here less than elegant. For now.
1096                         int head = textclass.maxcounter() - LABEL_COUNTER_CHAPTER;
1097                         if (!pit->params().appendix()) {
1098                                 numbertype = "sectioning";
1099                         } else {
1100                                 numbertype = "appendix";
1101                                 if (pit->isRightToLeftPar(buf->params))
1102                                         langtype = "hebrew";
1103                                 else
1104                                         langtype = "latin";
1105                         }
1106
1107                         s << " "
1108                           << textclass.counters()
1109                                 .numberLabel(layout->latexname(),
1110                                              numbertype, langtype, head);
1111
1112                         pit->params().labelString(STRCONV(s.str()));
1113
1114                         // reset enum counters
1115                         textclass.counters().reset("enum");
1116                 } else if (layout->labeltype < LABEL_COUNTER_ENUMI) {
1117                         textclass.counters().reset("enum");
1118                 } else if (layout->labeltype == LABEL_COUNTER_ENUMI) {
1119                         // FIXME
1120                         // Yes I know this is a really, really! bad solution
1121                         // (Lgb)
1122                         string enumcounter("enum");
1123
1124                         switch (pit->enumdepth) {
1125                         case 2:
1126                                 enumcounter += 'i';
1127                         case 1:
1128                                 enumcounter += 'i';
1129                         case 0:
1130                                 enumcounter += 'i';
1131                                 break;
1132                         case 3:
1133                                 enumcounter += "iv";
1134                                 break;
1135                         default:
1136                                 // not a valid enumdepth...
1137                                 break;
1138                         }
1139
1140                         textclass.counters().step(enumcounter);
1141
1142                         s << textclass.counters()
1143                                 .numberLabel(enumcounter, "enumeration");
1144                         pit->params().labelString(STRCONV(s.str()));
1145                 }
1146         } else if (layout->labeltype == LABEL_BIBLIO) {// ale970302
1147                 textclass.counters().step("bibitem");
1148                 int number = textclass.counters().value("bibitem");
1149                 if (pit->bibitem()) {
1150                         pit->bibitem()->setCounter(number);
1151                         pit->params().labelString(layout->labelstring());
1152                 }
1153                 // In biblio should't be following counters but...
1154         } else {
1155                 string s = buf->B_(layout->labelstring());
1156
1157                 // the caption hack:
1158                 if (layout->labeltype == LABEL_SENSITIVE) {
1159                         ParagraphList::iterator tmppit = pit;
1160                         Inset * in = 0;
1161                         bool isOK = false;
1162                         while (tmppit != ownerParagraphs().end() &&
1163                                tmppit->inInset()
1164                                // the single '=' is intended below
1165                                && (in = tmppit->inInset()->owner())) {
1166                                 if (in->lyxCode() == Inset::FLOAT_CODE ||
1167                                     in->lyxCode() == Inset::WRAP_CODE) {
1168                                         isOK = true;
1169                                         break;
1170                                 } else {
1171                                         tmppit = in->parOwner();
1172                                 }
1173                         }
1174
1175                         if (isOK) {
1176                                 Floating const & fl
1177                                         = textclass.floats().getType(static_cast<InsetFloat*>(in)->type());
1178
1179                                 textclass.counters().step(fl.type());
1180
1181                                 // Doesn't work... yet.
1182 #if USE_BOOST_FORMAT
1183                                 s = boost::io::str(boost::format(_("%1$s #:")) % buf->B_(fl.name()));
1184                                 // s << boost::format(_("%1$s %1$d:")
1185                                 //        % fl.name()
1186                                 //        % buf->counters().value(fl.name());
1187 #else
1188                                 ostringstream o;
1189                                 //o << fl.name() << ' ' << buf->counters().value(fl.name()) << ":";
1190                                 o << buf->B_(fl.name()) << " #:";
1191                                 s = STRCONV(o.str());
1192 #endif
1193                         } else {
1194                                 // par->SetLayout(0);
1195                                 // s = layout->labelstring;
1196                                 s = _("Senseless: ");
1197                         }
1198                 }
1199                 pit->params().labelString(s);
1200
1201                 // reset the enumeration counter. They are always reset
1202                 // when there is any other layout between
1203                 // Just fall-through between the cases so that all
1204                 // enum counters deeper than enumdepth is also reset.
1205                 switch (pit->enumdepth) {
1206                 case 0:
1207                         textclass.counters().reset("enumi");
1208                 case 1:
1209                         textclass.counters().reset("enumii");
1210                 case 2:
1211                         textclass.counters().reset("enumiii");
1212                 case 3:
1213                         textclass.counters().reset("enumiv");
1214                 }
1215         }
1216 }
1217
1218
1219 // Updates all counters. Paragraphs with changed label string will be rebroken
1220 void LyXText::updateCounters()
1221 {
1222         RowList::iterator rowit = rows().begin();
1223         ParagraphList::iterator pit = rowit->par();
1224
1225         // CHECK if this is really needed. (Lgb)
1226         bv()->buffer()->params.getLyXTextClass().counters().reset();
1227
1228         for (; pit != ownerParagraphs().end(); ++pit) {
1229                 while (rowit->par() != pit)
1230                         ++rowit;
1231
1232                 string const oldLabel = pit->params().labelString();
1233
1234                 int maxdepth = 0;
1235                 if (pit != ownerParagraphs().begin())
1236                         maxdepth = boost::prior(pit)->getMaxDepthAfter();
1237
1238                 if (pit->params().depth() > maxdepth)
1239                         pit->params().depth(maxdepth);
1240
1241                 // setCounter can potentially change the labelString.
1242                 setCounter(bv()->buffer(), pit);
1243
1244                 string const & newLabel = pit->params().labelString();
1245
1246                 if (oldLabel.empty() && !newLabel.empty()) {
1247                         removeParagraph(rowit);
1248                         appendParagraph(rowit);
1249                 }
1250         }
1251 }
1252
1253
1254 void LyXText::insertInset(Inset * inset)
1255 {
1256         if (!cursor.par()->insetAllowed(inset->lyxCode()))
1257                 return;
1258         setUndo(bv(), Undo::FINISH, cursor.par(),
1259                 boost::next(cursor.par()));
1260         freezeUndo();
1261         cursor.par()->insertInset(cursor.pos(), inset);
1262         // Just to rebreak and refresh correctly.
1263         // The character will not be inserted a second time
1264         insertChar(Paragraph::META_INSET);
1265         // If we enter a highly editable inset the cursor should be to before
1266         // the inset. This couldn't happen before as Undo was not handled inside
1267         // inset now after the Undo LyX tries to call inset->Edit(...) again
1268         // and cannot do this as the cursor is behind the inset and GetInset
1269         // does not return the inset!
1270         if (isHighlyEditableInset(inset)) {
1271                 cursorLeft(true);
1272         }
1273         unFreezeUndo();
1274 }
1275
1276
1277 void LyXText::cutSelection(bool doclear, bool realcut)
1278 {
1279         // Stuff what we got on the clipboard. Even if there is no selection.
1280
1281         // There is a problem with having the stuffing here in that the
1282         // larger the selection the slower LyX will get. This can be
1283         // solved by running the line below only when the selection has
1284         // finished. The solution used currently just works, to make it
1285         // faster we need to be more clever and probably also have more
1286         // calls to stuffClipboard. (Lgb)
1287         bv()->stuffClipboard(selectionAsString(bv()->buffer(), true));
1288
1289         // This doesn't make sense, if there is no selection
1290         if (!selection.set())
1291                 return;
1292
1293         // OK, we have a selection. This is always between selection.start
1294         // and selection.end
1295
1296         // make sure that the depth behind the selection are restored, too
1297         ParagraphList::iterator endpit = boost::next(selection.end.par());
1298         ParagraphList::iterator undoendpit = endpit;
1299         ParagraphList::iterator pars_end = ownerParagraphs().end();
1300
1301         if (endpit != pars_end && endpit->getDepth()) {
1302                 while (endpit != pars_end && endpit->getDepth()) {
1303                         ++endpit;
1304                         undoendpit = endpit;
1305                 }
1306         } else if (endpit != pars_end) {
1307                 // because of parindents etc.
1308                 ++endpit;
1309         }
1310
1311         setUndo(bv(), Undo::DELETE, selection.start.par(), undoendpit);
1312
1313
1314         endpit = selection.end.par();
1315         int endpos = selection.end.pos();
1316
1317         boost::tie(endpit, endpos) = realcut ?
1318                 CutAndPaste::cutSelection(ownerParagraphs(),
1319                                           selection.start.par(), endpit,
1320                                           selection.start.pos(), endpos,
1321                                           bv()->buffer()->params.textclass,
1322                                           doclear)
1323                 : CutAndPaste::eraseSelection(ownerParagraphs(),
1324                                               selection.start.par(), endpit,
1325                                               selection.start.pos(), endpos,
1326                                               doclear);
1327         // sometimes necessary
1328         if (doclear)
1329                 selection.start.par()->stripLeadingSpaces();
1330
1331         redoParagraphs(selection.start, boost::next(endpit));
1332 #warning FIXME latent bug
1333         // endpit will be invalidated on redoParagraphs once ParagraphList
1334         // becomes a std::list? There are maybe other places on which this
1335         // can happend? (Ab)
1336         // cutSelection can invalidate the cursor so we need to set
1337         // it anew. (Lgb)
1338         // we prefer the end for when tracking changes
1339         cursor.pos(endpos);
1340         cursor.par(endpit);
1341
1342         // need a valid cursor. (Lgb)
1343         clearSelection();
1344
1345         setCursor(cursor.par(), cursor.pos());
1346         selection.cursor = cursor;
1347         updateCounters();
1348 }
1349
1350
1351 void LyXText::copySelection()
1352 {
1353         // stuff the selection onto the X clipboard, from an explicit copy request
1354         bv()->stuffClipboard(selectionAsString(bv()->buffer(), true));
1355
1356         // this doesnt make sense, if there is no selection
1357         if (!selection.set())
1358                 return;
1359
1360         // ok we have a selection. This is always between selection.start
1361         // and sel_end cursor
1362
1363         // copy behind a space if there is one
1364         while (selection.start.par()->size() > selection.start.pos()
1365                && selection.start.par()->isLineSeparator(selection.start.pos())
1366                && (selection.start.par() != selection.end.par()
1367                    || selection.start.pos() < selection.end.pos()))
1368                 selection.start.pos(selection.start.pos() + 1);
1369
1370         CutAndPaste::copySelection(selection.start.par(),
1371                                    selection.end.par(),
1372                                    selection.start.pos(), selection.end.pos(),
1373                                    bv()->buffer()->params.textclass);
1374 }
1375
1376
1377 void LyXText::pasteSelection()
1378 {
1379         // this does not make sense, if there is nothing to paste
1380         if (!CutAndPaste::checkPastePossible())
1381                 return;
1382
1383         setUndo(bv(), Undo::INSERT,
1384                 cursor.par(), boost::next(cursor.par()));
1385
1386         ParagraphList::iterator endpit;
1387         PitPosPair ppp;
1388
1389         boost::tie(ppp, endpit) =
1390                 CutAndPaste::pasteSelection(ownerParagraphs(),
1391                                             cursor.par(), cursor.pos(),
1392                                             bv()->buffer()->params.textclass);
1393
1394         redoParagraphs(cursor, endpit);
1395
1396         setCursor(cursor.par(), cursor.pos());
1397         clearSelection();
1398
1399         selection.cursor = cursor;
1400         setCursor(ppp.first, ppp.second);
1401         setSelection();
1402         updateCounters();
1403 }
1404
1405
1406 void LyXText::setSelectionRange(lyx::pos_type length)
1407 {
1408         if (!length)
1409                 return;
1410
1411         selection.cursor = cursor;
1412         while (length--)
1413                 cursorRight(bv());
1414         setSelection();
1415 }
1416
1417
1418 // simple replacing. The font of the first selected character is used
1419 void LyXText::replaceSelectionWithString(string const & str)
1420 {
1421         setCursorParUndo(bv());
1422         freezeUndo();
1423
1424         if (!selection.set()) { // create a dummy selection
1425                 selection.end = cursor;
1426                 selection.start = cursor;
1427         }
1428
1429         // Get font setting before we cut
1430         pos_type pos = selection.end.pos();
1431         LyXFont const font = selection.start.par()
1432                 ->getFontSettings(bv()->buffer()->params,
1433                                   selection.start.pos());
1434
1435         // Insert the new string
1436         for (string::const_iterator cit = str.begin(); cit != str.end(); ++cit) {
1437                 selection.end.par()->insertChar(pos, (*cit), font);
1438                 ++pos;
1439         }
1440
1441         // Cut the selection
1442         cutSelection(true, false);
1443
1444         unFreezeUndo();
1445 }
1446
1447
1448 // needed to insert the selection
1449 void LyXText::insertStringAsLines(string const & str)
1450 {
1451         ParagraphList::iterator pit = cursor.par();
1452         pos_type pos = cursor.pos();
1453         ParagraphList::iterator endpit = boost::next(cursor.par());
1454
1455         setCursorParUndo(bv());
1456
1457         // only to be sure, should not be neccessary
1458         clearSelection();
1459
1460         bv()->buffer()->insertStringAsLines(pit, pos, current_font, str);
1461
1462         redoParagraphs(cursor, endpit);
1463         setCursor(cursor.par(), cursor.pos());
1464         selection.cursor = cursor;
1465         setCursor(pit, pos);
1466         setSelection();
1467 }
1468
1469
1470 // turns double-CR to single CR, others where converted into one
1471 // blank. Then InsertStringAsLines is called
1472 void LyXText::insertStringAsParagraphs(string const & str)
1473 {
1474         string linestr(str);
1475         bool newline_inserted = false;
1476         for (string::size_type i = 0; i < linestr.length(); ++i) {
1477                 if (linestr[i] == '\n') {
1478                         if (newline_inserted) {
1479                                 // we know that \r will be ignored by
1480                                 // InsertStringA. Of course, it is a dirty
1481                                 // trick, but it works...
1482                                 linestr[i - 1] = '\r';
1483                                 linestr[i] = '\n';
1484                         } else {
1485                                 linestr[i] = ' ';
1486                                 newline_inserted = true;
1487                         }
1488                 } else if (IsPrintable(linestr[i])) {
1489                         newline_inserted = false;
1490                 }
1491         }
1492         insertStringAsLines(linestr);
1493 }
1494
1495
1496 void LyXText::checkParagraph(ParagraphList::iterator pit, pos_type pos)
1497 {
1498         LyXCursor tmpcursor;
1499
1500         int y = 0;
1501         pos_type z;
1502         RowList::iterator row = getRow(pit, pos, y);
1503         RowList::iterator beg = rows().begin();
1504
1505         // is there a break one row above
1506         if (row != beg
1507             && boost::prior(row)->par() == row->par()) {
1508                 z = rowBreakPoint(*boost::prior(row));
1509                 if (z >= row->pos()) {
1510                         // set the dimensions of the row above
1511                         y -= boost::prior(row)->height();
1512                         postPaint(y);
1513
1514                         breakAgain(boost::prior(row));
1515
1516                         // set the cursor again. Otherwise
1517                         // dangling pointers are possible
1518                         setCursor(cursor.par(), cursor.pos(),
1519                                   false, cursor.boundary());
1520                         selection.cursor = cursor;
1521                         return;
1522                 }
1523         }
1524
1525         int const tmpheight = row->height();
1526         pos_type const tmplast = lastPos(*this, row);
1527
1528         breakAgain(row);
1529         if (row->height() == tmpheight && lastPos(*this, row) == tmplast) {
1530                 postRowPaint(row, y);
1531         } else {
1532                 postPaint(y);
1533         }
1534
1535         // check the special right address boxes
1536         if (pit->layout()->margintype == MARGIN_RIGHT_ADDRESS_BOX) {
1537                 tmpcursor.par(pit);
1538                 tmpcursor.row(row);
1539                 tmpcursor.y(y);
1540                 tmpcursor.x(0);
1541                 tmpcursor.x_fix(0);
1542                 tmpcursor.pos(pos);
1543                 redoDrawingOfParagraph(tmpcursor);
1544         }
1545
1546         // set the cursor again. Otherwise dangling pointers are possible
1547         // also set the selection
1548
1549         if (selection.set()) {
1550                 tmpcursor = cursor;
1551                 setCursorIntern(selection.cursor.par(), selection.cursor.pos(),
1552                                 false, selection.cursor.boundary());
1553                 selection.cursor = cursor;
1554                 setCursorIntern(selection.start.par(),
1555                                 selection.start.pos(),
1556                                 false, selection.start.boundary());
1557                 selection.start = cursor;
1558                 setCursorIntern(selection.end.par(),
1559                                 selection.end.pos(),
1560                                 false, selection.end.boundary());
1561                 selection.end = cursor;
1562                 setCursorIntern(last_sel_cursor.par(),
1563                                 last_sel_cursor.pos(),
1564                                 false, last_sel_cursor.boundary());
1565                 last_sel_cursor = cursor;
1566                 cursor = tmpcursor;
1567         }
1568         setCursorIntern(cursor.par(), cursor.pos(),
1569                         false, cursor.boundary());
1570 }
1571
1572
1573 // returns false if inset wasn't found
1574 bool LyXText::updateInset(Inset * inset)
1575 {
1576         // first check the current paragraph
1577         int pos = cursor.par()->getPositionOfInset(inset);
1578         if (pos != -1) {
1579                 checkParagraph(cursor.par(), pos);
1580                 return true;
1581         }
1582
1583         // check every paragraph
1584
1585         ParagraphList::iterator par = ownerParagraphs().begin();
1586         ParagraphList::iterator end = ownerParagraphs().end();
1587         for (; par != end; ++par) {
1588                 pos = par->getPositionOfInset(inset);
1589                 if (pos != -1) {
1590                         checkParagraph(par, pos);
1591                         return true;
1592                 }
1593         };
1594
1595         return false;
1596 }
1597
1598
1599 bool LyXText::setCursor(ParagraphList::iterator pit,
1600                         pos_type pos,
1601                         bool setfont, bool boundary)
1602 {
1603         LyXCursor old_cursor = cursor;
1604         setCursorIntern(pit, pos, setfont, boundary);
1605         return deleteEmptyParagraphMechanism(old_cursor);
1606 }
1607
1608
1609 void LyXText::setCursor(LyXCursor & cur, ParagraphList::iterator pit,
1610                         pos_type pos, bool boundary)
1611 {
1612         lyx::Assert(pit != ownerParagraphs().end());
1613
1614         cur.par(pit);
1615         cur.pos(pos);
1616         cur.boundary(boundary);
1617
1618         // get the cursor y position in text
1619         int y = 0;
1620         RowList::iterator row = getRow(pit, pos, y);
1621         RowList::iterator beg = rows().begin();
1622
1623         RowList::iterator old_row = row;
1624         cur.irow(row);
1625         // if we are before the first char of this row and are still in the
1626         // same paragraph and there is a previous row then put the cursor on
1627         // the end of the previous row
1628         cur.iy(y + row->baseline());
1629         if (row != beg &&
1630             pos &&
1631             boost::prior(row)->par() == row->par() &&
1632             pos < pit->size() &&
1633             pit->getChar(pos) == Paragraph::META_INSET) {
1634                 Inset * ins = pit->getInset(pos);
1635                 if (ins && (ins->needFullRow() || ins->display())) {
1636                         --row;
1637                         y -= row->height();
1638                 }
1639         }
1640
1641         cur.row(row);
1642         // y is now the beginning of the cursor row
1643         y += row->baseline();
1644         // y is now the cursor baseline
1645         cur.y(y);
1646
1647         pos_type last = lastPrintablePos(*this, old_row);
1648
1649         // None of these should happen, but we're scaredy-cats
1650         if (pos > pit->size()) {
1651                 lyxerr << "dont like 1 please report" << endl;
1652                 pos = 0;
1653                 cur.pos(0);
1654         } else if (pos > last + 1) {
1655                 lyxerr << "dont like 2 please report" << endl;
1656                 // This shouldn't happen.
1657                 pos = last + 1;
1658                 cur.pos(pos);
1659         } else if (pos < row->pos()) {
1660                 lyxerr << "dont like 3 please report" << endl;
1661                 pos = row->pos();
1662                 cur.pos(pos);
1663         }
1664
1665         // now get the cursors x position
1666         float x = getCursorX(row, pos, last, boundary);
1667         cur.x(int(x));
1668         cur.x_fix(cur.x());
1669         if (old_row != row) {
1670                 x = getCursorX(old_row, pos, last, boundary);
1671                 cur.ix(int(x));
1672         } else
1673                 cur.ix(cur.x());
1674 /* We take out this for the time being because 1) the redraw code is not
1675    prepared to this yet and 2) because some good policy has yet to be decided
1676    while editting: for instance how to act on rows being created/deleted
1677    because of DEPM.
1678 */
1679 #if 0
1680         //if the cursor is in a visible row, anchor to it
1681         int topy = top_y();
1682         if (topy < y && y < topy + bv()->workHeight())
1683                 anchor_row(row);
1684 #endif
1685 }
1686
1687
1688 float LyXText::getCursorX(RowList::iterator rit,
1689                           pos_type pos, pos_type last, bool boundary) const
1690 {
1691         pos_type cursor_vpos = 0;
1692         float x;
1693         float fill_separator;
1694         float fill_hfill;
1695         float fill_label_hfill;
1696         // This call HAS to be here because of the BidiTables!!!
1697         prepareToPrint(rit, x, fill_separator, fill_hfill,
1698                        fill_label_hfill);
1699
1700         ParagraphList::iterator rit_par = rit->par();
1701         pos_type const rit_pos = rit->pos();
1702
1703         if (last < rit_pos)
1704                 cursor_vpos = rit_pos;
1705         else if (pos > last && !boundary)
1706                 cursor_vpos = (rit_par->isRightToLeftPar(bv()->buffer()->params))
1707                         ? rit_pos : last + 1;
1708         else if (pos > rit_pos && (pos > last || boundary))
1709                 /// Place cursor after char at (logical) position pos - 1
1710                 cursor_vpos = (bidi_level(pos - 1) % 2 == 0)
1711                         ? log2vis(pos - 1) + 1 : log2vis(pos - 1);
1712         else
1713                 /// Place cursor before char at (logical) position pos
1714                 cursor_vpos = (bidi_level(pos) % 2 == 0)
1715                         ? log2vis(pos) : log2vis(pos) + 1;
1716
1717         pos_type body_pos = rit_par->beginningOfBody();
1718         if ((body_pos > 0) &&
1719             ((body_pos - 1 > last) || !rit_par->isLineSeparator(body_pos - 1)))
1720                 body_pos = 0;
1721
1722         for (pos_type vpos = rit_pos; vpos < cursor_vpos; ++vpos) {
1723                 pos_type pos = vis2log(vpos);
1724                 if (body_pos > 0 && pos == body_pos - 1) {
1725                         x += fill_label_hfill +
1726                                 font_metrics::width(
1727                                         rit_par->layout()->labelsep,
1728                                         getLabelFont(bv()->buffer(), rit_par));
1729                         if (rit_par->isLineSeparator(body_pos - 1))
1730                                 x -= singleWidth(rit_par, body_pos - 1);
1731                 }
1732
1733                 if (hfillExpansion(*this, rit, pos)) {
1734                         x += singleWidth(rit_par, pos);
1735                         if (pos >= body_pos)
1736                                 x += fill_hfill;
1737                         else
1738                                 x += fill_label_hfill;
1739                 } else if (rit_par->isSeparator(pos)) {
1740                         x += singleWidth(rit_par, pos);
1741                         if (pos >= body_pos)
1742                                 x += fill_separator;
1743                 } else
1744                         x += singleWidth(rit_par, pos);
1745         }
1746         return x;
1747 }
1748
1749
1750 void LyXText::setCursorIntern(ParagraphList::iterator pit,
1751                               pos_type pos, bool setfont, bool boundary)
1752 {
1753         InsetText * it = static_cast<InsetText *>(pit->inInset());
1754         if (it) {
1755                 if (it != inset_owner) {
1756                         lyxerr[Debug::INSETS] << "InsetText   is " << it
1757                                               << endl
1758                                               << "inset_owner is "
1759                                               << inset_owner << endl;
1760 #ifdef WITH_WARNINGS
1761 #warning I believe this code is wrong. (Lgb)
1762 #warning Jürgen, have a look at this. (Lgb)
1763 #warning Hmmm, I guess you are right but we
1764 #warning should verify when this is needed
1765 #endif
1766                         // Jürgen, would you like to have a look?
1767                         // I guess we need to move the outer cursor
1768                         // and open and lock the inset (bla bla bla)
1769                         // stuff I don't know... so can you have a look?
1770                         // (Lgb)
1771                         // I moved the lyxerr stuff in here so we can see if
1772                         // this is actually really needed and where!
1773                         // (Jug)
1774                         // it->getLyXText(bv())->setCursorIntern(bv(), par, pos, setfont, boundary);
1775                         return;
1776                 }
1777         }
1778
1779         setCursor(cursor, pit, pos, boundary);
1780         if (setfont)
1781                 setCurrentFont();
1782 }
1783
1784
1785 void LyXText::setCurrentFont()
1786 {
1787         pos_type pos = cursor.pos();
1788         ParagraphList::iterator pit = cursor.par();
1789
1790         if (cursor.boundary() && pos > 0)
1791                 --pos;
1792
1793         if (pos > 0) {
1794                 if (pos == pit->size())
1795                         --pos;
1796                 else // potentional bug... BUG (Lgb)
1797                         if (pit->isSeparator(pos)) {
1798                                 if (pos > cursor.row()->pos() &&
1799                                     bidi_level(pos) % 2 ==
1800                                     bidi_level(pos - 1) % 2)
1801                                         --pos;
1802                                 else if (pos + 1 < pit->size())
1803                                         ++pos;
1804                         }
1805         }
1806
1807         current_font =
1808                 pit->getFontSettings(bv()->buffer()->params, pos);
1809         real_current_font = getFont(bv()->buffer(), pit, pos);
1810
1811         if (cursor.pos() == pit->size() &&
1812             isBoundary(bv()->buffer(), *pit, cursor.pos()) &&
1813             !cursor.boundary()) {
1814                 Language const * lang =
1815                         pit->getParLanguage(bv()->buffer()->params);
1816                 current_font.setLanguage(lang);
1817                 current_font.setNumber(LyXFont::OFF);
1818                 real_current_font.setLanguage(lang);
1819                 real_current_font.setNumber(LyXFont::OFF);
1820         }
1821 }
1822
1823
1824 // returns the column near the specified x-coordinate of the row
1825 // x is set to the real beginning of this column
1826 pos_type
1827 LyXText::getColumnNearX(RowList::iterator rit, int & x, bool & boundary) const
1828 {
1829         float tmpx = 0.0;
1830         float fill_separator;
1831         float fill_hfill;
1832         float fill_label_hfill;
1833
1834         prepareToPrint(rit, tmpx, fill_separator,
1835                        fill_hfill, fill_label_hfill);
1836
1837         pos_type vc = rit->pos();
1838         pos_type last = lastPrintablePos(*this, rit);
1839         pos_type c = 0;
1840
1841         ParagraphList::iterator rit_par = rit->par();
1842         LyXLayout_ptr const & layout = rit->par()->layout();
1843
1844         bool left_side = false;
1845
1846         pos_type body_pos = rit_par->beginningOfBody();
1847         float last_tmpx = tmpx;
1848
1849         if (body_pos > 0 &&
1850             (body_pos - 1 > last ||
1851              !rit_par->isLineSeparator(body_pos - 1)))
1852                 body_pos = 0;
1853
1854         // check for empty row
1855         if (!rit_par->size()) {
1856                 x = int(tmpx);
1857                 return 0;
1858         }
1859
1860         while (vc <= last && tmpx <= x) {
1861                 c = vis2log(vc);
1862                 last_tmpx = tmpx;
1863                 if (body_pos > 0 && c == body_pos - 1) {
1864                         tmpx += fill_label_hfill +
1865                                 font_metrics::width(layout->labelsep,
1866                                                getLabelFont(bv()->buffer(), &*rit_par));
1867                         if (rit_par->isLineSeparator(body_pos - 1))
1868                                 tmpx -= singleWidth(rit_par, body_pos - 1);
1869                 }
1870
1871                 if (hfillExpansion(*this, rit, c)) {
1872                         tmpx += singleWidth(rit_par, c);
1873                         if (c >= body_pos)
1874                                 tmpx += fill_hfill;
1875                         else
1876                                 tmpx += fill_label_hfill;
1877                 } else if (rit_par->isSeparator(c)) {
1878                         tmpx += singleWidth(rit_par, c);
1879                         if (c >= body_pos)
1880                                 tmpx+= fill_separator;
1881                 } else {
1882                         tmpx += singleWidth(rit_par, c);
1883                 }
1884                 ++vc;
1885         }
1886
1887         if ((tmpx + last_tmpx) / 2 > x) {
1888                 tmpx = last_tmpx;
1889                 left_side = true;
1890         }
1891
1892         if (vc > last + 1)  // This shouldn't happen.
1893                 vc = last + 1;
1894
1895         boundary = false;
1896         // This (rtl_support test) is not needed, but gives
1897         // some speedup if rtl_support=false
1898         bool const lastrow = lyxrc.rtl_support &&
1899                 (boost::next(rit) == rowlist_.end() ||
1900                  boost::next(rit)->par() != rit_par);
1901         // If lastrow is false, we don't need to compute
1902         // the value of rtl.
1903         bool const rtl = (lastrow)
1904                 ? rit_par->isRightToLeftPar(bv()->buffer()->params)
1905                 : false;
1906         if (lastrow &&
1907                  ((rtl &&  left_side && vc == rit->pos() && x < tmpx - 5) ||
1908                    (!rtl && !left_side && vc == last + 1   && x > tmpx + 5)))
1909                 c = last + 1;
1910         else if (vc == rit->pos()) {
1911                 c = vis2log(vc);
1912                 if (bidi_level(c) % 2 == 1)
1913                         ++c;
1914         } else {
1915                 c = vis2log(vc - 1);
1916                 bool const rtl = (bidi_level(c) % 2 == 1);
1917                 if (left_side == rtl) {
1918                         ++c;
1919                         boundary = isBoundary(bv()->buffer(), *rit_par, c);
1920                 }
1921         }
1922
1923         if (rit->pos() <= last && c > last
1924             && rit_par->isNewline(last)) {
1925                 if (bidi_level(last) % 2 == 0)
1926                         tmpx -= singleWidth(rit_par, last);
1927                 else
1928                         tmpx += singleWidth(rit_par, last);
1929                 c = last;
1930         }
1931
1932         c -= rit->pos();
1933         x = int(tmpx);
1934         return c;
1935 }
1936
1937
1938 void LyXText::setCursorFromCoordinates(int x, int y)
1939 {
1940         LyXCursor old_cursor = cursor;
1941
1942         setCursorFromCoordinates(cursor, x, y);
1943         setCurrentFont();
1944         deleteEmptyParagraphMechanism(old_cursor);
1945 }
1946
1947
1948 namespace {
1949
1950         /**
1951          * return true if the cursor given is at the end of a row,
1952          * and the next row is filled by an inset that spans an entire
1953          * row.
1954          */
1955         bool beforeFullRowInset(LyXText & lt, LyXCursor const & cur) {
1956                 RowList::iterator row = cur.row();
1957                 if (boost::next(row) == lt.rows().end())
1958                         return false;
1959                 Row const & next = *boost::next(row);
1960
1961                 if (next.pos() != cur.pos() || next.par() != cur.par())
1962                         return false;
1963
1964                 if (cur.pos() == cur.par()->size()
1965                     || !cur.par()->isInset(cur.pos()))
1966                         return false;
1967                 Inset const * inset = cur.par()->getInset(cur.pos());
1968                 if (inset->needFullRow() || inset->display())
1969                         return true;
1970                 return false;
1971         }
1972 }
1973
1974
1975 void LyXText::setCursorFromCoordinates(LyXCursor & cur, int x, int y)
1976 {
1977         // Get the row first.
1978
1979         RowList::iterator row = getRowNearY(y);
1980         bool bound = false;
1981         pos_type const column = getColumnNearX(row, x, bound);
1982         cur.par(row->par());
1983         cur.pos(row->pos() + column);
1984         cur.x(x);
1985         cur.y(y + row->baseline());
1986         cur.row(row);
1987
1988         if (beforeFullRowInset(*this, cur)) {
1989                 pos_type last = lastPrintablePos(*this, row);
1990                 float x = getCursorX(boost::next(row), cur.pos(), last, bound);
1991                 cur.ix(int(x));
1992                 cur.iy(y + row->height() + boost::next(row)->baseline());
1993                 cur.irow(boost::next(row));
1994         } else {
1995                 cur.iy(cur.y());
1996                 cur.ix(cur.x());
1997                 cur.irow(row);
1998         }
1999         cur.boundary(bound);
2000 }
2001
2002
2003 void LyXText::cursorLeft(bool internal)
2004 {
2005         if (cursor.pos() > 0) {
2006                 bool boundary = cursor.boundary();
2007                 setCursor(cursor.par(), cursor.pos() - 1, true, false);
2008                 if (!internal && !boundary &&
2009                     isBoundary(bv()->buffer(), *cursor.par(), cursor.pos() + 1))
2010                         setCursor(cursor.par(), cursor.pos() + 1, true, true);
2011         } else if (cursor.par() != ownerParagraphs().begin()) { // steps into the above paragraph.
2012                 ParagraphList::iterator pit = boost::prior(cursor.par());
2013                 setCursor(pit, pit->size());
2014         }
2015 }
2016
2017
2018 void LyXText::cursorRight(bool internal)
2019 {
2020         bool const at_end = (cursor.pos() == cursor.par()->size());
2021         bool const at_newline = !at_end &&
2022                 cursor.par()->isNewline(cursor.pos());
2023
2024         if (!internal && cursor.boundary() && !at_newline)
2025                 setCursor(cursor.par(), cursor.pos(), true, false);
2026         else if (!at_end) {
2027                 setCursor(cursor.par(), cursor.pos() + 1, true, false);
2028                 if (!internal &&
2029                     isBoundary(bv()->buffer(), *cursor.par(), cursor.pos()))
2030                         setCursor(cursor.par(), cursor.pos(), true, true);
2031         } else if (boost::next(cursor.par()) != ownerParagraphs().end())
2032                 setCursor(boost::next(cursor.par()), 0);
2033 }
2034
2035
2036 void LyXText::cursorUp(bool selecting)
2037 {
2038 #if 1
2039         int x = cursor.x_fix();
2040         int y = cursor.y() - cursor.row()->baseline() - 1;
2041         setCursorFromCoordinates(x, y);
2042         if (!selecting) {
2043                 int topy = top_y();
2044                 int y1 = cursor.iy() - topy;
2045                 int y2 = y1;
2046                 y -= topy;
2047                 Inset * inset_hit = checkInsetHit(x, y1);
2048                 if (inset_hit && isHighlyEditableInset(inset_hit)) {
2049                         inset_hit->edit(bv(), x, y - (y2 - y1), mouse_button::none);
2050                 }
2051         }
2052 #else
2053         setCursorFromCoordinates(bv(), cursor.x_fix(),
2054                                  cursor.y() - cursor.row()->baseline() - 1);
2055 #endif
2056 }
2057
2058
2059 void LyXText::cursorDown(bool selecting)
2060 {
2061 #if 1
2062         int x = cursor.x_fix();
2063         int y = cursor.y() - cursor.row()->baseline() +
2064                 cursor.row()->height() + 1;
2065         setCursorFromCoordinates(x, y);
2066         if (!selecting && cursor.row() == cursor.irow()) {
2067                 int topy = top_y();
2068                 int y1 = cursor.iy() - topy;
2069                 int y2 = y1;
2070                 y -= topy;
2071                 Inset * inset_hit = checkInsetHit(x, y1);
2072                 if (inset_hit && isHighlyEditableInset(inset_hit)) {
2073                         inset_hit->edit(bv(), x, y - (y2 - y1), mouse_button::none);
2074                 }
2075         }
2076 #else
2077         setCursorFromCoordinates(bv(), cursor.x_fix(),
2078                                  cursor.y() - cursor.row()->baseline()
2079                                  + cursor.row()->height() + 1);
2080 #endif
2081 }
2082
2083
2084 void LyXText::cursorUpParagraph()
2085 {
2086         if (cursor.pos() > 0) {
2087                 setCursor(cursor.par(), 0);
2088         }
2089         else if (cursor.par() != ownerParagraphs().begin()) {
2090                 setCursor(boost::prior(cursor.par()), 0);
2091         }
2092 }
2093
2094
2095 void LyXText::cursorDownParagraph()
2096 {
2097         if (boost::next(cursor.par()) != ownerParagraphs().end()) {
2098                 setCursor(boost::next(cursor.par()), 0);
2099         } else {
2100                 setCursor(cursor.par(), cursor.par()->size());
2101         }
2102 }
2103
2104 // fix the cursor `cur' after a characters has been deleted at `where'
2105 // position. Called by deleteEmptyParagraphMechanism
2106 void LyXText::fixCursorAfterDelete(LyXCursor & cur,
2107                                    LyXCursor const & where)
2108 {
2109         // if cursor is not in the paragraph where the delete occured,
2110         // do nothing
2111         if (cur.par() != where.par())
2112                 return;
2113
2114         // if cursor position is after the place where the delete occured,
2115         // update it
2116         if (cur.pos() > where.pos())
2117                 cur.pos(cur.pos()-1);
2118
2119         // check also if we don't want to set the cursor on a spot behind the
2120         // pagragraph because we erased the last character.
2121         if (cur.pos() > cur.par()->size())
2122                 cur.pos(cur.par()->size());
2123
2124         // recompute row et al. for this cursor
2125         setCursor(cur, cur.par(), cur.pos(), cur.boundary());
2126 }
2127
2128
2129 bool LyXText::deleteEmptyParagraphMechanism(LyXCursor const & old_cursor)
2130 {
2131         // Would be wrong to delete anything if we have a selection.
2132         if (selection.set())
2133                 return false;
2134
2135         // We allow all kinds of "mumbo-jumbo" when freespacing.
2136         if (old_cursor.par()->layout()->free_spacing
2137             || old_cursor.par()->isFreeSpacing()) {
2138                 return false;
2139         }
2140
2141         /* Ok I'll put some comments here about what is missing.
2142            I have fixed BackSpace (and thus Delete) to not delete
2143            double-spaces automagically. I have also changed Cut,
2144            Copy and Paste to hopefully do some sensible things.
2145            There are still some small problems that can lead to
2146            double spaces stored in the document file or space at
2147            the beginning of paragraphs. This happens if you have
2148            the cursor betwenn to spaces and then save. Or if you
2149            cut and paste and the selection have a space at the
2150            beginning and then save right after the paste. I am
2151            sure none of these are very hard to fix, but I will
2152            put out 1.1.4pre2 with FIX_DOUBLE_SPACE defined so
2153            that I can get some feedback. (Lgb)
2154         */
2155
2156         // If old_cursor.pos() == 0 and old_cursor.pos()(1) == LineSeparator
2157         // delete the LineSeparator.
2158         // MISSING
2159
2160         // If old_cursor.pos() == 1 and old_cursor.pos()(0) == LineSeparator
2161         // delete the LineSeparator.
2162         // MISSING
2163
2164         // If the pos around the old_cursor were spaces, delete one of them.
2165         if (old_cursor.par() != cursor.par()
2166             || old_cursor.pos() != cursor.pos()) {
2167                 // Only if the cursor has really moved
2168
2169                 if (old_cursor.pos() > 0
2170                     && old_cursor.pos() < old_cursor.par()->size()
2171                     && old_cursor.par()->isLineSeparator(old_cursor.pos())
2172                     && old_cursor.par()->isLineSeparator(old_cursor.pos() - 1)) {
2173                         old_cursor.par()->erase(old_cursor.pos() - 1);
2174                         redoParagraphs(old_cursor, boost::next(old_cursor.par()));
2175
2176 #ifdef WITH_WARNINGS
2177 #warning This will not work anymore when we have multiple views of the same buffer
2178 // In this case, we will have to correct also the cursors held by
2179 // other bufferviews. It will probably be easier to do that in a more
2180 // automated way in LyXCursor code. (JMarc 26/09/2001)
2181 #endif
2182                         // correct all cursors held by the LyXText
2183                         fixCursorAfterDelete(cursor, old_cursor);
2184                         fixCursorAfterDelete(selection.cursor,
2185                                              old_cursor);
2186                         fixCursorAfterDelete(selection.start,
2187                                              old_cursor);
2188                         fixCursorAfterDelete(selection.end, old_cursor);
2189                         fixCursorAfterDelete(last_sel_cursor,
2190                                              old_cursor);
2191                         fixCursorAfterDelete(toggle_cursor, old_cursor);
2192                         fixCursorAfterDelete(toggle_end_cursor,
2193                                              old_cursor);
2194                         return false;
2195                 }
2196         }
2197
2198         // don't delete anything if this is the ONLY paragraph!
2199         if (ownerParagraphs().size() == 1)
2200                 return false;
2201
2202         // Do not delete empty paragraphs with keepempty set.
2203         if (old_cursor.par()->layout()->keepempty)
2204                 return false;
2205
2206         // only do our magic if we changed paragraph
2207         if (old_cursor.par() == cursor.par())
2208                 return false;
2209
2210         // record if we have deleted a paragraph
2211         // we can't possibly have deleted a paragraph before this point
2212         bool deleted = false;
2213
2214         if (old_cursor.par()->empty() ||
2215             (old_cursor.par()->size() == 1 &&
2216              old_cursor.par()->isLineSeparator(0))) {
2217                 // ok, we will delete anything
2218                 LyXCursor tmpcursor;
2219
2220                 deleted = true;
2221
2222                 bool selection_position_was_oldcursor_position = (
2223                         selection.cursor.par()  == old_cursor.par()
2224                         && selection.cursor.pos() == old_cursor.pos());
2225
2226                 if (old_cursor.row() != rows().begin()) {
2227                         RowList::iterator
2228                                 prevrow = boost::prior(old_cursor.row());
2229                         const_cast<LyXText *>(this)->postPaint(old_cursor.y() - old_cursor.row()->baseline() - prevrow->height());
2230                         tmpcursor = cursor;
2231                         cursor = old_cursor; // that undo can restore the right cursor position
2232                         #warning FIXME. --end() iterator is usable here
2233                         ParagraphList::iterator endpit = boost::next(old_cursor.par());
2234                         while (endpit != ownerParagraphs().end() &&
2235                                endpit->getDepth()) {
2236                                 ++endpit;
2237                         }
2238
2239                         setUndo(bv(), Undo::DELETE, old_cursor.par(), endpit);
2240                         cursor = tmpcursor;
2241
2242                         // delete old row
2243                         removeRow(old_cursor.row());
2244                         // delete old par
2245                         ownerParagraphs().erase(old_cursor.par());
2246
2247                         /* Breakagain the next par. Needed because of
2248                          * the parindent that can occur or dissappear.
2249                          * The next row can change its height, if
2250                          * there is another layout before */
2251                         if (boost::next(prevrow) != rows().end()) {
2252                                 breakAgain(boost::next(prevrow));
2253                                 updateCounters();
2254                         }
2255                         setHeightOfRow(prevrow);
2256                 } else {
2257                         RowList::iterator nextrow = boost::next(old_cursor.row());
2258                         const_cast<LyXText *>(this)->postPaint(
2259                                 old_cursor.y() - old_cursor.row()->baseline());
2260
2261                         tmpcursor = cursor;
2262                         cursor = old_cursor; // that undo can restore the right cursor position
2263 #warning FIXME. --end() iterator is usable here
2264                         ParagraphList::iterator endpit = boost::next(old_cursor.par());
2265                         while (endpit != ownerParagraphs().end() &&
2266                                endpit->getDepth()) {
2267                                 ++endpit;
2268                         }
2269
2270                         setUndo(bv(), Undo::DELETE, old_cursor.par(), endpit);
2271                         cursor = tmpcursor;
2272
2273                         // delete old row
2274                         removeRow(old_cursor.row());
2275                         // delete old par
2276                         ownerParagraphs().erase(old_cursor.par());
2277
2278                         /* Breakagain the next par. Needed because of
2279                            the parindent that can occur or dissappear.
2280                            The next row can change its height, if
2281                            there is another layout before */
2282                         if (nextrow != rows().end()) {
2283                                 breakAgain(nextrow);
2284                                 updateCounters();
2285                         }
2286                 }
2287
2288                 // correct cursor y
2289                 setCursorIntern(cursor.par(), cursor.pos());
2290
2291                 if (selection_position_was_oldcursor_position) {
2292                         // correct selection
2293                         selection.cursor = cursor;
2294                 }
2295         }
2296         if (!deleted) {
2297                 if (old_cursor.par()->stripLeadingSpaces()) {
2298                         redoParagraphs(old_cursor, boost::next(old_cursor.par()));
2299                         // correct cursor y
2300                         setCursorIntern(cursor.par(), cursor.pos());
2301                         selection.cursor = cursor;
2302                 }
2303         }
2304         return deleted;
2305 }
2306
2307
2308 ParagraphList & LyXText::ownerParagraphs() const
2309 {
2310         if (inset_owner) {
2311                 return inset_owner->paragraphs;
2312         }
2313         return bv_owner->buffer()->paragraphs;
2314 }
2315
2316
2317 LyXText::refresh_status LyXText::refreshStatus() const
2318 {
2319         return refresh_status_;
2320 }
2321
2322
2323 void LyXText::clearPaint()
2324 {
2325         refresh_status_ = REFRESH_NONE;
2326         refresh_row = rows().end();
2327         refresh_y = 0;
2328 }
2329
2330
2331 void LyXText::postPaint(int start_y)
2332 {
2333         refresh_status old = refresh_status_;
2334
2335         refresh_status_ = REFRESH_AREA;
2336         refresh_row = rows().end();
2337
2338         if (old != REFRESH_NONE && refresh_y < start_y)
2339                 return;
2340
2341         refresh_y = start_y;
2342
2343         if (!inset_owner)
2344                 return;
2345
2346         // We are an inset's lyxtext. Tell the top-level lyxtext
2347         // it needs to update the row we're in.
2348         LyXText * t = bv()->text;
2349         t->postRowPaint(t->cursor.row(), t->cursor.y() - t->cursor.row()->baseline());
2350 }
2351
2352
2353 // FIXME: we should probably remove this y parameter,
2354 // make refresh_y be 0, and use row->y etc.
2355 void LyXText::postRowPaint(RowList::iterator rit, int start_y)
2356 {
2357         if (refresh_status_ != REFRESH_NONE && refresh_y < start_y) {
2358                 refresh_status_ = REFRESH_AREA;
2359                 return;
2360         } else {
2361                 refresh_y = start_y;
2362         }
2363
2364         if (refresh_status_ == REFRESH_AREA)
2365                 return;
2366
2367         refresh_status_ = REFRESH_ROW;
2368         refresh_row = rit;
2369
2370         if (!inset_owner)
2371                 return;
2372
2373         // We are an inset's lyxtext. Tell the top-level lyxtext
2374         // it needs to update the row we're in.
2375         LyXText * t = bv()->text;
2376         t->postRowPaint(t->cursor.row(), t->cursor.y() - t->cursor.row()->baseline());
2377 }
2378
2379
2380 bool LyXText::isInInset() const
2381 {
2382         // Sub-level has non-null bv owner and
2383         // non-null inset owner.
2384         return inset_owner != 0 && bv_owner != 0;
2385 }
2386
2387
2388 int defaultRowHeight()
2389 {
2390         LyXFont const font(LyXFont::ALL_SANE);
2391         return int(font_metrics::maxAscent(font)
2392                  + font_metrics::maxDescent(font) * 1.5);
2393 }