1 /* This file is part of
2 * ======================================================
4 * LyX, The Document Processor
6 * Copyright 1995 Matthias Ettrich
7 * Copyright 1995-2001 The LyX Team.
9 * ====================================================== */
16 #include "paragraph.h"
17 #include "funcrequest.h"
18 #include "frontends/LyXView.h"
19 #include "undo_funcs.h"
21 #include "buffer_funcs.h"
22 #include "bufferparams.h"
23 #include "errorlist.h"
25 #include "BufferView.h"
26 #include "CutAndPaste.h"
27 #include "frontends/Painter.h"
28 #include "frontends/font_metrics.h"
32 #include "FloatList.h"
34 #include "ParagraphParameters.h"
36 #include "lyxrow_funcs.h"
37 #include "metricsinfo.h"
38 #include "paragraph_funcs.h"
40 #include "insets/insetbibitem.h"
41 #include "insets/insetenv.h"
42 #include "insets/insetfloat.h"
43 #include "insets/insetwrap.h"
45 #include "support/LAssert.h"
46 #include "support/textutils.h"
47 #include "support/lstrings.h"
49 #include <boost/tuple/tuple.hpp>
53 using namespace lyx::support;
63 LyXText::LyXText(BufferView * bv)
64 : height(0), width(0), anchor_row_offset_(0),
65 inset_owner(0), the_locking_inset(0), bv_owner(bv)
67 anchor_row_ = rows().end();
71 LyXText::LyXText(BufferView * bv, InsetText * inset)
72 : height(0), width(0), anchor_row_offset_(0),
73 inset_owner(inset), the_locking_inset(0), bv_owner(bv)
75 anchor_row_ = rows().end();
79 void LyXText::init(BufferView * bview)
86 anchor_row_ = rows().end();
87 anchor_row_offset_ = 0;
89 current_font = getFont(ownerParagraphs().begin(), 0);
91 redoParagraphs(ownerParagraphs().begin(), ownerParagraphs().end());
93 setCursorIntern(rowlist_.begin()->par(), 0);
94 selection.cursor = cursor;
100 // Gets the fully instantiated font at a given position in a paragraph
101 // Basically the same routine as Paragraph::getFont() in paragraph.C.
102 // The difference is that this one is used for displaying, and thus we
103 // are allowed to make cosmetic improvements. For instance make footnotes
105 // If position is -1, we get the layout font of the paragraph.
106 // If position is -2, we get the font of the manual label of the paragraph.
107 LyXFont LyXText::getFont(ParagraphList::iterator pit, pos_type pos) const
111 LyXLayout_ptr const & layout = pit->layout();
113 BufferParams const & params = bv()->buffer()->params;
115 // We specialize the 95% common case:
116 if (!pit->getDepth()) {
117 if (layout->labeltype == LABEL_MANUAL
118 && pos < pit->beginningOfBody()) {
120 LyXFont f = pit->getFontSettings(params, pos);
122 pit->inInset()->getDrawFont(f);
123 return f.realize(layout->reslabelfont);
125 LyXFont f = pit->getFontSettings(params, pos);
127 pit->inInset()->getDrawFont(f);
128 return f.realize(layout->resfont);
132 // The uncommon case need not be optimized as much
136 if (pos < pit->beginningOfBody()) {
138 layoutfont = layout->labelfont;
141 layoutfont = layout->font;
144 LyXFont tmpfont = pit->getFontSettings(params, pos);
145 tmpfont.realize(layoutfont);
148 pit->inInset()->getDrawFont(tmpfont);
150 // Realize with the fonts of lesser depth.
151 tmpfont.realize(outerFont(pit, ownerParagraphs()));
152 tmpfont.realize(defaultfont_);
158 LyXFont LyXText::getLayoutFont(ParagraphList::iterator pit) const
160 LyXLayout_ptr const & layout = pit->layout();
162 if (!pit->getDepth())
163 return layout->resfont;
165 LyXFont font = layout->font;
166 // Realize with the fonts of lesser depth.
167 font.realize(outerFont(pit, ownerParagraphs()));
168 font.realize(defaultfont_);
174 LyXFont LyXText::getLabelFont(ParagraphList::iterator pit) const
176 LyXLayout_ptr const & layout = pit->layout();
178 if (!pit->getDepth())
179 return layout->reslabelfont;
181 LyXFont font = layout->labelfont;
182 // Realize with the fonts of lesser depth.
183 font.realize(outerFont(pit, ownerParagraphs()));
184 font.realize(defaultfont_);
190 void LyXText::setCharFont(ParagraphList::iterator pit,
191 pos_type pos, LyXFont const & fnt,
194 BufferParams const & params = bv()->buffer()->params;
195 LyXFont font = getFont(pit, pos);
196 font.update(fnt, params.language, toggleall);
197 // Let the insets convert their font
198 if (pit->isInset(pos)) {
199 InsetOld * inset = pit->getInset(pos);
200 if (isEditableInset(inset)) {
201 static_cast<UpdatableInset *>(inset)
202 ->setFont(bv(), fnt, toggleall, true);
206 // Plug through to version below:
207 setCharFont(pit, pos, font);
211 void LyXText::setCharFont(
212 ParagraphList::iterator pit, pos_type pos, LyXFont const & fnt)
215 LyXLayout_ptr const & layout = pit->layout();
217 // Get concrete layout font to reduce against
220 if (pos < pit->beginningOfBody())
221 layoutfont = layout->labelfont;
223 layoutfont = layout->font;
225 // Realize against environment font information
226 if (pit->getDepth()) {
227 ParagraphList::iterator tp = pit;
228 while (!layoutfont.resolved() &&
229 tp != ownerParagraphs().end() &&
231 tp = outerHook(tp, ownerParagraphs());
232 if (tp != ownerParagraphs().end())
233 layoutfont.realize(tp->layout()->font);
237 layoutfont.realize(defaultfont_);
239 // Now, reduce font against full layout font
240 font.reduce(layoutfont);
242 pit->setFont(pos, font);
246 // removes the row and reset the touched counters
247 void LyXText::removeRow(RowList::iterator rit)
249 if (anchor_row_ == rit) {
250 if (rit != rows().begin()) {
251 anchor_row_ = boost::prior(rit);
252 anchor_row_offset_ += anchor_row_->height();
254 anchor_row_ = boost::next(rit);
255 anchor_row_offset_ -= rit->height();
259 // the text becomes smaller
260 height -= rit->height();
266 // remove all following rows of the paragraph of the specified row.
267 void LyXText::removeParagraph(RowList::iterator rit)
269 ParagraphList::iterator tmppit = rit->par();
272 while (rit != rows().end() && rit->par() == tmppit) {
273 RowList::iterator tmprit = boost::next(rit);
280 void LyXText::insertParagraph(ParagraphList::iterator pit,
281 RowList::iterator rit)
283 // insert a new row, starting at position 0
284 rit = rowlist_.insert(rit, Row(pit, 0));
286 // and now append the whole paragraph before the new row
287 appendParagraph(rit);
291 InsetOld * LyXText::getInset() const
293 ParagraphList::iterator pit = cursor.par();
294 pos_type const pos = cursor.pos();
296 if (pos < pit->size() && pit->isInset(pos)) {
297 return pit->getInset(pos);
303 void LyXText::toggleInset()
305 InsetOld * inset = getInset();
306 // is there an editable inset at cursor position?
307 if (!isEditableInset(inset)) {
308 // No, try to see if we are inside a collapsable inset
309 if (inset_owner && inset_owner->owner()
310 && inset_owner->owner()->isOpen()) {
311 bv()->unlockInset(inset_owner->owner());
312 inset_owner->owner()->close(bv());
313 bv()->getLyXText()->cursorRight(bv());
317 //bv()->owner()->message(inset->editMessage());
319 // do we want to keep this?? (JMarc)
320 if (!isHighlyEditableInset(inset))
321 recordUndo(bv(), Undo::ATOMIC);
323 if (inset->isOpen()) {
329 bv()->updateInset(inset);
333 /* used in setlayout */
334 // Asger is not sure we want to do this...
335 void LyXText::makeFontEntriesLayoutSpecific(BufferParams const & params,
338 LyXLayout_ptr const & layout = par.layout();
339 pos_type const psize = par.size();
342 for (pos_type pos = 0; pos < psize; ++pos) {
343 if (pos < par.beginningOfBody())
344 layoutfont = layout->labelfont;
346 layoutfont = layout->font;
348 LyXFont tmpfont = par.getFontSettings(params, pos);
349 tmpfont.reduce(layoutfont);
350 par.setFont(pos, tmpfont);
355 ParagraphList::iterator
356 LyXText::setLayout(LyXCursor & cur, LyXCursor & sstart_cur,
357 LyXCursor & send_cur,
358 string const & layout)
360 ParagraphList::iterator endpit = boost::next(send_cur.par());
361 ParagraphList::iterator undoendpit = endpit;
362 ParagraphList::iterator pars_end = ownerParagraphs().end();
364 if (endpit != pars_end && endpit->getDepth()) {
365 while (endpit != pars_end && endpit->getDepth()) {
369 } else if (endpit != pars_end) {
370 // because of parindents etc.
374 recordUndo(bv(), Undo::ATOMIC, sstart_cur.par(), boost::prior(undoendpit));
376 // ok we have a selection. This is always between sstart_cur
377 // and sel_end cursor
379 ParagraphList::iterator pit = sstart_cur.par();
380 ParagraphList::iterator epit = boost::next(send_cur.par());
382 LyXLayout_ptr const & lyxlayout =
383 bv()->buffer()->params.getLyXTextClass()[layout];
386 pit->applyLayout(lyxlayout);
387 makeFontEntriesLayoutSpecific(bv()->buffer()->params, *pit);
388 ParagraphList::iterator fppit = pit;
389 fppit->params().spaceTop(lyxlayout->fill_top ?
390 VSpace(VSpace::VFILL)
391 : VSpace(VSpace::NONE));
392 fppit->params().spaceBottom(lyxlayout->fill_bottom ?
393 VSpace(VSpace::VFILL)
394 : VSpace(VSpace::NONE));
395 if (lyxlayout->margintype == MARGIN_MANUAL)
396 pit->setLabelWidthString(lyxlayout->labelstring());
399 } while (pit != epit);
405 // set layout over selection and make a total rebreak of those paragraphs
406 void LyXText::setLayout(string const & layout)
408 LyXCursor tmpcursor = cursor; // store the current cursor
410 // if there is no selection just set the layout
411 // of the current paragraph
412 if (!selection.set()) {
413 selection.start = cursor; // dummy selection
414 selection.end = cursor;
417 // special handling of new environment insets
418 BufferParams const & params = bv()->buffer()->params;
419 LyXLayout_ptr const & lyxlayout = params.getLyXTextClass()[layout];
420 if (lyxlayout->is_environment) {
421 // move everything in a new environment inset
422 lyxerr << "setting layout " << layout << endl;
423 bv()->owner()->dispatch(FuncRequest(LFUN_HOME));
424 bv()->owner()->dispatch(FuncRequest(LFUN_ENDSEL));
425 bv()->owner()->dispatch(FuncRequest(LFUN_CUT));
426 InsetOld * inset = new InsetEnvironment(params, layout);
427 if (bv()->insertInset(inset)) {
429 //bv()->owner()->dispatch(FuncRequest(LFUN_PASTE));
436 ParagraphList::iterator endpit = setLayout(cursor, selection.start,
437 selection.end, layout);
438 redoParagraphs(selection.start.par(), endpit);
440 // we have to reset the selection, because the
441 // geometry could have changed
442 setCursor(selection.start.par(), selection.start.pos(), false);
443 selection.cursor = cursor;
444 setCursor(selection.end.par(), selection.end.pos(), false);
448 setCursor(tmpcursor.par(), tmpcursor.pos(), true);
452 bool LyXText::changeDepth(bv_funcs::DEPTH_CHANGE type, bool test_only)
454 ParagraphList::iterator pit(cursor.par());
455 ParagraphList::iterator end(cursor.par());
456 ParagraphList::iterator start = pit;
458 if (selection.set()) {
459 pit = selection.start.par();
460 end = selection.end.par();
464 ParagraphList::iterator pastend = boost::next(end);
467 recordUndo(bv(), Undo::ATOMIC, start, end);
469 bool changed = false;
471 int prev_after_depth = 0;
472 #warning parlist ... could be nicer ?
473 if (start != ownerParagraphs().begin()) {
474 prev_after_depth = boost::prior(start)->getMaxDepthAfter();
478 int const depth = pit->params().depth();
479 if (type == bv_funcs::INC_DEPTH) {
480 if (depth < prev_after_depth
481 && pit->layout()->labeltype != LABEL_BIBLIO) {
484 pit->params().depth(depth + 1);
491 pit->params().depth(depth - 1);
494 prev_after_depth = pit->getMaxDepthAfter();
507 redoParagraphs(start, pastend);
509 // We need to actually move the text->cursor. I don't
510 // understand why ...
511 LyXCursor tmpcursor = cursor;
513 // we have to reset the visual selection because the
514 // geometry could have changed
515 if (selection.set()) {
516 setCursor(selection.start.par(), selection.start.pos());
517 selection.cursor = cursor;
518 setCursor(selection.end.par(), selection.end.pos());
521 // this handles the counter labels, and also fixes up
522 // depth values for follow-on (child) paragraphs
526 setCursor(tmpcursor.par(), tmpcursor.pos());
532 // set font over selection and make a total rebreak of those paragraphs
533 void LyXText::setFont(LyXFont const & font, bool toggleall)
535 // if there is no selection just set the current_font
536 if (!selection.set()) {
537 // Determine basis font
539 if (cursor.pos() < cursor.par()->beginningOfBody()) {
540 layoutfont = getLabelFont(cursor.par());
542 layoutfont = getLayoutFont(cursor.par());
544 // Update current font
545 real_current_font.update(font,
546 bv()->buffer()->params.language,
549 // Reduce to implicit settings
550 current_font = real_current_font;
551 current_font.reduce(layoutfont);
552 // And resolve it completely
553 real_current_font.realize(layoutfont);
558 LyXCursor tmpcursor = cursor; // store the current cursor
560 // ok we have a selection. This is always between sel_start_cursor
561 // and sel_end cursor
563 recordUndo(bv(), Undo::ATOMIC, selection.start.par(), selection.end.par());
565 cursor = selection.start;
566 while (cursor.par() != selection.end.par() ||
567 cursor.pos() < selection.end.pos())
569 if (cursor.pos() < cursor.par()->size()) {
570 // an open footnote should behave like a closed one
571 setCharFont(cursor.par(), cursor.pos(),
573 cursor.pos(cursor.pos() + 1);
576 cursor.par(boost::next(cursor.par()));
581 redoParagraph(selection.start.par());
583 // we have to reset the selection, because the
584 // geometry could have changed, but we keep
585 // it for user convenience
586 setCursor(selection.start.par(), selection.start.pos());
587 selection.cursor = cursor;
588 setCursor(selection.end.par(), selection.end.pos());
590 setCursor(tmpcursor.par(), tmpcursor.pos(), true,
591 tmpcursor.boundary());
595 void LyXText::redoHeightOfParagraph()
597 RowList::iterator tmprow = cursorRow();
599 setHeightOfRow(tmprow);
601 while (tmprow != rows().begin()
602 && boost::prior(tmprow)->par() == tmprow->par()) {
604 setHeightOfRow(tmprow);
607 setCursor(cursor.par(), cursor.pos(), false, cursor.boundary());
611 RowList::iterator LyXText::firstRow(ParagraphList::iterator pit)
613 RowList::iterator rit;
614 for (rit = rows().begin(); rit != rows().end(); ++rit)
615 if (rit->par() == pit)
621 // rebreaks all paragraphs between the specified pars
622 // This function is needed after SetLayout and SetFont etc.
623 void LyXText::redoParagraphs(ParagraphList::iterator start,
624 ParagraphList::iterator end)
626 for ( ; start != end; ++start)
627 redoParagraph(start);
631 void LyXText::redoParagraph(ParagraphList::iterator pit)
633 RowList::iterator rit = firstRow(pit);
635 // remove paragraph from rowlist
636 while (rit != rows().end() && rit->par() == pit) {
637 RowList::iterator rit2 = rit++;
641 // reinsert the paragraph
642 // insert a new row, starting at position 0
644 rit = rowlist_.insert(rit, newrow);
645 //newrow.dump("newrow: ");
647 // and now append the whole paragraph before the new row
648 pos_type const last = rit->par()->size();
652 pos_type z = rowBreakPoint(*rit);
654 RowList::iterator tmprow = rit;
655 //tmprow->dump("tmprow: ");
659 Row newrow(rit->par(), z);
660 //newrow.dump("newrow2: ");
661 rit = rowlist_.insert(boost::next(rit), newrow);
666 // Set the dimensions of the row
667 // fixed fill setting now by calling inset->update() in
668 // SingleWidth when needed!
669 //tmprow->dump("tmprow 1: ");
670 tmprow->fill(fill(tmprow, workWidth()));
671 //tmprow->dump("tmprow 2: ");
672 setHeightOfRow(tmprow);
673 //tmprow->dump("tmprow 3: ");
674 height += rit->height();
678 setHeightOfRow(rows().begin());
682 void LyXText::fullRebreak()
684 lyxerr << "fullRebreak" << endl;
685 redoParagraphs(ownerParagraphs().begin(), ownerParagraphs().end());
686 setCursorIntern(cursor.par(), cursor.pos());
687 selection.cursor = cursor;
691 void LyXText::metrics(MetricsInfo & mi, Dimension & dim)
693 //lyxerr << "LyXText::metrics: width: " << mi.base.textwidth << endl;
694 //Assert(mi.base.textwidth);
700 anchor_row_ = rows().end();
701 anchor_row_offset_ = 0;
703 ParagraphList::iterator pit = ownerParagraphs().begin();
704 ParagraphList::iterator end = ownerParagraphs().end();
706 for (; pit != end; ++pit) {
707 InsetList::iterator ii = pit->insetlist.begin();
708 InsetList::iterator iend = pit->insetlist.end();
709 for (; ii != iend; ++ii) {
712 #warning FIXME: pos != 0
713 m.base.font = getFont(pit, 0);
714 ii->inset->metrics(m, dim);
718 // insert a new row, starting at position 0
720 RowList::iterator rit = rowlist_.insert(rowlist_.end(), newrow);
722 // and now append the whole paragraph before the new row
723 appendParagraph(rit);
730 //lyxerr << "height 0: " << height << endl;
731 //for (RowList::iterator rit = rows().begin(); rit != rows().end(); ++rit) {
732 // height += rit->height();
734 //lyxerr << "height 1: " << height << endl;
737 dim.asc = rows().begin()->ascent_of_text();
738 dim.des = height - dim.asc;
739 dim.wid = std::max(mi.base.textwidth, int(width));
743 void LyXText::partialRebreak()
745 if (rows().empty()) {
749 breakAgain(rows().begin());
753 // important for the screen
756 // the cursor set functions have a special mechanism. When they
757 // realize, that you left an empty paragraph, they will delete it.
758 // They also delete the corresponding row
760 // need the selection cursor:
761 void LyXText::setSelection()
763 TextCursor::setSelection();
768 void LyXText::clearSelection()
770 TextCursor::clearSelection();
772 // reset this in the bv_owner!
773 if (bv_owner && bv_owner->text)
774 bv_owner->text->xsel_cache.set(false);
778 void LyXText::cursorHome()
780 setCursor(cursor.par(), cursorRow()->pos());
784 void LyXText::cursorEnd()
786 if (cursor.par()->empty())
789 RowList::iterator rit = cursorRow();
790 RowList::iterator next_rit = boost::next(rit);
791 ParagraphList::iterator pit = rit->par();
792 pos_type last_pos = lastPos(*this, rit);
794 if (next_rit == rows().end() || next_rit->par() != pit) {
798 (pit->getChar(last_pos) != ' ' && !pit->isNewline(last_pos))) {
803 setCursor(pit, last_pos);
807 void LyXText::cursorTop()
809 setCursor(ownerParagraphs().begin(), 0);
813 void LyXText::cursorBottom()
815 ParagraphList::iterator lastpit =
816 boost::prior(ownerParagraphs().end());
817 setCursor(lastpit, lastpit->size());
821 void LyXText::toggleFree(LyXFont const & font, bool toggleall)
823 // If the mask is completely neutral, tell user
824 if (font == LyXFont(LyXFont::ALL_IGNORE)) {
825 // Could only happen with user style
826 bv()->owner()->message(_("No font change defined. Use Character under the Layout menu to define font change."));
830 // Try implicit word selection
831 // If there is a change in the language the implicit word selection
833 LyXCursor resetCursor = cursor;
834 bool implicitSelection = (font.language() == ignore_language
835 && font.number() == LyXFont::IGNORE)
836 ? selectWordWhenUnderCursor(lyx::WHOLE_WORD_STRICT) : false;
839 setFont(font, toggleall);
841 // Implicit selections are cleared afterwards
842 //and cursor is set to the original position.
843 if (implicitSelection) {
845 cursor = resetCursor;
846 setCursor(cursor.par(), cursor.pos());
847 selection.cursor = cursor;
852 string LyXText::getStringToIndex()
854 // Try implicit word selection
855 // If there is a change in the language the implicit word selection
857 LyXCursor const reset_cursor = cursor;
858 bool const implicitSelection =
859 selectWordWhenUnderCursor(lyx::PREVIOUS_WORD);
862 if (!selection.set())
863 bv()->owner()->message(_("Nothing to index!"));
864 else if (selection.start.par() != selection.end.par())
865 bv()->owner()->message(_("Cannot index more than one paragraph!"));
867 idxstring = selectionAsString(bv()->buffer(), false);
869 // Reset cursors to their original position.
870 cursor = reset_cursor;
871 setCursor(cursor.par(), cursor.pos());
872 selection.cursor = cursor;
874 // Clear the implicit selection.
875 if (implicitSelection)
882 // the DTP switches for paragraphs. LyX will store them in the first
883 // physicla paragraph. When a paragraph is broken, the top settings rest,
884 // the bottom settings are given to the new one. So I can make shure,
885 // they do not duplicate themself and you cannnot make dirty things with
888 void LyXText::setParagraph(bool line_top, bool line_bottom,
889 bool pagebreak_top, bool pagebreak_bottom,
890 VSpace const & space_top,
891 VSpace const & space_bottom,
892 Spacing const & spacing,
894 string const & labelwidthstring,
897 LyXCursor tmpcursor = cursor;
898 if (!selection.set()) {
899 selection.start = cursor;
900 selection.end = cursor;
903 // make sure that the depth behind the selection are restored, too
904 ParagraphList::iterator endpit = boost::next(selection.end.par());
905 ParagraphList::iterator undoendpit = endpit;
906 ParagraphList::iterator pars_end = ownerParagraphs().end();
908 if (endpit != pars_end && endpit->getDepth()) {
909 while (endpit != pars_end && endpit->getDepth()) {
913 } else if (endpit != pars_end) {
914 // because of parindents etc.
918 recordUndo(bv(), Undo::ATOMIC, selection.start.par(),
919 boost::prior(undoendpit));
922 ParagraphList::iterator tmppit = selection.end.par();
924 while (tmppit != boost::prior(selection.start.par())) {
925 setCursor(tmppit, 0);
927 ParagraphList::iterator pit = cursor.par();
928 ParagraphParameters & params = pit->params();
930 params.lineTop(line_top);
931 params.lineBottom(line_bottom);
932 params.pagebreakTop(pagebreak_top);
933 params.pagebreakBottom(pagebreak_bottom);
934 params.spaceTop(space_top);
935 params.spaceBottom(space_bottom);
936 params.spacing(spacing);
937 // does the layout allow the new alignment?
938 LyXLayout_ptr const & layout = pit->layout();
940 if (align == LYX_ALIGN_LAYOUT)
941 align = layout->align;
942 if (align & layout->alignpossible) {
943 if (align == layout->align)
944 params.align(LYX_ALIGN_LAYOUT);
948 pit->setLabelWidthString(labelwidthstring);
949 params.noindent(noindent);
950 tmppit = boost::prior(pit);
953 redoParagraphs(selection.start.par(), endpit);
956 setCursor(selection.start.par(), selection.start.pos());
957 selection.cursor = cursor;
958 setCursor(selection.end.par(), selection.end.pos());
960 setCursor(tmpcursor.par(), tmpcursor.pos());
962 bv()->updateInset(inset_owner);
966 // set the counter of a paragraph. This includes the labels
967 void LyXText::setCounter(Buffer const * buf, ParagraphList::iterator pit)
969 LyXTextClass const & textclass = buf->params.getLyXTextClass();
970 LyXLayout_ptr const & layout = pit->layout();
972 if (pit != ownerParagraphs().begin()) {
974 pit->params().appendix(boost::prior(pit)->params().appendix());
975 if (!pit->params().appendix() &&
976 pit->params().startOfAppendix()) {
977 pit->params().appendix(true);
978 textclass.counters().reset();
980 pit->enumdepth = boost::prior(pit)->enumdepth;
981 pit->itemdepth = boost::prior(pit)->itemdepth;
983 pit->params().appendix(pit->params().startOfAppendix());
988 /* Maybe we have to increment the enumeration depth.
989 * BUT, enumeration in a footnote is considered in isolation from its
990 * surrounding paragraph so don't increment if this is the
991 * first line of the footnote
992 * AND, bibliographies can't have their depth changed ie. they
993 * are always of depth 0
995 if (pit != ownerParagraphs().begin()
996 && boost::prior(pit)->getDepth() < pit->getDepth()
997 && boost::prior(pit)->layout()->labeltype == LABEL_COUNTER_ENUMI
998 && pit->enumdepth < 3
999 && layout->labeltype != LABEL_BIBLIO) {
1003 // Maybe we have to decrement the enumeration depth, see note above
1004 if (pit != ownerParagraphs().begin()
1005 && boost::prior(pit)->getDepth() > pit->getDepth()
1006 && layout->labeltype != LABEL_BIBLIO) {
1007 pit->enumdepth = depthHook(pit, ownerParagraphs(),
1008 pit->getDepth())->enumdepth;
1011 if (!pit->params().labelString().empty()) {
1012 pit->params().labelString(string());
1015 if (layout->margintype == MARGIN_MANUAL) {
1016 if (pit->params().labelWidthString().empty()) {
1017 pit->setLabelWidthString(layout->labelstring());
1020 pit->setLabelWidthString(string());
1023 // is it a layout that has an automatic label?
1024 if (layout->labeltype >= LABEL_COUNTER_CHAPTER) {
1025 int const i = layout->labeltype - LABEL_COUNTER_CHAPTER;
1029 if (i >= 0 && i <= buf->params.secnumdepth) {
1033 textclass.counters().step(layout->latexname());
1035 // Is there a label? Useful for Chapter layout
1036 if (!pit->params().appendix()) {
1037 s << buf->B_(layout->labelstring());
1039 s << buf->B_(layout->labelstring_appendix());
1042 // Use of an integer is here less than elegant. For now.
1043 int head = textclass.maxcounter() - LABEL_COUNTER_CHAPTER;
1044 if (!pit->params().appendix()) {
1045 numbertype = "sectioning";
1047 numbertype = "appendix";
1048 if (pit->isRightToLeftPar(buf->params))
1049 langtype = "hebrew";
1055 << textclass.counters()
1056 .numberLabel(layout->latexname(),
1057 numbertype, langtype, head);
1059 pit->params().labelString(STRCONV(s.str()));
1061 // reset enum counters
1062 textclass.counters().reset("enum");
1063 } else if (layout->labeltype < LABEL_COUNTER_ENUMI) {
1064 textclass.counters().reset("enum");
1065 } else if (layout->labeltype == LABEL_COUNTER_ENUMI) {
1067 // Yes I know this is a really, really! bad solution
1069 string enumcounter("enum");
1071 switch (pit->enumdepth) {
1080 enumcounter += "iv";
1083 // not a valid enumdepth...
1087 textclass.counters().step(enumcounter);
1089 s << textclass.counters()
1090 .numberLabel(enumcounter, "enumeration");
1091 pit->params().labelString(STRCONV(s.str()));
1093 } else if (layout->labeltype == LABEL_BIBLIO) {// ale970302
1094 textclass.counters().step("bibitem");
1095 int number = textclass.counters().value("bibitem");
1096 if (pit->bibitem()) {
1097 pit->bibitem()->setCounter(number);
1098 pit->params().labelString(layout->labelstring());
1100 // In biblio should't be following counters but...
1102 string s = buf->B_(layout->labelstring());
1104 // the caption hack:
1105 if (layout->labeltype == LABEL_SENSITIVE) {
1106 ParagraphList::iterator end = ownerParagraphs().end();
1107 ParagraphList::iterator tmppit = pit;
1110 while (tmppit != end && tmppit->inInset()
1111 // the single '=' is intended below
1112 && (in = tmppit->inInset()->owner()))
1114 if (in->lyxCode() == InsetOld::FLOAT_CODE ||
1115 in->lyxCode() == InsetOld::WRAP_CODE) {
1119 tmppit = ownerParagraphs().begin();
1120 for ( ; tmppit != end; ++tmppit)
1121 if (&*tmppit == in->parOwner())
1129 if (in->lyxCode() == InsetOld::FLOAT_CODE)
1130 type = static_cast<InsetFloat*>(in)->params().type;
1131 else if (in->lyxCode() == InsetOld::WRAP_CODE)
1132 type = static_cast<InsetWrap*>(in)->params().type;
1136 Floating const & fl = textclass.floats().getType(type);
1138 textclass.counters().step(fl.type());
1140 // Doesn't work... yet.
1141 s = bformat(_("%1$s #:"), buf->B_(fl.name()));
1143 // par->SetLayout(0);
1144 // s = layout->labelstring;
1145 s = _("Senseless: ");
1148 pit->params().labelString(s);
1150 // reset the enumeration counter. They are always reset
1151 // when there is any other layout between
1152 // Just fall-through between the cases so that all
1153 // enum counters deeper than enumdepth is also reset.
1154 switch (pit->enumdepth) {
1156 textclass.counters().reset("enumi");
1158 textclass.counters().reset("enumii");
1160 textclass.counters().reset("enumiii");
1162 textclass.counters().reset("enumiv");
1168 // Updates all counters. Paragraphs with changed label string will be rebroken
1169 void LyXText::updateCounters()
1171 RowList::iterator rowit = rows().begin();
1172 ParagraphList::iterator pit = rowit->par();
1174 // CHECK if this is really needed. (Lgb)
1175 bv()->buffer()->params.getLyXTextClass().counters().reset();
1177 ParagraphList::iterator beg = ownerParagraphs().begin();
1178 ParagraphList::iterator end = ownerParagraphs().end();
1179 for (; pit != end; ++pit) {
1180 while (rowit->par() != pit)
1183 string const oldLabel = pit->params().labelString();
1185 size_t maxdepth = 0;
1187 maxdepth = boost::prior(pit)->getMaxDepthAfter();
1189 if (pit->params().depth() > maxdepth)
1190 pit->params().depth(maxdepth);
1192 // setCounter can potentially change the labelString.
1193 setCounter(bv()->buffer(), pit);
1195 string const & newLabel = pit->params().labelString();
1197 if (oldLabel.empty() && !newLabel.empty()) {
1198 removeParagraph(rowit);
1199 appendParagraph(rowit);
1205 void LyXText::insertInset(InsetOld * inset)
1207 if (!cursor.par()->insetAllowed(inset->lyxCode()))
1209 recordUndo(bv(), Undo::ATOMIC, cursor.par());
1211 cursor.par()->insertInset(cursor.pos(), inset);
1212 // Just to rebreak and refresh correctly.
1213 // The character will not be inserted a second time
1214 insertChar(Paragraph::META_INSET);
1215 // If we enter a highly editable inset the cursor should be to before
1216 // the inset. This couldn't happen before as Undo was not handled inside
1217 // inset now after the Undo LyX tries to call inset->Edit(...) again
1218 // and cannot do this as the cursor is behind the inset and GetInset
1219 // does not return the inset!
1220 if (isHighlyEditableInset(inset)) {
1227 void LyXText::cutSelection(bool doclear, bool realcut)
1229 // Stuff what we got on the clipboard. Even if there is no selection.
1231 // There is a problem with having the stuffing here in that the
1232 // larger the selection the slower LyX will get. This can be
1233 // solved by running the line below only when the selection has
1234 // finished. The solution used currently just works, to make it
1235 // faster we need to be more clever and probably also have more
1236 // calls to stuffClipboard. (Lgb)
1237 bv()->stuffClipboard(selectionAsString(bv()->buffer(), true));
1239 // This doesn't make sense, if there is no selection
1240 if (!selection.set())
1243 // OK, we have a selection. This is always between selection.start
1244 // and selection.end
1246 // make sure that the depth behind the selection are restored, too
1247 ParagraphList::iterator endpit = boost::next(selection.end.par());
1248 ParagraphList::iterator undoendpit = endpit;
1249 ParagraphList::iterator pars_end = ownerParagraphs().end();
1251 if (endpit != pars_end && endpit->getDepth()) {
1252 while (endpit != pars_end && endpit->getDepth()) {
1254 undoendpit = endpit;
1256 } else if (endpit != pars_end) {
1257 // because of parindents etc.
1261 recordUndo(bv(), Undo::DELETE, selection.start.par(),
1262 boost::prior(undoendpit));
1265 endpit = selection.end.par();
1266 int endpos = selection.end.pos();
1268 boost::tie(endpit, endpos) = realcut ?
1269 CutAndPaste::cutSelection(bv()->buffer()->params,
1271 selection.start.par(), endpit,
1272 selection.start.pos(), endpos,
1273 bv()->buffer()->params.textclass,
1275 : CutAndPaste::eraseSelection(bv()->buffer()->params,
1277 selection.start.par(), endpit,
1278 selection.start.pos(), endpos,
1280 // sometimes necessary
1282 selection.start.par()->stripLeadingSpaces();
1284 redoParagraphs(selection.start.par(), boost::next(endpit));
1285 #warning FIXME latent bug
1286 // endpit will be invalidated on redoParagraphs once ParagraphList
1287 // becomes a std::list? There are maybe other places on which this
1288 // can happend? (Ab)
1289 // cutSelection can invalidate the cursor so we need to set
1291 // we prefer the end for when tracking changes
1295 // need a valid cursor. (Lgb)
1298 setCursor(cursor.par(), cursor.pos());
1299 selection.cursor = cursor;
1304 void LyXText::copySelection()
1306 // stuff the selection onto the X clipboard, from an explicit copy request
1307 bv()->stuffClipboard(selectionAsString(bv()->buffer(), true));
1309 // this doesnt make sense, if there is no selection
1310 if (!selection.set())
1313 // ok we have a selection. This is always between selection.start
1314 // and sel_end cursor
1316 // copy behind a space if there is one
1317 while (selection.start.par()->size() > selection.start.pos()
1318 && selection.start.par()->isLineSeparator(selection.start.pos())
1319 && (selection.start.par() != selection.end.par()
1320 || selection.start.pos() < selection.end.pos()))
1321 selection.start.pos(selection.start.pos() + 1);
1323 CutAndPaste::copySelection(selection.start.par(),
1324 selection.end.par(),
1325 selection.start.pos(), selection.end.pos(),
1326 bv()->buffer()->params.textclass);
1330 void LyXText::pasteSelection(size_t sel_index)
1332 // this does not make sense, if there is nothing to paste
1333 if (!CutAndPaste::checkPastePossible())
1336 recordUndo(bv(), Undo::INSERT, cursor.par());
1338 ParagraphList::iterator endpit;
1343 boost::tie(ppp, endpit) =
1344 CutAndPaste::pasteSelection(*bv()->buffer(),
1346 cursor.par(), cursor.pos(),
1347 bv()->buffer()->params.textclass,
1349 bufferErrors(*bv()->buffer(), el);
1350 bv()->showErrorList(_("Paste"));
1352 redoParagraphs(cursor.par(), endpit);
1354 setCursor(cursor.par(), cursor.pos());
1357 selection.cursor = cursor;
1358 setCursor(ppp.first, ppp.second);
1364 void LyXText::setSelectionRange(lyx::pos_type length)
1369 selection.cursor = cursor;
1376 // simple replacing. The font of the first selected character is used
1377 void LyXText::replaceSelectionWithString(string const & str)
1379 recordUndo(bv(), Undo::ATOMIC);
1382 if (!selection.set()) { // create a dummy selection
1383 selection.end = cursor;
1384 selection.start = cursor;
1387 // Get font setting before we cut
1388 pos_type pos = selection.end.pos();
1389 LyXFont const font = selection.start.par()
1390 ->getFontSettings(bv()->buffer()->params,
1391 selection.start.pos());
1393 // Insert the new string
1394 string::const_iterator cit = str.begin();
1395 string::const_iterator end = str.end();
1396 for (; cit != end; ++cit) {
1397 selection.end.par()->insertChar(pos, (*cit), font);
1401 // Cut the selection
1402 cutSelection(true, false);
1408 // needed to insert the selection
1409 void LyXText::insertStringAsLines(string const & str)
1411 ParagraphList::iterator pit = cursor.par();
1412 pos_type pos = cursor.pos();
1413 ParagraphList::iterator endpit = boost::next(cursor.par());
1415 recordUndo(bv(), Undo::ATOMIC);
1417 // only to be sure, should not be neccessary
1420 bv()->buffer()->insertStringAsLines(pit, pos, current_font, str);
1422 redoParagraphs(cursor.par(), endpit);
1423 setCursor(cursor.par(), cursor.pos());
1424 selection.cursor = cursor;
1425 setCursor(pit, pos);
1430 // turns double-CR to single CR, others where converted into one
1431 // blank. Then InsertStringAsLines is called
1432 void LyXText::insertStringAsParagraphs(string const & str)
1434 string linestr(str);
1435 bool newline_inserted = false;
1436 string::size_type const siz = linestr.length();
1438 for (string::size_type i = 0; i < siz; ++i) {
1439 if (linestr[i] == '\n') {
1440 if (newline_inserted) {
1441 // we know that \r will be ignored by
1442 // InsertStringA. Of course, it is a dirty
1443 // trick, but it works...
1444 linestr[i - 1] = '\r';
1448 newline_inserted = true;
1450 } else if (IsPrintable(linestr[i])) {
1451 newline_inserted = false;
1454 insertStringAsLines(linestr);
1458 void LyXText::checkParagraph(ParagraphList::iterator pit, pos_type pos)
1460 breakAgain(getRow(pit, pos));
1461 setCursorIntern(cursor.par(), cursor.pos(), false, cursor.boundary());
1465 // returns false if inset wasn't found
1466 bool LyXText::updateInset(InsetOld * inset)
1468 // first check the current paragraph
1469 int pos = cursor.par()->getPositionOfInset(inset);
1471 checkParagraph(cursor.par(), pos);
1475 // check every paragraph
1476 ParagraphList::iterator par = ownerParagraphs().begin();
1477 ParagraphList::iterator end = ownerParagraphs().end();
1478 for (; par != end; ++par) {
1479 pos = par->getPositionOfInset(inset);
1481 checkParagraph(par, pos);
1490 bool LyXText::setCursor(ParagraphList::iterator pit,
1492 bool setfont, bool boundary)
1494 LyXCursor old_cursor = cursor;
1495 setCursorIntern(pit, pos, setfont, boundary);
1496 return deleteEmptyParagraphMechanism(old_cursor);
1500 void LyXText::setCursor(LyXCursor & cur, ParagraphList::iterator pit,
1501 pos_type pos, bool boundary)
1503 Assert(pit != ownerParagraphs().end());
1507 cur.boundary(boundary);
1511 // get the cursor y position in text
1513 RowList::iterator row = getRow(pit, pos, y);
1514 RowList::iterator beg = rows().begin();
1516 RowList::iterator old_row = row;
1517 // if we are before the first char of this row and are still in the
1518 // same paragraph and there is a previous row then put the cursor on
1519 // the end of the previous row
1520 cur.iy(y + row->baseline());
1523 boost::prior(row)->par() == row->par() &&
1524 pos < pit->size() &&
1525 pit->getChar(pos) == Paragraph::META_INSET) {
1526 InsetOld * ins = pit->getInset(pos);
1527 if (ins && (ins->needFullRow() || ins->display())) {
1533 // y is now the beginning of the cursor row
1534 y += row->baseline();
1535 // y is now the cursor baseline
1538 pos_type last = lastPrintablePos(*this, old_row);
1540 // None of these should happen, but we're scaredy-cats
1541 if (pos > pit->size()) {
1542 lyxerr << "dont like 1 please report" << endl;
1545 } else if (pos > last + 1) {
1546 lyxerr << "dont like 2 please report" << endl;
1547 // This shouldn't happen.
1550 } else if (pos < row->pos()) {
1551 lyxerr << "dont like 3 please report" << endl;
1556 // now get the cursors x position
1557 float x = getCursorX(row, pos, last, boundary);
1560 if (old_row != row) {
1561 x = getCursorX(old_row, pos, last, boundary);
1565 /* We take out this for the time being because 1) the redraw code is not
1566 prepared to this yet and 2) because some good policy has yet to be decided
1567 while editting: for instance how to act on rows being created/deleted
1571 //if the cursor is in a visible row, anchor to it
1573 if (topy < y && y < topy + bv()->workHeight())
1579 float LyXText::getCursorX(RowList::iterator rit,
1580 pos_type pos, pos_type last, bool boundary) const
1582 pos_type cursor_vpos = 0;
1584 double fill_separator;
1586 double fill_label_hfill;
1587 // This call HAS to be here because of the BidiTables!!!
1588 prepareToPrint(rit, x, fill_separator, fill_hfill,
1591 ParagraphList::iterator rit_par = rit->par();
1592 pos_type const rit_pos = rit->pos();
1595 cursor_vpos = rit_pos;
1596 else if (pos > last && !boundary)
1597 cursor_vpos = (rit_par->isRightToLeftPar(bv()->buffer()->params))
1598 ? rit_pos : last + 1;
1599 else if (pos > rit_pos && (pos > last || boundary))
1600 /// Place cursor after char at (logical) position pos - 1
1601 cursor_vpos = (bidi_level(pos - 1) % 2 == 0)
1602 ? log2vis(pos - 1) + 1 : log2vis(pos - 1);
1604 /// Place cursor before char at (logical) position pos
1605 cursor_vpos = (bidi_level(pos) % 2 == 0)
1606 ? log2vis(pos) : log2vis(pos) + 1;
1608 pos_type body_pos = rit_par->beginningOfBody();
1610 (body_pos - 1 > last || !rit_par->isLineSeparator(body_pos - 1)))
1613 for (pos_type vpos = rit_pos; vpos < cursor_vpos; ++vpos) {
1614 pos_type pos = vis2log(vpos);
1615 if (body_pos > 0 && pos == body_pos - 1) {
1616 x += fill_label_hfill +
1617 font_metrics::width(
1618 rit_par->layout()->labelsep, getLabelFont(rit_par));
1619 if (rit_par->isLineSeparator(body_pos - 1))
1620 x -= singleWidth(rit_par, body_pos - 1);
1623 if (hfillExpansion(*this, rit, pos)) {
1624 x += singleWidth(rit_par, pos);
1625 if (pos >= body_pos)
1628 x += fill_label_hfill;
1629 } else if (rit_par->isSeparator(pos)) {
1630 x += singleWidth(rit_par, pos);
1631 if (pos >= body_pos)
1632 x += fill_separator;
1634 x += singleWidth(rit_par, pos);
1640 void LyXText::setCursorIntern(ParagraphList::iterator pit,
1641 pos_type pos, bool setfont, bool boundary)
1643 UpdatableInset * it = pit->inInset();
1645 if (it != inset_owner) {
1646 lyxerr[Debug::INSETS] << "InsetText is " << it
1648 << "inset_owner is "
1649 << inset_owner << endl;
1650 #ifdef WITH_WARNINGS
1651 #warning I believe this code is wrong. (Lgb)
1652 #warning Jürgen, have a look at this. (Lgb)
1653 #warning Hmmm, I guess you are right but we
1654 #warning should verify when this is needed
1656 // Jürgen, would you like to have a look?
1657 // I guess we need to move the outer cursor
1658 // and open and lock the inset (bla bla bla)
1659 // stuff I don't know... so can you have a look?
1661 // I moved the lyxerr stuff in here so we can see if
1662 // this is actually really needed and where!
1664 // it->getLyXText(bv())->setCursorIntern(bv(), par, pos, setfont, boundary);
1669 setCursor(cursor, pit, pos, boundary);
1675 void LyXText::setCurrentFont()
1677 pos_type pos = cursor.pos();
1678 ParagraphList::iterator pit = cursor.par();
1680 if (cursor.boundary() && pos > 0)
1684 if (pos == pit->size())
1686 else // potentional bug... BUG (Lgb)
1687 if (pit->isSeparator(pos)) {
1688 if (pos > cursorRow()->pos() &&
1689 bidi_level(pos) % 2 ==
1690 bidi_level(pos - 1) % 2)
1692 else if (pos + 1 < pit->size())
1697 current_font = pit->getFontSettings(bv()->buffer()->params, pos);
1698 real_current_font = getFont(pit, pos);
1700 if (cursor.pos() == pit->size() &&
1701 isBoundary(bv()->buffer(), *pit, cursor.pos()) &&
1702 !cursor.boundary()) {
1703 Language const * lang =
1704 pit->getParLanguage(bv()->buffer()->params);
1705 current_font.setLanguage(lang);
1706 current_font.setNumber(LyXFont::OFF);
1707 real_current_font.setLanguage(lang);
1708 real_current_font.setNumber(LyXFont::OFF);
1713 // returns the column near the specified x-coordinate of the row
1714 // x is set to the real beginning of this column
1716 LyXText::getColumnNearX(RowList::iterator rit, int & x, bool & boundary) const
1719 double fill_separator;
1721 double fill_label_hfill;
1723 prepareToPrint(rit, tmpx, fill_separator, fill_hfill, fill_label_hfill);
1725 pos_type vc = rit->pos();
1726 pos_type last = lastPrintablePos(*this, rit);
1729 ParagraphList::iterator rit_par = rit->par();
1730 LyXLayout_ptr const & layout = rit->par()->layout();
1732 bool left_side = false;
1734 pos_type body_pos = rit_par->beginningOfBody();
1735 double last_tmpx = tmpx;
1738 (body_pos - 1 > last ||
1739 !rit_par->isLineSeparator(body_pos - 1)))
1742 // check for empty row
1743 if (!rit_par->size()) {
1748 while (vc <= last && tmpx <= x) {
1751 if (body_pos > 0 && c == body_pos - 1) {
1752 tmpx += fill_label_hfill +
1753 font_metrics::width(layout->labelsep, getLabelFont(rit_par));
1754 if (rit_par->isLineSeparator(body_pos - 1))
1755 tmpx -= singleWidth(rit_par, body_pos - 1);
1758 if (hfillExpansion(*this, rit, c)) {
1759 tmpx += singleWidth(rit_par, c);
1763 tmpx += fill_label_hfill;
1764 } else if (rit_par->isSeparator(c)) {
1765 tmpx += singleWidth(rit_par, c);
1767 tmpx += fill_separator;
1769 tmpx += singleWidth(rit_par, c);
1774 if ((tmpx + last_tmpx) / 2 > x) {
1779 if (vc > last + 1) // This shouldn't happen.
1783 // This (rtl_support test) is not needed, but gives
1784 // some speedup if rtl_support=false
1785 RowList::iterator next_rit = boost::next(rit);
1787 bool const lastrow = lyxrc.rtl_support &&
1788 (next_rit == rowlist_.end() ||
1789 next_rit->par() != rit_par);
1791 // If lastrow is false, we don't need to compute
1792 // the value of rtl.
1793 bool const rtl = (lastrow)
1794 ? rit_par->isRightToLeftPar(bv()->buffer()->params)
1797 ((rtl && left_side && vc == rit->pos() && x < tmpx - 5) ||
1798 (!rtl && !left_side && vc == last + 1 && x > tmpx + 5)))
1800 else if (vc == rit->pos()) {
1802 if (bidi_level(c) % 2 == 1)
1805 c = vis2log(vc - 1);
1806 bool const rtl = (bidi_level(c) % 2 == 1);
1807 if (left_side == rtl) {
1809 boundary = isBoundary(bv()->buffer(), *rit_par, c);
1813 if (rit->pos() <= last && c > last
1814 && rit_par->isNewline(last)) {
1815 if (bidi_level(last) % 2 == 0)
1816 tmpx -= singleWidth(rit_par, last);
1818 tmpx += singleWidth(rit_par, last);
1828 void LyXText::setCursorFromCoordinates(int x, int y)
1830 //LyXCursor old_cursor = cursor;
1831 setCursorFromCoordinates(cursor, x, y);
1833 #warning DEPM disabled, otherwise crash when entering new table
1834 //deleteEmptyParagraphMechanism(old_cursor);
1841 * return true if the cursor given is at the end of a row,
1842 * and the next row is filled by an inset that spans an entire
1845 bool beforeFullRowInset(LyXText & lt, LyXCursor const & cur)
1847 RowList::iterator row = lt.getRow(cur);
1848 if (boost::next(row) == lt.rows().end())
1851 Row const & next = *boost::next(row);
1853 if (next.pos() != cur.pos() || next.par() != cur.par())
1856 if (cur.pos() == cur.par()->size()
1857 || !cur.par()->isInset(cur.pos()))
1860 InsetOld const * inset = cur.par()->getInset(cur.pos());
1861 if (inset->needFullRow() || inset->display())
1869 void LyXText::setCursorFromCoordinates(LyXCursor & cur, int x, int y)
1871 // Get the row first.
1873 RowList::iterator row = getRowNearY(y);
1875 pos_type const column = getColumnNearX(row, x, bound);
1876 cur.par(row->par());
1877 cur.pos(row->pos() + column);
1879 cur.y(y + row->baseline());
1881 if (beforeFullRowInset(*this, cur)) {
1882 pos_type const last = lastPrintablePos(*this, row);
1883 RowList::iterator next_row = boost::next(row);
1885 float x = getCursorX(next_row, cur.pos(), last, bound);
1887 cur.iy(y + row->height() + next_row->baseline());
1892 cur.boundary(bound);
1896 void LyXText::cursorLeft(bool internal)
1898 if (cursor.pos() > 0) {
1899 bool boundary = cursor.boundary();
1900 setCursor(cursor.par(), cursor.pos() - 1, true, false);
1901 if (!internal && !boundary &&
1902 isBoundary(bv()->buffer(), *cursor.par(), cursor.pos() + 1))
1903 setCursor(cursor.par(), cursor.pos() + 1, true, true);
1904 } else if (cursor.par() != ownerParagraphs().begin()) {
1905 // steps into the paragraph above
1906 ParagraphList::iterator pit = boost::prior(cursor.par());
1907 setCursor(pit, pit->size());
1912 void LyXText::cursorRight(bool internal)
1914 bool const at_end = (cursor.pos() == cursor.par()->size());
1915 bool const at_newline = !at_end &&
1916 cursor.par()->isNewline(cursor.pos());
1918 if (!internal && cursor.boundary() && !at_newline)
1919 setCursor(cursor.par(), cursor.pos(), true, false);
1921 setCursor(cursor.par(), cursor.pos() + 1, true, false);
1923 isBoundary(bv()->buffer(), *cursor.par(), cursor.pos()))
1924 setCursor(cursor.par(), cursor.pos(), true, true);
1925 } else if (boost::next(cursor.par()) != ownerParagraphs().end())
1926 setCursor(boost::next(cursor.par()), 0);
1930 void LyXText::cursorUp(bool selecting)
1933 int x = cursor.x_fix();
1934 int y = cursor.y() - cursorRow()->baseline() - 1;
1935 setCursorFromCoordinates(x, y);
1938 int y1 = cursor.iy() - topy;
1941 InsetOld * inset_hit = checkInsetHit(x, y1);
1942 if (inset_hit && isHighlyEditableInset(inset_hit)) {
1943 inset_hit->localDispatch(
1944 FuncRequest(bv(), LFUN_INSET_EDIT, x, y - (y2 - y1), mouse_button::none));
1948 setCursorFromCoordinates(bv(), cursor.x_fix(),
1949 cursor.y() - cursorRow()->baseline() - 1);
1954 void LyXText::cursorDown(bool selecting)
1957 int x = cursor.x_fix();
1958 int y = cursor.y() - cursorRow()->baseline() + cursorRow()->height() + 1;
1959 setCursorFromCoordinates(x, y);
1960 if (!selecting && cursorRow() == cursorIRow()) {
1962 int y1 = cursor.iy() - topy;
1965 InsetOld * inset_hit = checkInsetHit(x, y1);
1966 if (inset_hit && isHighlyEditableInset(inset_hit)) {
1967 FuncRequest cmd(bv(), LFUN_INSET_EDIT, x, y - (y2 - y1), mouse_button::none);
1968 inset_hit->localDispatch(cmd);
1972 setCursorFromCoordinates(bv(), cursor.x_fix(),
1973 cursor.y() - cursorRow()->baseline()
1974 + cursorRow()->height() + 1);
1979 void LyXText::cursorUpParagraph()
1981 if (cursor.pos() > 0)
1982 setCursor(cursor.par(), 0);
1983 else if (cursor.par() != ownerParagraphs().begin())
1984 setCursor(boost::prior(cursor.par()), 0);
1988 void LyXText::cursorDownParagraph()
1990 ParagraphList::iterator par = cursor.par();
1991 ParagraphList::iterator next_par = boost::next(par);
1993 if (next_par != ownerParagraphs().end())
1994 setCursor(next_par, 0);
1996 setCursor(par, par->size());
2000 // fix the cursor `cur' after a characters has been deleted at `where'
2001 // position. Called by deleteEmptyParagraphMechanism
2002 void LyXText::fixCursorAfterDelete(LyXCursor & cur,
2003 LyXCursor const & where)
2005 // if cursor is not in the paragraph where the delete occured,
2007 if (cur.par() != where.par())
2010 // if cursor position is after the place where the delete occured,
2012 if (cur.pos() > where.pos())
2013 cur.pos(cur.pos()-1);
2015 // check also if we don't want to set the cursor on a spot behind the
2016 // pagragraph because we erased the last character.
2017 if (cur.pos() > cur.par()->size())
2018 cur.pos(cur.par()->size());
2020 // recompute row et al. for this cursor
2021 setCursor(cur, cur.par(), cur.pos(), cur.boundary());
2025 bool LyXText::deleteEmptyParagraphMechanism(LyXCursor const & old_cursor)
2027 // Would be wrong to delete anything if we have a selection.
2028 if (selection.set())
2031 // We allow all kinds of "mumbo-jumbo" when freespacing.
2032 if (old_cursor.par()->layout()->free_spacing
2033 || old_cursor.par()->isFreeSpacing()) {
2037 /* Ok I'll put some comments here about what is missing.
2038 I have fixed BackSpace (and thus Delete) to not delete
2039 double-spaces automagically. I have also changed Cut,
2040 Copy and Paste to hopefully do some sensible things.
2041 There are still some small problems that can lead to
2042 double spaces stored in the document file or space at
2043 the beginning of paragraphs. This happens if you have
2044 the cursor betwenn to spaces and then save. Or if you
2045 cut and paste and the selection have a space at the
2046 beginning and then save right after the paste. I am
2047 sure none of these are very hard to fix, but I will
2048 put out 1.1.4pre2 with FIX_DOUBLE_SPACE defined so
2049 that I can get some feedback. (Lgb)
2052 // If old_cursor.pos() == 0 and old_cursor.pos()(1) == LineSeparator
2053 // delete the LineSeparator.
2056 // If old_cursor.pos() == 1 and old_cursor.pos()(0) == LineSeparator
2057 // delete the LineSeparator.
2060 // If the pos around the old_cursor were spaces, delete one of them.
2061 if (old_cursor.par() != cursor.par()
2062 || old_cursor.pos() != cursor.pos()) {
2063 // Only if the cursor has really moved
2065 if (old_cursor.pos() > 0
2066 && old_cursor.pos() < old_cursor.par()->size()
2067 && old_cursor.par()->isLineSeparator(old_cursor.pos())
2068 && old_cursor.par()->isLineSeparator(old_cursor.pos() - 1)) {
2069 old_cursor.par()->erase(old_cursor.pos() - 1);
2070 redoParagraph(old_cursor.par());
2072 #ifdef WITH_WARNINGS
2073 #warning This will not work anymore when we have multiple views of the same buffer
2074 // In this case, we will have to correct also the cursors held by
2075 // other bufferviews. It will probably be easier to do that in a more
2076 // automated way in LyXCursor code. (JMarc 26/09/2001)
2078 // correct all cursors held by the LyXText
2079 fixCursorAfterDelete(cursor, old_cursor);
2080 fixCursorAfterDelete(selection.cursor, old_cursor);
2081 fixCursorAfterDelete(selection.start, old_cursor);
2082 fixCursorAfterDelete(selection.end, old_cursor);
2083 fixCursorAfterDelete(last_sel_cursor, old_cursor);
2088 // don't delete anything if this is the ONLY paragraph!
2089 if (ownerParagraphs().size() == 1)
2092 // Do not delete empty paragraphs with keepempty set.
2093 if (old_cursor.par()->allowEmpty())
2096 // only do our magic if we changed paragraph
2097 if (old_cursor.par() == cursor.par())
2100 // record if we have deleted a paragraph
2101 // we can't possibly have deleted a paragraph before this point
2102 bool deleted = false;
2104 if (old_cursor.par()->empty() ||
2105 (old_cursor.par()->size() == 1 &&
2106 old_cursor.par()->isLineSeparator(0))) {
2107 // ok, we will delete anything
2108 LyXCursor tmpcursor;
2112 bool selection_position_was_oldcursor_position = (
2113 selection.cursor.par() == old_cursor.par()
2114 && selection.cursor.pos() == old_cursor.pos());
2116 if (getRow(old_cursor) != rows().begin()) {
2117 RowList::iterator prevrow = boost::prior(getRow(old_cursor));
2119 cursor = old_cursor; // that undo can restore the right cursor position
2120 #warning FIXME. --end() iterator is usable here
2121 ParagraphList::iterator endpit = boost::next(old_cursor.par());
2122 while (endpit != ownerParagraphs().end() &&
2123 endpit->getDepth()) {
2127 recordUndo(bv(), Undo::DELETE, old_cursor.par(),
2128 boost::prior(endpit));
2132 removeRow(getRow(old_cursor));
2134 ownerParagraphs().erase(old_cursor.par());
2136 /* Breakagain the next par. Needed because of
2137 * the parindent that can occur or dissappear.
2138 * The next row can change its height, if
2139 * there is another layout before */
2140 RowList::iterator tmprit = boost::next(prevrow);
2141 if (tmprit != rows().end()) {
2145 setHeightOfRow(prevrow);
2147 RowList::iterator nextrow = boost::next(getRow(old_cursor));
2150 cursor = old_cursor; // that undo can restore the right cursor position
2151 #warning FIXME. --end() iterator is usable here
2152 ParagraphList::iterator endpit = boost::next(old_cursor.par());
2153 while (endpit != ownerParagraphs().end() &&
2154 endpit->getDepth()) {
2158 recordUndo(bv(), Undo::DELETE, old_cursor.par(), boost::prior(endpit));
2162 removeRow(getRow(old_cursor));
2164 ownerParagraphs().erase(old_cursor.par());
2166 /* Breakagain the next par. Needed because of
2167 the parindent that can occur or dissappear.
2168 The next row can change its height, if
2169 there is another layout before */
2170 if (nextrow != rows().end()) {
2171 breakAgain(nextrow);
2177 setCursorIntern(cursor.par(), cursor.pos());
2179 if (selection_position_was_oldcursor_position) {
2180 // correct selection
2181 selection.cursor = cursor;
2185 if (old_cursor.par()->stripLeadingSpaces()) {
2186 redoParagraph(old_cursor.par());
2188 setCursorIntern(cursor.par(), cursor.pos());
2189 selection.cursor = cursor;
2196 ParagraphList & LyXText::ownerParagraphs() const
2199 return inset_owner->paragraphs;
2201 return bv_owner->buffer()->paragraphs;
2205 bool LyXText::isInInset() const
2207 // Sub-level has non-null bv owner and
2208 // non-null inset owner.
2209 return inset_owner != 0 && bv_owner != 0;
2213 int defaultRowHeight()
2215 LyXFont const font(LyXFont::ALL_SANE);
2216 return int(font_metrics::maxAscent(font)
2217 + font_metrics::maxDescent(font) * 1.5);