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