src/text2.C

   1 /**
   2  * \file text2.C
   3  * This file is part of LyX, the document processor.
   4  * Licence details can be found in the file COPYING.
   5  *
   6  * \author Asger Alstrup
   7  * \author Lars Gullik Bjønnes
   8  * \author Alfredo Braunstein
   9  * \author Jean-Marc Lasgouttes
  10  * \author Angus Leeming
  11  * \author John Levon
  12  * \author André Pönitz
  13  * \author Allan Rae
  14  * \author Dekel Tsur
  15  * \author Jürgen Vigna
  16  *
  17  * Full author contact details are available in file CREDITS.
  18  */
  19
  20 #include <config.h>
  21
  22 #include "lyxtext.h"
  23
  24 #include "buffer.h"
  25 #include "buffer_funcs.h"
  26 #include "bufferlist.h"
  27 #include "bufferparams.h"
  28 #include "BufferView.h"
  29 #include "Bullet.h"
  30 #include "coordcache.h"
  31 #include "cursor.h"
  32 #include "CutAndPaste.h"
  33 #include "debug.h"
  34 #include "dispatchresult.h"
  35 #include "errorlist.h"
  36 #include "funcrequest.h"
  37 #include "gettext.h"
  38 #include "language.h"
  39 #include "LColor.h"
  40 #include "lyxfunc.h"
  41 #include "lyxrc.h"
  42 #include "lyxrow.h"
  43 #include "lyxrow_funcs.h"
  44 #include "paragraph.h"
  45 #include "paragraph_funcs.h"
  46 #include "ParagraphParameters.h"
  47 #include "pariterator.h"
  48 #include "lyxserver.h"
  49 #include "lyxsocket.h"
  50 #include "undo.h"
  51 #include "vspace.h"
  52
  53 #include "frontends/Application.h"
  54 #include "frontends/font_metrics.h"
  55
  56 #include "insets/insetenv.h"
  57
  58 #include "mathed/InsetMathHull.h"
  59
  60 #include "support/textutils.h"
  61
  62 #include <boost/current_function.hpp>
  63
  64 #include <sstream>
  65
  66 using lyx::docstring;
  67 using lyx::pit_type;
  68 using lyx::pos_type;
  69
  70 using std::endl;
  71 using std::ostringstream;
  72 using std::string;
  73 using std::max;
  74 using std::min;
  75
  76
  77 LyXText::LyXText(BufferView * bv)
  78         : maxwidth_(bv ? bv->workWidth() : 100),
  79           current_font(LyXFont::ALL_INHERIT),
  80           background_color_(LColor::background),
  81           bv_owner(bv),
  82           autoBreakRows_(false)
  83 {}
  84
  85
  86 void LyXText::init(BufferView * bv)
  87 {
  88         BOOST_ASSERT(bv);
  89         bv_owner = bv;
  90         maxwidth_ = bv->workWidth();
  91         dim_.wid = maxwidth_;
  92         dim_.asc = 10;
  93         dim_.des = 10;
  94
  95         pit_type const end = paragraphs().size();
  96         for (pit_type pit = 0; pit != end; ++pit)
  97                 pars_[pit].rows().clear();
  98
  99         updateLabels(*bv->buffer());
 100 }
 101
 102
 103 bool LyXText::isMainText() const
 104 {
 105         return &bv()->buffer()->text() == this;
 106 }
 107
 108
 109 //takes screen x,y coordinates
 110 InsetBase * LyXText::checkInsetHit(int x, int y) const
 111 {
 112         pit_type pit = getPitNearY(y);
 113         BOOST_ASSERT(pit != -1);
 114
 115         Paragraph const & par = pars_[pit];
 116
 117         lyxerr[Debug::DEBUG]
 118                 << BOOST_CURRENT_FUNCTION
 119                 << ": x: " << x
 120                 << " y: " << y
 121                 << "  pit: " << pit
 122                 << endl;
 123         InsetList::const_iterator iit = par.insetlist.begin();
 124         InsetList::const_iterator iend = par.insetlist.end();
 125         for (; iit != iend; ++iit) {
 126                 InsetBase * inset = iit->inset;
 127 #if 1
 128                 lyxerr[Debug::DEBUG]
 129                         << BOOST_CURRENT_FUNCTION
 130                         << ": examining inset " << inset << endl;
 131
 132                 if (theCoords.getInsets().has(inset))
 133                         lyxerr[Debug::DEBUG]
 134                                 << BOOST_CURRENT_FUNCTION
 135                                 << ": xo: " << inset->xo() << "..."
 136                                 << inset->xo() + inset->width()
 137                                 << " yo: " << inset->yo() - inset->ascent()
 138                                 << "..."
 139                                 << inset->yo() + inset->descent()
 140                                 << endl;
 141                 else
 142                         lyxerr[Debug::DEBUG]
 143                                 << BOOST_CURRENT_FUNCTION
 144                                 << ": inset has no cached position" << endl;
 145 #endif
 146                 if (inset->covers(x, y)) {
 147                         lyxerr[Debug::DEBUG]
 148                                 << BOOST_CURRENT_FUNCTION
 149                                 << ": Hit inset: " << inset << endl;
 150                         return inset;
 151                 }
 152         }
 153         lyxerr[Debug::DEBUG]
 154                 << BOOST_CURRENT_FUNCTION
 155                 << ": No inset hit. " << endl;
 156         return 0;
 157 }
 158
 159
 160
 161 // Gets the fully instantiated font at a given position in a paragraph
 162 // Basically the same routine as Paragraph::getFont() in paragraph.C.
 163 // The difference is that this one is used for displaying, and thus we
 164 // are allowed to make cosmetic improvements. For instance make footnotes
 165 // smaller. (Asger)
 166 LyXFont LyXText::getFont(Paragraph const & par, pos_type const pos) const
 167 {
 168         BOOST_ASSERT(pos >= 0);
 169
 170         LyXLayout_ptr const & layout = par.layout();
 171 #ifdef WITH_WARNINGS
 172 #warning broken?
 173 #endif
 174         BufferParams const & params = bv()->buffer()->params();
 175         pos_type const body_pos = par.beginOfBody();
 176
 177         // We specialize the 95% common case:
 178         if (!par.getDepth()) {
 179                 LyXFont f = par.getFontSettings(params, pos);
 180                 if (!isMainText())
 181                         applyOuterFont(f);
 182                 LyXFont lf;
 183                 LyXFont rlf;
 184                 if (layout->labeltype == LABEL_MANUAL && pos < body_pos) {
 185                         lf = layout->labelfont;
 186                         rlf = layout->reslabelfont;
 187                 } else {
 188                         lf = layout->font;
 189                         rlf = layout->resfont;
 190                 }
 191                 // In case the default family has been customized
 192                 if (lf.family() == LyXFont::INHERIT_FAMILY)
 193                         rlf.setFamily(params.getFont().family());
 194                 return f.realize(rlf);
 195         }
 196
 197         // The uncommon case need not be optimized as much
 198         LyXFont layoutfont;
 199         if (pos < body_pos)
 200                 layoutfont = layout->labelfont;
 201         else
 202                 layoutfont = layout->font;
 203
 204         LyXFont font = par.getFontSettings(params, pos);
 205         font.realize(layoutfont);
 206
 207         if (!isMainText())
 208                 applyOuterFont(font);
 209
 210         // Find the pit value belonging to paragraph. This will not break
 211         // even if pars_ would not be a vector anymore.
 212         // Performance appears acceptable.
 213
 214         pit_type pit = pars_.size();
 215         for (pit_type it = 0; it < pit; ++it)
 216                 if (&pars_[it] == &par) {
 217                         pit = it;
 218                         break;
 219                 }
 220         // Realize against environment font information
 221         // NOTE: the cast to pit_type should be removed when pit_type
 222         // changes to a unsigned integer.
 223         if (pit < pit_type(pars_.size()))
 224                 font.realize(outerFont(pit, pars_));
 225
 226         // Realize with the fonts of lesser depth.
 227         font.realize(params.getFont());
 228
 229         return font;
 230 }
 231
 232 // There are currently two font mechanisms in LyX:
 233 // 1. The font attributes in a lyxtext, and
 234 // 2. The inset-specific font properties, defined in an inset's
 235 // metrics() and draw() methods and handed down the inset chain through
 236 // the pi/mi parameters, and stored locally in a lyxtext in font_.
 237 // This is where the two are integrated in the final fully realized
 238 // font.
 239 void LyXText::applyOuterFont(LyXFont & font) const {
 240         LyXFont lf(font_);
 241         lf.reduce(bv()->buffer()->params().getFont());
 242         lf.realize(font);
 243         lf.setLanguage(font.language());
 244         font = lf;
 245 }
 246
 247
 248 LyXFont LyXText::getLayoutFont(pit_type const pit) const
 249 {
 250         LyXLayout_ptr const & layout = pars_[pit].layout();
 251
 252         if (!pars_[pit].getDepth())  {
 253                 LyXFont lf = layout->resfont;
 254                 // In case the default family has been customized
 255                 if (layout->font.family() == LyXFont::INHERIT_FAMILY)
 256                         lf.setFamily(bv()->buffer()->params().getFont().family());
 257                 return lf;
 258         }
 259
 260         LyXFont font = layout->font;
 261         // Realize with the fonts of lesser depth.
 262         //font.realize(outerFont(pit, paragraphs()));
 263         font.realize(bv()->buffer()->params().getFont());
 264
 265         return font;
 266 }
 267
 268
 269 LyXFont LyXText::getLabelFont(Paragraph const & par) const
 270 {
 271         LyXLayout_ptr const & layout = par.layout();
 272
 273         if (!par.getDepth()) {
 274                 LyXFont lf = layout->reslabelfont;
 275                 // In case the default family has been customized
 276                 if (layout->labelfont.family() == LyXFont::INHERIT_FAMILY)
 277                         lf.setFamily(bv()->buffer()->params().getFont().family());
 278                 return lf;
 279         }
 280
 281         LyXFont font = layout->labelfont;
 282         // Realize with the fonts of lesser depth.
 283         font.realize(bv()->buffer()->params().getFont());
 284
 285         return font;
 286 }
 287
 288
 289 void LyXText::setCharFont(pit_type pit, pos_type pos, LyXFont const & fnt)
 290 {
 291         LyXFont font = fnt;
 292         LyXLayout_ptr const & layout = pars_[pit].layout();
 293
 294         // Get concrete layout font to reduce against
 295         LyXFont layoutfont;
 296
 297         if (pos < pars_[pit].beginOfBody())
 298                 layoutfont = layout->labelfont;
 299         else
 300                 layoutfont = layout->font;
 301
 302         // Realize against environment font information
 303         if (pars_[pit].getDepth()) {
 304                 pit_type tp = pit;
 305                 while (!layoutfont.resolved() &&
 306                        tp != pit_type(paragraphs().size()) &&
 307                        pars_[tp].getDepth()) {
 308                         tp = outerHook(tp, paragraphs());
 309                         if (tp != pit_type(paragraphs().size()))
 310                                 layoutfont.realize(pars_[tp].layout()->font);
 311                 }
 312         }
 313
 314         // Inside inset, apply the inset's font attributes if any
 315         // (charstyle!)
 316         if (!isMainText())
 317                 layoutfont.realize(font_);
 318
 319         layoutfont.realize(bv()->buffer()->params().getFont());
 320
 321         // Now, reduce font against full layout font
 322         font.reduce(layoutfont);
 323
 324         pars_[pit].setFont(pos, font);
 325 }
 326
 327
 328 // return past-the-last paragraph influenced by a layout change on pit
 329 pit_type LyXText::undoSpan(pit_type pit)
 330 {
 331         pit_type end = paragraphs().size();
 332         pit_type nextpit = pit + 1;
 333         if (nextpit == end)
 334                 return nextpit;
 335         //because of parindents
 336         if (!pars_[pit].getDepth())
 337                 return boost::next(nextpit);
 338         //because of depth constrains
 339         for (; nextpit != end; ++pit, ++nextpit) {
 340                 if (!pars_[pit].getDepth())
 341                         break;
 342         }
 343         return nextpit;
 344 }
 345
 346
 347 void LyXText::setLayout(pit_type start, pit_type end, string const & layout)
 348 {
 349         BOOST_ASSERT(start != end);
 350
 351         BufferParams const & bufparams = bv()->buffer()->params();
 352         LyXLayout_ptr const & lyxlayout = bufparams.getLyXTextClass()[layout];
 353
 354         for (pit_type pit = start; pit != end; ++pit) {
 355                 pars_[pit].applyLayout(lyxlayout);
 356                 if (lyxlayout->margintype == MARGIN_MANUAL)
 357                         pars_[pit].setLabelWidthString(lyxlayout->labelstring());
 358         }
 359 }
 360
 361
 362 // set layout over selection and make a total rebreak of those paragraphs
 363 void LyXText::setLayout(LCursor & cur, string const & layout)
 364 {
 365         BOOST_ASSERT(this == cur.text());
 366         // special handling of new environment insets
 367         BufferView & bv = cur.bv();
 368         BufferParams const & params = bv.buffer()->params();
 369         LyXLayout_ptr const & lyxlayout = params.getLyXTextClass()[layout];
 370         if (lyxlayout->is_environment) {
 371                 // move everything in a new environment inset
 372                 lyxerr[Debug::DEBUG] << "setting layout " << layout << endl;
 373                 theApp->lyxFunc().dispatch(FuncRequest(LFUN_LINE_BEGIN));
 374                 theApp->lyxFunc().dispatch(FuncRequest(LFUN_LINE_END_SELECT));
 375                 theApp->lyxFunc().dispatch(FuncRequest(LFUN_CUT));
 376                 InsetBase * inset = new InsetEnvironment(params, layout);
 377                 insertInset(cur, inset);
 378                 //inset->edit(cur, true);
 379                 //theApp->lyxFunc().dispatch(FuncRequest(LFUN_PASTE));
 380                 return;
 381         }
 382
 383         pit_type start = cur.selBegin().pit();
 384         pit_type end = cur.selEnd().pit() + 1;
 385         pit_type undopit = undoSpan(end - 1);
 386         recUndo(start, undopit - 1);
 387         setLayout(start, end, layout);
 388         updateLabels(cur.buffer());
 389 }
 390
 391
 392 namespace {
 393
 394
 395 bool changeDepthAllowed(LyXText::DEPTH_CHANGE type,
 396                         Paragraph const & par, int max_depth)
 397 {
 398         if (par.layout()->labeltype == LABEL_BIBLIO)
 399                 return false;
 400         int const depth = par.params().depth();
 401         if (type == LyXText::INC_DEPTH && depth < max_depth)
 402                 return true;
 403         if (type == LyXText::DEC_DEPTH && depth > 0)
 404                 return true;
 405         return false;
 406 }
 407
 408
 409 }
 410
 411
 412 bool LyXText::changeDepthAllowed(LCursor & cur, DEPTH_CHANGE type) const
 413 {
 414         BOOST_ASSERT(this == cur.text());
 415         // this happens when selecting several cells in tabular (bug 2630)
 416         if (cur.selBegin().idx() != cur.selEnd().idx())
 417                 return false;
 418
 419         pit_type const beg = cur.selBegin().pit();
 420         pit_type const end = cur.selEnd().pit() + 1;
 421         int max_depth = (beg != 0 ? pars_[beg - 1].getMaxDepthAfter() : 0);
 422
 423         for (pit_type pit = beg; pit != end; ++pit) {
 424                 if (::changeDepthAllowed(type, pars_[pit], max_depth))
 425                         return true;
 426                 max_depth = pars_[pit].getMaxDepthAfter();
 427         }
 428         return false;
 429 }
 430
 431
 432 void LyXText::changeDepth(LCursor & cur, DEPTH_CHANGE type)
 433 {
 434         BOOST_ASSERT(this == cur.text());
 435         pit_type const beg = cur.selBegin().pit();
 436         pit_type const end = cur.selEnd().pit() + 1;
 437         recordUndoSelection(cur);
 438         int max_depth = (beg != 0 ? pars_[beg - 1].getMaxDepthAfter() : 0);
 439
 440         for (pit_type pit = beg; pit != end; ++pit) {
 441                 Paragraph & par = pars_[pit];
 442                 if (::changeDepthAllowed(type, par, max_depth)) {
 443                         int const depth = par.params().depth();
 444                         if (type == INC_DEPTH)
 445                                 par.params().depth(depth + 1);
 446                         else
 447                                 par.params().depth(depth - 1);
 448                 }
 449                 max_depth = par.getMaxDepthAfter();
 450         }
 451         // this handles the counter labels, and also fixes up
 452         // depth values for follow-on (child) paragraphs
 453         updateLabels(cur.buffer());
 454 }
 455
 456
 457 // set font over selection
 458 void LyXText::setFont(LCursor & cur, LyXFont const & font, bool toggleall)
 459 {
 460         BOOST_ASSERT(this == cur.text());
 461         // if there is no selection just set the current_font
 462         if (!cur.selection()) {
 463                 // Determine basis font
 464                 LyXFont layoutfont;
 465                 pit_type pit = cur.pit();
 466                 if (cur.pos() < pars_[pit].beginOfBody())
 467                         layoutfont = getLabelFont(pars_[pit]);
 468                 else
 469                         layoutfont = getLayoutFont(pit);
 470
 471                 // Update current font
 472                 real_current_font.update(font,
 473                                          cur.buffer().params().language,
 474                                          toggleall);
 475
 476                 // Reduce to implicit settings
 477                 current_font = real_current_font;
 478                 current_font.reduce(layoutfont);
 479                 // And resolve it completely
 480                 real_current_font.realize(layoutfont);
 481
 482                 return;
 483         }
 484
 485         // Ok, we have a selection.
 486         recordUndoSelection(cur);
 487
 488         DocIterator dit = cur.selectionBegin();
 489         DocIterator ditend = cur.selectionEnd();
 490
 491         BufferParams const & params = cur.buffer().params();
 492
 493         // Don't use forwardChar here as ditend might have
 494         // pos() == lastpos() and forwardChar would miss it.
 495         // Can't use forwardPos either as this descends into
 496         // nested insets.
 497         for (; dit != ditend; dit.forwardPosNoDescend()) {
 498                 if (dit.pos() != dit.lastpos()) {
 499                         LyXFont f = getFont(dit.paragraph(), dit.pos());
 500                         f.update(font, params.language, toggleall);
 501                         setCharFont(dit.pit(), dit.pos(), f);
 502                 }
 503         }
 504 }
 505
 506
 507 // the cursor set functions have a special mechanism. When they
 508 // realize you left an empty paragraph, they will delete it.
 509
 510 bool LyXText::cursorHome(LCursor & cur)
 511 {
 512         BOOST_ASSERT(this == cur.text());
 513         Row const & row = cur.paragraph().getRow(cur.pos(),cur.boundary());
 514
 515         return setCursor(cur, cur.pit(), row.pos());
 516 }
 517
 518
 519 bool LyXText::cursorEnd(LCursor & cur)
 520 {
 521         BOOST_ASSERT(this == cur.text());
 522         // if not on the last row of the par, put the cursor before
 523         // the final space exept if I have a spanning inset or one string
 524         // is so long that we force a break.
 525         pos_type end = cur.textRow().endpos();
 526         if (end == 0)
 527                 // empty text, end-1 is no valid position
 528                 return false;
 529         bool boundary = false;
 530         if (end != cur.lastpos()) {
 531                 if (!cur.paragraph().isLineSeparator(end-1)
 532                     && !cur.paragraph().isNewline(end-1))
 533                         boundary = true;
 534                 else
 535                         --end;
 536         }
 537         return setCursor(cur, cur.pit(), end, true, boundary);
 538 }
 539
 540
 541 bool LyXText::cursorTop(LCursor & cur)
 542 {
 543         BOOST_ASSERT(this == cur.text());
 544         return setCursor(cur, 0, 0);
 545 }
 546
 547
 548 bool LyXText::cursorBottom(LCursor & cur)
 549 {
 550         BOOST_ASSERT(this == cur.text());
 551         return setCursor(cur, cur.lastpit(), boost::prior(paragraphs().end())->size());
 552 }
 553
 554
 555 void LyXText::toggleFree(LCursor & cur, LyXFont const & font, bool toggleall)
 556 {
 557         BOOST_ASSERT(this == cur.text());
 558         // If the mask is completely neutral, tell user
 559         if (font == LyXFont(LyXFont::ALL_IGNORE)) {
 560                 // Could only happen with user style
 561                 cur.message(_("No font change defined. "
 562                                            "Use Character under the Layout menu to define font change."));
 563                 return;
 564         }
 565
 566         // Try implicit word selection
 567         // If there is a change in the language the implicit word selection
 568         // is disabled.
 569         CursorSlice resetCursor = cur.top();
 570         bool implicitSelection =
 571                 font.language() == ignore_language
 572                 && font.number() == LyXFont::IGNORE
 573                 && selectWordWhenUnderCursor(cur, lyx::WHOLE_WORD_STRICT);
 574
 575         // Set font
 576         setFont(cur, font, toggleall);
 577
 578         // Implicit selections are cleared afterwards
 579         // and cursor is set to the original position.
 580         if (implicitSelection) {
 581                 cur.clearSelection();
 582                 cur.top() = resetCursor;
 583                 cur.resetAnchor();
 584         }
 585 }
 586
 587
 588 string LyXText::getStringToIndex(LCursor const & cur)
 589 {
 590         BOOST_ASSERT(this == cur.text());
 591
 592         docstring idxstring;
 593         if (cur.selection())
 594                 idxstring = cur.selectionAsString(false);
 595         else {
 596                 // Try implicit word selection. If there is a change
 597                 // in the language the implicit word selection is
 598                 // disabled.
 599                 LCursor tmpcur = cur;
 600                 selectWord(tmpcur, lyx::PREVIOUS_WORD);
 601
 602                 if (!tmpcur.selection())
 603                         cur.message(_("Nothing to index!"));
 604                 else if (tmpcur.selBegin().pit() != tmpcur.selEnd().pit())
 605                         cur.message(_("Cannot index more than one paragraph!"));
 606                 else
 607                         idxstring = tmpcur.selectionAsString(false);
 608         }
 609
 610         return lyx::to_utf8(idxstring);
 611 }
 612
 613
 614 void LyXText::setParagraph(LCursor & cur,
 615                            Spacing const & spacing, LyXAlignment align,
 616                            string const & labelwidthstring, bool noindent)
 617 {
 618         BOOST_ASSERT(cur.text());
 619         // make sure that the depth behind the selection are restored, too
 620         pit_type undopit = undoSpan(cur.selEnd().pit());
 621         recUndo(cur.selBegin().pit(), undopit - 1);
 622
 623         for (pit_type pit = cur.selBegin().pit(), end = cur.selEnd().pit();
 624              pit <= end; ++pit) {
 625                 Paragraph & par = pars_[pit];
 626                 ParagraphParameters & params = par.params();
 627                 params.spacing(spacing);
 628
 629                 // does the layout allow the new alignment?
 630                 LyXLayout_ptr const & layout = par.layout();
 631
 632                 if (align == LYX_ALIGN_LAYOUT)
 633                         align = layout->align;
 634                 if (align & layout->alignpossible) {
 635                         if (align == layout->align)
 636                                 params.align(LYX_ALIGN_LAYOUT);
 637                         else
 638                                 params.align(align);
 639                 }
 640                 par.setLabelWidthString(labelwidthstring);
 641                 params.noindent(noindent);
 642         }
 643 }
 644
 645
 646 // this really should just insert the inset and not move the cursor.
 647 void LyXText::insertInset(LCursor & cur, InsetBase * inset)
 648 {
 649         BOOST_ASSERT(this == cur.text());
 650         BOOST_ASSERT(inset);
 651         cur.paragraph().insertInset(cur.pos(), inset);
 652 }
 653
 654
 655 // needed to insert the selection
 656 void LyXText::insertStringAsLines(LCursor & cur, docstring const & str)
 657 {
 658         cur.buffer().insertStringAsLines(pars_, cur.pit(), cur.pos(),
 659                                          current_font, str, autoBreakRows_);
 660 }
 661
 662
 663 // turn double CR to single CR, others are converted into one
 664 // blank. Then insertStringAsLines is called
 665 void LyXText::insertStringAsParagraphs(LCursor & cur, docstring const & str)
 666 {
 667         docstring linestr = str;
 668         bool newline_inserted = false;
 669
 670         for (string::size_type i = 0, siz = linestr.size(); i < siz; ++i) {
 671                 if (linestr[i] == '\n') {
 672                         if (newline_inserted) {
 673                                 // we know that \r will be ignored by
 674                                 // insertStringAsLines. Of course, it is a dirty
 675                                 // trick, but it works...
 676                                 linestr[i - 1] = '\r';
 677                                 linestr[i] = '\n';
 678                         } else {
 679                                 linestr[i] = ' ';
 680                                 newline_inserted = true;
 681                         }
 682                 } else if (isPrintable(linestr[i])) {
 683                         newline_inserted = false;
 684                 }
 685         }
 686         insertStringAsLines(cur, linestr);
 687 }
 688
 689
 690 bool LyXText::setCursor(LCursor & cur, pit_type par, pos_type pos,
 691                         bool setfont, bool boundary)
 692 {
 693         LCursor old = cur;
 694         setCursorIntern(cur, par, pos, setfont, boundary);
 695         return deleteEmptyParagraphMechanism(cur, old);
 696 }
 697
 698
 699 void LyXText::setCursor(CursorSlice & cur, pit_type par, pos_type pos)
 700 {
 701         BOOST_ASSERT(par != int(paragraphs().size()));
 702         cur.pit() = par;
 703         cur.pos() = pos;
 704
 705         // now some strict checking
 706         Paragraph & para = getPar(par);
 707
 708         // None of these should happen, but we're scaredy-cats
 709         if (pos < 0) {
 710                 lyxerr << "dont like -1" << endl;
 711                 BOOST_ASSERT(false);
 712         }
 713
 714         if (pos > para.size()) {
 715                 lyxerr << "dont like 1, pos: " << pos
 716                        << " size: " << para.size()
 717                        << " par: " << par << endl;
 718                 BOOST_ASSERT(false);
 719         }
 720 }
 721
 722
 723 void LyXText::setCursorIntern(LCursor & cur,
 724                               pit_type par, pos_type pos, bool setfont, bool boundary)
 725 {
 726         BOOST_ASSERT(this == cur.text());
 727         cur.boundary(boundary);
 728         setCursor(cur.top(), par, pos);
 729         cur.setTargetX();
 730         if (setfont)
 731                 setCurrentFont(cur);
 732 }
 733
 734
 735 void LyXText::setCurrentFont(LCursor & cur)
 736 {
 737         BOOST_ASSERT(this == cur.text());
 738         pos_type pos = cur.pos();
 739         Paragraph & par = cur.paragraph();
 740
 741         if (cur.boundary() && pos > 0)
 742                 --pos;
 743
 744         if (pos > 0) {
 745                 if (pos == cur.lastpos())
 746                         --pos;
 747                 else // potentional bug... BUG (Lgb)
 748                         if (par.isSeparator(pos)) {
 749                                 if (pos > cur.textRow().pos() &&
 750                                     bidi.level(pos) % 2 ==
 751                                     bidi.level(pos - 1) % 2)
 752                                         --pos;
 753                                 else if (pos + 1 < cur.lastpos())
 754                                         ++pos;
 755                         }
 756         }
 757
 758         BufferParams const & bufparams = cur.buffer().params();
 759         current_font = par.getFontSettings(bufparams, pos);
 760         real_current_font = getFont(par, pos);
 761
 762         if (cur.pos() == cur.lastpos()
 763             && bidi.isBoundary(cur.buffer(), par, cur.pos())
 764             && !cur.boundary()) {
 765                 Language const * lang = par.getParLanguage(bufparams);
 766                 current_font.setLanguage(lang);
 767                 current_font.setNumber(LyXFont::OFF);
 768                 real_current_font.setLanguage(lang);
 769                 real_current_font.setNumber(LyXFont::OFF);
 770         }
 771 }
 772
 773
 774 // x is an absolute screen coord
 775 // returns the column near the specified x-coordinate of the row
 776 // x is set to the real beginning of this column
 777 pos_type LyXText::getColumnNearX(pit_type const pit,
 778                                  Row const & row, int & x, bool & boundary) const
 779 {
 780         int const xo = theCoords.get(this, pit).x_;
 781         x -= xo;
 782         RowMetrics const r = computeRowMetrics(pit, row);
 783         Paragraph const & par = pars_[pit];
 784
 785         pos_type vc = row.pos();
 786         pos_type end = row.endpos();
 787         pos_type c = 0;
 788         LyXLayout_ptr const & layout = par.layout();
 789
 790         bool left_side = false;
 791
 792         pos_type body_pos = par.beginOfBody();
 793
 794         double tmpx = r.x;
 795         double last_tmpx = tmpx;
 796
 797         if (body_pos > 0 &&
 798             (body_pos > end || !par.isLineSeparator(body_pos - 1)))
 799                 body_pos = 0;
 800
 801         // check for empty row
 802         if (vc == end) {
 803                 x = int(tmpx) + xo;
 804                 return 0;
 805         }
 806
 807         while (vc < end && tmpx <= x) {
 808                 c = bidi.vis2log(vc);
 809                 last_tmpx = tmpx;
 810                 if (body_pos > 0 && c == body_pos - 1) {
 811                         string lsep = layout->labelsep;
 812                         docstring dlsep(lsep.begin(), lsep.end());
 813                         tmpx += r.label_hfill +
 814                                 font_metrics::width(dlsep, getLabelFont(par));
 815                         if (par.isLineSeparator(body_pos - 1))
 816                                 tmpx -= singleWidth(par, body_pos - 1);
 817                 }
 818
 819                 if (hfillExpansion(par, row, c)) {
 820                         tmpx += singleWidth(par, c);
 821                         if (c >= body_pos)
 822                                 tmpx += r.hfill;
 823                         else
 824                                 tmpx += r.label_hfill;
 825                 } else if (par.isSeparator(c)) {
 826                         tmpx += singleWidth(par, c);
 827                         if (c >= body_pos)
 828                                 tmpx += r.separator;
 829                 } else {
 830                         tmpx += singleWidth(par, c);
 831                 }
 832                 ++vc;
 833         }
 834
 835         if ((tmpx + last_tmpx) / 2 > x) {
 836                 tmpx = last_tmpx;
 837                 left_side = true;
 838         }
 839
 840         BOOST_ASSERT(vc <= end);  // This shouldn't happen.
 841
 842         boundary = false;
 843         // This (rtl_support test) is not needed, but gives
 844         // some speedup if rtl_support == false
 845         bool const lastrow = lyxrc.rtl_support && row.endpos() == par.size();
 846
 847         // If lastrow is false, we don't need to compute
 848         // the value of rtl.
 849         bool const rtl = lastrow ? isRTL(par) : false;
 850         if (lastrow &&
 851             ((rtl  &&  left_side && vc == row.pos() && x < tmpx - 5) ||
 852              (!rtl && !left_side && vc == end  && x > tmpx + 5)))
 853                 c = end;
 854         else if (vc == row.pos()) {
 855                 c = bidi.vis2log(vc);
 856                 if (bidi.level(c) % 2 == 1)
 857                         ++c;
 858         } else {
 859                 c = bidi.vis2log(vc - 1);
 860                 bool const rtl = (bidi.level(c) % 2 == 1);
 861                 if (left_side == rtl) {
 862                         ++c;
 863                         boundary = bidi.isBoundary(*bv()->buffer(), par, c);
 864                 }
 865         }
 866
 867 // I believe this code is not needed anymore (Jug 20050717)
 868 #if 0
 869         // The following code is necessary because the cursor position past
 870         // the last char in a row is logically equivalent to that before
 871         // the first char in the next row. That's why insets causing row
 872         // divisions -- Newline and display-style insets -- must be treated
 873         // specially, so cursor up/down doesn't get stuck in an air gap -- MV
 874         // Newline inset, air gap below:
 875         if (row.pos() < end && c >= end && par.isNewline(end - 1)) {
 876                 if (bidi.level(end -1) % 2 == 0)
 877                         tmpx -= singleWidth(par, end - 1);
 878                 else
 879                         tmpx += singleWidth(par, end - 1);
 880                 c = end - 1;
 881         }
 882
 883         // Air gap above display inset:
 884         if (row.pos() < end && c >= end && end < par.size()
 885             && par.isInset(end) && par.getInset(end)->display()) {
 886                 c = end - 1;
 887         }
 888         // Air gap below display inset:
 889         if (row.pos() < end && c >= end && par.isInset(end - 1)
 890             && par.getInset(end - 1)->display()) {
 891                 c = end - 1;
 892         }
 893 #endif
 894
 895         x = int(tmpx) + xo;
 896         pos_type const col = c - row.pos();
 897
 898         if (!c || end == par.size())
 899                 return col;
 900
 901         if (c==end && !par.isLineSeparator(c-1) && !par.isNewline(c-1)) {
 902                 boundary = true;
 903                 return col;
 904         }
 905
 906         return min(col, end - 1 - row.pos());
 907 }
 908
 909
 910 // y is screen coordinate
 911 pit_type LyXText::getPitNearY(int y) const
 912 {
 913         BOOST_ASSERT(!paragraphs().empty());
 914         BOOST_ASSERT(theCoords.getParPos().find(this) != theCoords.getParPos().end());
 915         CoordCache::InnerParPosCache const & cc = theCoords.getParPos().find(this)->second;
 916         lyxerr[Debug::DEBUG]
 917                 << BOOST_CURRENT_FUNCTION
 918                 << ": y: " << y << " cache size: " << cc.size()
 919                 << endl;
 920
 921         // look for highest numbered paragraph with y coordinate less than given y
 922         pit_type pit = 0;
 923         int yy = -1;
 924         CoordCache::InnerParPosCache::const_iterator it = cc.begin();
 925         CoordCache::InnerParPosCache::const_iterator et = cc.end();
 926         for (; it != et; ++it) {
 927                 lyxerr[Debug::DEBUG]
 928                         << BOOST_CURRENT_FUNCTION
 929                         << "  examining: pit: " << it->first
 930                         << " y: " << it->second.y_
 931                         << endl;
 932
 933                 if (it->first >= pit && int(it->second.y_) - int(pars_[it->first].ascent()) <= y) {
 934                         pit = it->first;
 935                         yy = it->second.y_;
 936                 }
 937         }
 938
 939         lyxerr[Debug::DEBUG]
 940                 << BOOST_CURRENT_FUNCTION
 941                 << ": found best y: " << yy << " for pit: " << pit
 942                 << endl;
 943
 944         return pit;
 945 }
 946
 947
 948 Row const & LyXText::getRowNearY(int y, pit_type pit) const
 949 {
 950         Paragraph const & par = pars_[pit];
 951         int yy = theCoords.get(this, pit).y_ - par.ascent();
 952         BOOST_ASSERT(!par.rows().empty());
 953         RowList::const_iterator rit = par.rows().begin();
 954         RowList::const_iterator const rlast = boost::prior(par.rows().end());
 955         for (; rit != rlast; yy += rit->height(), ++rit)
 956                 if (yy + rit->height() > y)
 957                         break;
 958         return *rit;
 959 }
 960
 961
 962 // x,y are absolute screen coordinates
 963 // sets cursor recursively descending into nested editable insets
 964 InsetBase * LyXText::editXY(LCursor & cur, int x, int y)
 965 {
 966         pit_type pit = getPitNearY(y);
 967         BOOST_ASSERT(pit != -1);
 968         Row const & row = getRowNearY(y, pit);
 969         bool bound = false;
 970
 971         int xx = x; // is modified by getColumnNearX
 972         pos_type const pos = row.pos() + getColumnNearX(pit, row, xx, bound);
 973         cur.pit() = pit;
 974         cur.pos() = pos;
 975         cur.boundary(bound);
 976         cur.x_target() = x;
 977
 978         // try to descend into nested insets
 979         InsetBase * inset = checkInsetHit(x, y);
 980         //lyxerr << "inset " << inset << " hit at x: " << x << " y: " << y << endl;
 981         if (!inset) {
 982                 // Either we deconst editXY or better we move current_font
 983                 // and real_current_font to LCursor
 984                 setCurrentFont(cur);
 985                 return 0;
 986         }
 987
 988         // This should be just before or just behind the
 989         // cursor position set above.
 990         BOOST_ASSERT((pos != 0 && inset == pars_[pit].getInset(pos - 1))
 991                      || inset == pars_[pit].getInset(pos));
 992         // Make sure the cursor points to the position before
 993         // this inset.
 994         if (inset == pars_[pit].getInset(pos - 1))
 995                 --cur.pos();
 996         inset = inset->editXY(cur, x, y);
 997         if (cur.top().text() == this)
 998                 setCurrentFont(cur);
 999         return inset;
1000 }
1001
1002
1003 bool LyXText::checkAndActivateInset(LCursor & cur, bool front)
1004 {
1005         if (cur.selection())
1006                 return false;
1007         if (cur.pos() == cur.lastpos())
1008                 return false;
1009         InsetBase * inset = cur.nextInset();
1010         if (!isHighlyEditableInset(inset))
1011                 return false;
1012         inset->edit(cur, front);
1013         return true;
1014 }
1015
1016
1017 bool LyXText::cursorLeft(LCursor & cur)
1018 {
1019         if (!cur.boundary() && cur.pos() > 0 &&
1020             cur.textRow().pos() == cur.pos() &&
1021             !cur.paragraph().isLineSeparator(cur.pos()-1) &&
1022             !cur.paragraph().isNewline(cur.pos()-1)) {
1023                 return setCursor(cur, cur.pit(), cur.pos(), true, true);
1024         }
1025         if (cur.pos() != 0) {
1026                 bool boundary = cur.boundary();
1027                 bool updateNeeded = setCursor(cur, cur.pit(), cur.pos() - 1, true, false);
1028                 if (!checkAndActivateInset(cur, false)) {
1029                         if (false && !boundary &&
1030                             bidi.isBoundary(cur.buffer(), cur.paragraph(), cur.pos() + 1))
1031                                 updateNeeded |=
1032                                         setCursor(cur, cur.pit(), cur.pos() + 1, true, true);
1033                 }
1034                 return updateNeeded;
1035         }
1036
1037         if (cur.pit() != 0) {
1038                 // Steps into the paragraph above
1039                 return setCursor(cur, cur.pit() - 1, getPar(cur.pit() - 1).size());
1040         }
1041         return false;
1042 }
1043
1044
1045 bool LyXText::cursorRight(LCursor & cur)
1046 {
1047         if (cur.pos() != cur.lastpos()) {
1048                 if (cur.boundary())
1049                         return setCursor(cur, cur.pit(), cur.pos(),
1050                                          true, false);
1051
1052                 bool updateNeeded = false;
1053                 if (!checkAndActivateInset(cur, true)) {
1054                         if (cur.textRow().endpos() == cur.pos() + 1 &&
1055                             cur.textRow().endpos() != cur.lastpos() &&
1056                             !cur.paragraph().isLineSeparator(cur.pos()) &&
1057                             !cur.paragraph().isNewline(cur.pos())) {
1058                                 cur.boundary(true);
1059                         }
1060                         updateNeeded |= setCursor(cur, cur.pit(), cur.pos() + 1, true, cur.boundary());
1061                         if (false && bidi.isBoundary(cur.buffer(), cur.paragraph(),
1062                                                      cur.pos()))
1063                                 updateNeeded |= setCursor(cur, cur.pit(), cur.pos(), true, true);
1064                 }
1065                 return updateNeeded;
1066         }
1067
1068         if (cur.pit() != cur.lastpit())
1069                 return setCursor(cur, cur.pit() + 1, 0);
1070         return false;
1071 }
1072
1073
1074 bool LyXText::cursorUp(LCursor & cur)
1075 {
1076         Paragraph const & par = cur.paragraph();
1077         int row;
1078         int const x = cur.targetX();
1079
1080         if (cur.pos() && cur.boundary())
1081                 row = par.pos2row(cur.pos()-1);
1082         else
1083                 row = par.pos2row(cur.pos());
1084
1085         if (!cur.selection()) {
1086                 int const y = bv_funcs::getPos(cur, cur.boundary()).y_;
1087                 LCursor old = cur;
1088                 // Go to middle of previous row. 16 found to work OK;
1089                 // 12 = top/bottom margin of display math
1090                 int const margin = 3 * InsetMathHull::displayMargin() / 2;
1091                 editXY(cur, x, y - par.rows()[row].ascent() - margin);
1092                 cur.clearSelection();
1093
1094                 // This happens when you move out of an inset.
1095                 // And to give the DEPM the possibility of doing
1096                 // something we must provide it with two different
1097                 // cursors. (Lgb)
1098                 LCursor dummy = cur;
1099                 if (dummy == old)
1100                         ++dummy.pos();
1101
1102                 return deleteEmptyParagraphMechanism(dummy, old);
1103         }
1104
1105         bool updateNeeded = false;
1106
1107         if (row > 0) {
1108                 updateNeeded |= setCursor(cur, cur.pit(),
1109                                           x2pos(cur.pit(), row - 1, x));
1110         } else if (cur.pit() > 0) {
1111                 --cur.pit();
1112                 //cannot use 'par' now
1113                 updateNeeded |= setCursor(cur, cur.pit(),
1114                                           x2pos(cur.pit(), cur.paragraph().rows().size() - 1, x));
1115         }
1116
1117         cur.x_target() = x;
1118
1119         return updateNeeded;
1120 }
1121
1122
1123 bool LyXText::cursorDown(LCursor & cur)
1124 {
1125         Paragraph const & par = cur.paragraph();
1126         int row;
1127         int const x = cur.targetX();
1128
1129         if (cur.pos() && cur.boundary())
1130                 row = par.pos2row(cur.pos()-1);
1131         else
1132                 row = par.pos2row(cur.pos());
1133
1134         if (!cur.selection()) {
1135                 int const y = bv_funcs::getPos(cur, cur.boundary()).y_;
1136                 LCursor old = cur;
1137                 // To middle of next row
1138                 int const margin = 3 * InsetMathHull::displayMargin() / 2;
1139                 editXY(cur, x, y + par.rows()[row].descent() + margin);
1140                 cur.clearSelection();
1141
1142                 // This happens when you move out of an inset.
1143                 // And to give the DEPM the possibility of doing
1144                 // something we must provide it with two different
1145                 // cursors. (Lgb)
1146                 LCursor dummy = cur;
1147                 if (dummy == old)
1148                         ++dummy.pos();
1149
1150                 bool const changed = deleteEmptyParagraphMechanism(dummy, old);
1151
1152                 // Make sure that cur gets back whatever happened to dummy(Lgb)
1153                 if (changed)
1154                         cur = dummy;
1155
1156                 return changed;
1157         }
1158
1159         bool updateNeeded = false;
1160
1161         if (row + 1 < int(par.rows().size())) {
1162                 updateNeeded |= setCursor(cur, cur.pit(),
1163                                           x2pos(cur.pit(), row + 1, x));
1164         } else if (cur.pit() + 1 < int(paragraphs().size())) {
1165                 ++cur.pit();
1166                 updateNeeded |= setCursor(cur, cur.pit(),
1167                                           x2pos(cur.pit(), 0, x));
1168         }
1169
1170         cur.x_target() = x;
1171
1172         return updateNeeded;
1173 }
1174
1175
1176 bool LyXText::cursorUpParagraph(LCursor & cur)
1177 {
1178         bool updated = false;
1179         if (cur.pos() > 0)
1180                 updated = setCursor(cur, cur.pit(), 0);
1181         else if (cur.pit() != 0)
1182                 updated = setCursor(cur, cur.pit() - 1, 0);
1183         return updated;
1184 }
1185
1186
1187 bool LyXText::cursorDownParagraph(LCursor & cur)
1188 {
1189         bool updated = false;
1190         if (cur.pit() != cur.lastpit())
1191                 updated = setCursor(cur, cur.pit() + 1, 0);
1192         else
1193                 updated = setCursor(cur, cur.pit(), cur.lastpos());
1194         return updated;
1195 }
1196
1197
1198 // fix the cursor `cur' after a characters has been deleted at `where'
1199 // position. Called by deleteEmptyParagraphMechanism
1200 void LyXText::fixCursorAfterDelete(CursorSlice & cur, CursorSlice const & where)
1201 {
1202         // Do nothing if cursor is not in the paragraph where the
1203         // deletion occured,
1204         if (cur.pit() != where.pit())
1205                 return;
1206
1207         // If cursor position is after the deletion place update it
1208         if (cur.pos() > where.pos())
1209                 --cur.pos();
1210
1211         // Check also if we don't want to set the cursor on a spot behind the
1212         // pagragraph because we erased the last character.
1213         if (cur.pos() > cur.lastpos())
1214                 cur.pos() = cur.lastpos();
1215 }
1216
1217
1218 bool LyXText::deleteEmptyParagraphMechanism(LCursor & cur, LCursor & old)
1219 {
1220         // Would be wrong to delete anything if we have a selection.
1221         if (cur.selection())
1222                 return false;
1223
1224         //lyxerr[Debug::DEBUG] << "DEPM: cur:\n" << cur << "old:\n" << old << endl;
1225         // old should point to us
1226         BOOST_ASSERT(old.text() == this);
1227
1228         Paragraph & oldpar = old.paragraph();
1229
1230         // We allow all kinds of "mumbo-jumbo" when freespacing.
1231         if (oldpar.isFreeSpacing())
1232                 return false;
1233
1234         /* Ok I'll put some comments here about what is missing.
1235            There are still some small problems that can lead to
1236            double spaces stored in the document file or space at
1237            the beginning of paragraphs(). This happens if you have
1238            the cursor between to spaces and then save. Or if you
1239            cut and paste and the selection have a space at the
1240            beginning and then save right after the paste. (Lgb)
1241         */
1242
1243         // If old.pos() == 0 and old.pos()(1) == LineSeparator
1244         // delete the LineSeparator.
1245         // MISSING
1246
1247         // If old.pos() == 1 and old.pos()(0) == LineSeparator
1248         // delete the LineSeparator.
1249         // MISSING
1250
1251         bool const same_inset = &old.inset() == &cur.inset();
1252         bool const same_par = same_inset && old.pit() == cur.pit();
1253         bool const same_par_pos = same_par && old.pos() == cur.pos();
1254
1255         // If the chars around the old cursor were spaces, delete one of them.
1256         if (!same_par_pos) {
1257                 // Only if the cursor has really moved.
1258                 if (old.pos() > 0
1259                     && old.pos() < oldpar.size()
1260                     && oldpar.isLineSeparator(old.pos())
1261                     && oldpar.isLineSeparator(old.pos() - 1)
1262                     && oldpar.lookupChange(old.pos() - 1) != Change::DELETED) {
1263                         // We need to set the text to Change::INSERTED to
1264                         // get it erased properly
1265                         oldpar.setChange(old.pos() -1, Change::INSERTED);
1266                         oldpar.erase(old.pos() - 1);
1267 #ifdef WITH_WARNINGS
1268 #warning This will not work anymore when we have multiple views of the same buffer
1269 // In this case, we will have to correct also the cursors held by
1270 // other bufferviews. It will probably be easier to do that in a more
1271 // automated way in CursorSlice code. (JMarc 26/09/2001)
1272 #endif
1273                         // correct all cursor parts
1274                         if (same_par) {
1275                                 fixCursorAfterDelete(cur.top(), old.top());
1276                                 cur.resetAnchor();
1277                         }
1278                         return true;
1279                 }
1280         }
1281
1282         // only do our magic if we changed paragraph
1283         if (same_par)
1284                 return false;
1285
1286         // don't delete anything if this is the ONLY paragraph!
1287         if (old.lastpit() == 0)
1288                 return false;
1289
1290         // Do not delete empty paragraphs with keepempty set.
1291         if (oldpar.allowEmpty())
1292                 return false;
1293
1294         if (oldpar.empty() || (oldpar.size() == 1 && oldpar.isLineSeparator(0))) {
1295                 // Delete old par.
1296                 recordUndo(old, Undo::ATOMIC,
1297                            max(old.pit() - 1, pit_type(0)),
1298                            min(old.pit() + 1, old.lastpit()));
1299                 ParagraphList & plist = old.text()->paragraphs();
1300                 plist.erase(boost::next(plist.begin(), old.pit()));
1301
1302                 // see #warning above
1303                 if (cur.depth() >= old.depth()) {
1304                         CursorSlice & curslice = cur[old.depth() - 1];
1305                         if (&curslice.inset() == &old.inset()
1306                             && curslice.pit() > old.pit()) {
1307                                 --curslice.pit();
1308                                 // since a paragraph has been deleted, all the
1309                                 // insets after `old' have been copied and
1310                                 // their address has changed. Therefore we
1311                                 // need to `regenerate' cur. (JMarc)
1312                                 cur.updateInsets(&(cur.bottom().inset()));
1313                                 cur.resetAnchor();
1314                         }
1315                 }
1316                 // There is a crash reported by Edwin Leuven (16/04/2006) because of:
1317                 //ParIterator par_it(old);
1318                 //updateLabels(old.buffer(), par_it);
1319                 // So for now we do the full update:
1320                 updateLabels(old.buffer());
1321                 return true;
1322         }
1323
1324         if (oldpar.stripLeadingSpaces())
1325                 cur.resetAnchor();
1326
1327         return false;
1328 }
1329
1330
1331 void LyXText::recUndo(pit_type first, pit_type last) const
1332 {
1333         recordUndo(bv()->cursor(), Undo::ATOMIC, first, last);
1334 }
1335
1336
1337 void LyXText::recUndo(pit_type par) const
1338 {
1339         recordUndo(bv()->cursor(), Undo::ATOMIC, par, par);
1340 }
1341
1342
1343 int defaultRowHeight()
1344 {
1345         return int(font_metrics::maxHeight(LyXFont(LyXFont::ALL_SANE)) *  1.2);
1346 }