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 bool const lsel = TextCursor::setSelection();
765 if (inset_owner && (selection.set() || lsel))
766 inset_owner->setUpdateStatus(InsetText::SELECTION);
771 void LyXText::clearSelection()
773 TextCursor::clearSelection();
775 // reset this in the bv_owner!
776 if (bv_owner && bv_owner->text)
777 bv_owner->text->xsel_cache.set(false);
781 void LyXText::cursorHome()
783 setCursor(cursor.par(), cursorRow()->pos());
787 void LyXText::cursorEnd()
789 if (cursor.par()->empty())
792 RowList::iterator rit = cursorRow();
793 RowList::iterator next_rit = boost::next(rit);
794 ParagraphList::iterator pit = rit->par();
795 pos_type last_pos = lastPos(*this, rit);
797 if (next_rit == rows().end() || next_rit->par() != pit) {
801 (pit->getChar(last_pos) != ' ' && !pit->isNewline(last_pos))) {
806 setCursor(pit, last_pos);
810 void LyXText::cursorTop()
812 setCursor(ownerParagraphs().begin(), 0);
816 void LyXText::cursorBottom()
818 ParagraphList::iterator lastpit =
819 boost::prior(ownerParagraphs().end());
820 setCursor(lastpit, lastpit->size());
824 void LyXText::toggleFree(LyXFont const & font, bool toggleall)
826 // If the mask is completely neutral, tell user
827 if (font == LyXFont(LyXFont::ALL_IGNORE)) {
828 // Could only happen with user style
829 bv()->owner()->message(_("No font change defined. Use Character under the Layout menu to define font change."));
833 // Try implicit word selection
834 // If there is a change in the language the implicit word selection
836 LyXCursor resetCursor = cursor;
837 bool implicitSelection = (font.language() == ignore_language
838 && font.number() == LyXFont::IGNORE)
839 ? selectWordWhenUnderCursor(lyx::WHOLE_WORD_STRICT) : false;
842 setFont(font, toggleall);
844 // Implicit selections are cleared afterwards
845 //and cursor is set to the original position.
846 if (implicitSelection) {
848 cursor = resetCursor;
849 setCursor(cursor.par(), cursor.pos());
850 selection.cursor = cursor;
853 inset_owner->setUpdateStatus(InsetText::CURSOR_PAR);
857 string LyXText::getStringToIndex()
859 // Try implicit word selection
860 // If there is a change in the language the implicit word selection
862 LyXCursor const reset_cursor = cursor;
863 bool const implicitSelection =
864 selectWordWhenUnderCursor(lyx::PREVIOUS_WORD);
867 if (!selection.set())
868 bv()->owner()->message(_("Nothing to index!"));
869 else if (selection.start.par() != selection.end.par())
870 bv()->owner()->message(_("Cannot index more than one paragraph!"));
872 idxstring = selectionAsString(bv()->buffer(), false);
874 // Reset cursors to their original position.
875 cursor = reset_cursor;
876 setCursor(cursor.par(), cursor.pos());
877 selection.cursor = cursor;
879 // Clear the implicit selection.
880 if (implicitSelection)
887 // the DTP switches for paragraphs. LyX will store them in the first
888 // physicla paragraph. When a paragraph is broken, the top settings rest,
889 // the bottom settings are given to the new one. So I can make shure,
890 // they do not duplicate themself and you cannnot make dirty things with
893 void LyXText::setParagraph(bool line_top, bool line_bottom,
894 bool pagebreak_top, bool pagebreak_bottom,
895 VSpace const & space_top,
896 VSpace const & space_bottom,
897 Spacing const & spacing,
899 string const & labelwidthstring,
902 LyXCursor tmpcursor = cursor;
903 if (!selection.set()) {
904 selection.start = cursor;
905 selection.end = cursor;
908 // make sure that the depth behind the selection are restored, too
909 ParagraphList::iterator endpit = boost::next(selection.end.par());
910 ParagraphList::iterator undoendpit = endpit;
911 ParagraphList::iterator pars_end = ownerParagraphs().end();
913 if (endpit != pars_end && endpit->getDepth()) {
914 while (endpit != pars_end && endpit->getDepth()) {
918 } else if (endpit != pars_end) {
919 // because of parindents etc.
923 recordUndo(bv(), Undo::ATOMIC, selection.start.par(),
924 boost::prior(undoendpit));
927 ParagraphList::iterator tmppit = selection.end.par();
929 while (tmppit != boost::prior(selection.start.par())) {
930 setCursor(tmppit, 0);
932 ParagraphList::iterator pit = cursor.par();
933 ParagraphParameters & params = pit->params();
935 params.lineTop(line_top);
936 params.lineBottom(line_bottom);
937 params.pagebreakTop(pagebreak_top);
938 params.pagebreakBottom(pagebreak_bottom);
939 params.spaceTop(space_top);
940 params.spaceBottom(space_bottom);
941 params.spacing(spacing);
942 // does the layout allow the new alignment?
943 LyXLayout_ptr const & layout = pit->layout();
945 if (align == LYX_ALIGN_LAYOUT)
946 align = layout->align;
947 if (align & layout->alignpossible) {
948 if (align == layout->align)
949 params.align(LYX_ALIGN_LAYOUT);
953 pit->setLabelWidthString(labelwidthstring);
954 params.noindent(noindent);
955 tmppit = boost::prior(pit);
958 redoParagraphs(selection.start.par(), endpit);
961 setCursor(selection.start.par(), selection.start.pos());
962 selection.cursor = cursor;
963 setCursor(selection.end.par(), selection.end.pos());
965 setCursor(tmpcursor.par(), tmpcursor.pos());
967 bv()->updateInset(inset_owner);
971 // set the counter of a paragraph. This includes the labels
972 void LyXText::setCounter(Buffer const * buf, ParagraphList::iterator pit)
974 LyXTextClass const & textclass = buf->params.getLyXTextClass();
975 LyXLayout_ptr const & layout = pit->layout();
977 if (pit != ownerParagraphs().begin()) {
979 pit->params().appendix(boost::prior(pit)->params().appendix());
980 if (!pit->params().appendix() &&
981 pit->params().startOfAppendix()) {
982 pit->params().appendix(true);
983 textclass.counters().reset();
985 pit->enumdepth = boost::prior(pit)->enumdepth;
986 pit->itemdepth = boost::prior(pit)->itemdepth;
988 pit->params().appendix(pit->params().startOfAppendix());
993 /* Maybe we have to increment the enumeration depth.
994 * BUT, enumeration in a footnote is considered in isolation from its
995 * surrounding paragraph so don't increment if this is the
996 * first line of the footnote
997 * AND, bibliographies can't have their depth changed ie. they
998 * are always of depth 0
1000 if (pit != ownerParagraphs().begin()
1001 && boost::prior(pit)->getDepth() < pit->getDepth()
1002 && boost::prior(pit)->layout()->labeltype == LABEL_COUNTER_ENUMI
1003 && pit->enumdepth < 3
1004 && layout->labeltype != LABEL_BIBLIO) {
1008 // Maybe we have to decrement the enumeration depth, see note above
1009 if (pit != ownerParagraphs().begin()
1010 && boost::prior(pit)->getDepth() > pit->getDepth()
1011 && layout->labeltype != LABEL_BIBLIO) {
1012 pit->enumdepth = depthHook(pit, ownerParagraphs(),
1013 pit->getDepth())->enumdepth;
1016 if (!pit->params().labelString().empty()) {
1017 pit->params().labelString(string());
1020 if (layout->margintype == MARGIN_MANUAL) {
1021 if (pit->params().labelWidthString().empty()) {
1022 pit->setLabelWidthString(layout->labelstring());
1025 pit->setLabelWidthString(string());
1028 // is it a layout that has an automatic label?
1029 if (layout->labeltype >= LABEL_COUNTER_CHAPTER) {
1030 int const i = layout->labeltype - LABEL_COUNTER_CHAPTER;
1034 if (i >= 0 && i <= buf->params.secnumdepth) {
1038 textclass.counters().step(layout->latexname());
1040 // Is there a label? Useful for Chapter layout
1041 if (!pit->params().appendix()) {
1042 s << buf->B_(layout->labelstring());
1044 s << buf->B_(layout->labelstring_appendix());
1047 // Use of an integer is here less than elegant. For now.
1048 int head = textclass.maxcounter() - LABEL_COUNTER_CHAPTER;
1049 if (!pit->params().appendix()) {
1050 numbertype = "sectioning";
1052 numbertype = "appendix";
1053 if (pit->isRightToLeftPar(buf->params))
1054 langtype = "hebrew";
1060 << textclass.counters()
1061 .numberLabel(layout->latexname(),
1062 numbertype, langtype, head);
1064 pit->params().labelString(STRCONV(s.str()));
1066 // reset enum counters
1067 textclass.counters().reset("enum");
1068 } else if (layout->labeltype < LABEL_COUNTER_ENUMI) {
1069 textclass.counters().reset("enum");
1070 } else if (layout->labeltype == LABEL_COUNTER_ENUMI) {
1072 // Yes I know this is a really, really! bad solution
1074 string enumcounter("enum");
1076 switch (pit->enumdepth) {
1085 enumcounter += "iv";
1088 // not a valid enumdepth...
1092 textclass.counters().step(enumcounter);
1094 s << textclass.counters()
1095 .numberLabel(enumcounter, "enumeration");
1096 pit->params().labelString(STRCONV(s.str()));
1098 } else if (layout->labeltype == LABEL_BIBLIO) {// ale970302
1099 textclass.counters().step("bibitem");
1100 int number = textclass.counters().value("bibitem");
1101 if (pit->bibitem()) {
1102 pit->bibitem()->setCounter(number);
1103 pit->params().labelString(layout->labelstring());
1105 // In biblio should't be following counters but...
1107 string s = buf->B_(layout->labelstring());
1109 // the caption hack:
1110 if (layout->labeltype == LABEL_SENSITIVE) {
1111 ParagraphList::iterator end = ownerParagraphs().end();
1112 ParagraphList::iterator tmppit = pit;
1115 while (tmppit != end && tmppit->inInset()
1116 // the single '=' is intended below
1117 && (in = tmppit->inInset()->owner()))
1119 if (in->lyxCode() == InsetOld::FLOAT_CODE ||
1120 in->lyxCode() == InsetOld::WRAP_CODE) {
1124 tmppit = ownerParagraphs().begin();
1125 for ( ; tmppit != end; ++tmppit)
1126 if (&*tmppit == in->parOwner())
1134 if (in->lyxCode() == InsetOld::FLOAT_CODE)
1135 type = static_cast<InsetFloat*>(in)->params().type;
1136 else if (in->lyxCode() == InsetOld::WRAP_CODE)
1137 type = static_cast<InsetWrap*>(in)->params().type;
1141 Floating const & fl = textclass.floats().getType(type);
1143 textclass.counters().step(fl.type());
1145 // Doesn't work... yet.
1146 s = bformat(_("%1$s #:"), buf->B_(fl.name()));
1148 // par->SetLayout(0);
1149 // s = layout->labelstring;
1150 s = _("Senseless: ");
1153 pit->params().labelString(s);
1155 // reset the enumeration counter. They are always reset
1156 // when there is any other layout between
1157 // Just fall-through between the cases so that all
1158 // enum counters deeper than enumdepth is also reset.
1159 switch (pit->enumdepth) {
1161 textclass.counters().reset("enumi");
1163 textclass.counters().reset("enumii");
1165 textclass.counters().reset("enumiii");
1167 textclass.counters().reset("enumiv");
1173 // Updates all counters. Paragraphs with changed label string will be rebroken
1174 void LyXText::updateCounters()
1176 RowList::iterator rowit = rows().begin();
1177 ParagraphList::iterator pit = rowit->par();
1179 // CHECK if this is really needed. (Lgb)
1180 bv()->buffer()->params.getLyXTextClass().counters().reset();
1182 ParagraphList::iterator beg = ownerParagraphs().begin();
1183 ParagraphList::iterator end = ownerParagraphs().end();
1184 for (; pit != end; ++pit) {
1185 while (rowit->par() != pit)
1188 string const oldLabel = pit->params().labelString();
1190 size_t maxdepth = 0;
1192 maxdepth = boost::prior(pit)->getMaxDepthAfter();
1194 if (pit->params().depth() > maxdepth)
1195 pit->params().depth(maxdepth);
1197 // setCounter can potentially change the labelString.
1198 setCounter(bv()->buffer(), pit);
1200 string const & newLabel = pit->params().labelString();
1202 if (oldLabel.empty() && !newLabel.empty()) {
1203 removeParagraph(rowit);
1204 appendParagraph(rowit);
1210 void LyXText::insertInset(InsetOld * inset)
1212 if (!cursor.par()->insetAllowed(inset->lyxCode()))
1214 recordUndo(bv(), Undo::ATOMIC, cursor.par());
1216 cursor.par()->insertInset(cursor.pos(), inset);
1217 // Just to rebreak and refresh correctly.
1218 // The character will not be inserted a second time
1219 insertChar(Paragraph::META_INSET);
1220 // If we enter a highly editable inset the cursor should be to before
1221 // the inset. This couldn't happen before as Undo was not handled inside
1222 // inset now after the Undo LyX tries to call inset->Edit(...) again
1223 // and cannot do this as the cursor is behind the inset and GetInset
1224 // does not return the inset!
1225 if (isHighlyEditableInset(inset)) {
1232 void LyXText::cutSelection(bool doclear, bool realcut)
1234 // Stuff what we got on the clipboard. Even if there is no selection.
1236 // There is a problem with having the stuffing here in that the
1237 // larger the selection the slower LyX will get. This can be
1238 // solved by running the line below only when the selection has
1239 // finished. The solution used currently just works, to make it
1240 // faster we need to be more clever and probably also have more
1241 // calls to stuffClipboard. (Lgb)
1242 bv()->stuffClipboard(selectionAsString(bv()->buffer(), true));
1244 // This doesn't make sense, if there is no selection
1245 if (!selection.set())
1248 // OK, we have a selection. This is always between selection.start
1249 // and selection.end
1251 // make sure that the depth behind the selection are restored, too
1252 ParagraphList::iterator endpit = boost::next(selection.end.par());
1253 ParagraphList::iterator undoendpit = endpit;
1254 ParagraphList::iterator pars_end = ownerParagraphs().end();
1256 if (endpit != pars_end && endpit->getDepth()) {
1257 while (endpit != pars_end && endpit->getDepth()) {
1259 undoendpit = endpit;
1261 } else if (endpit != pars_end) {
1262 // because of parindents etc.
1266 recordUndo(bv(), Undo::DELETE, selection.start.par(),
1267 boost::prior(undoendpit));
1270 endpit = selection.end.par();
1271 int endpos = selection.end.pos();
1273 boost::tie(endpit, endpos) = realcut ?
1274 CutAndPaste::cutSelection(bv()->buffer()->params,
1276 selection.start.par(), endpit,
1277 selection.start.pos(), endpos,
1278 bv()->buffer()->params.textclass,
1280 : CutAndPaste::eraseSelection(bv()->buffer()->params,
1282 selection.start.par(), endpit,
1283 selection.start.pos(), endpos,
1285 // sometimes necessary
1287 selection.start.par()->stripLeadingSpaces();
1289 redoParagraphs(selection.start.par(), boost::next(endpit));
1290 #warning FIXME latent bug
1291 // endpit will be invalidated on redoParagraphs once ParagraphList
1292 // becomes a std::list? There are maybe other places on which this
1293 // can happend? (Ab)
1294 // cutSelection can invalidate the cursor so we need to set
1296 // we prefer the end for when tracking changes
1300 // need a valid cursor. (Lgb)
1303 setCursor(cursor.par(), cursor.pos());
1304 selection.cursor = cursor;
1309 void LyXText::copySelection()
1311 // stuff the selection onto the X clipboard, from an explicit copy request
1312 bv()->stuffClipboard(selectionAsString(bv()->buffer(), true));
1314 // this doesnt make sense, if there is no selection
1315 if (!selection.set())
1318 // ok we have a selection. This is always between selection.start
1319 // and sel_end cursor
1321 // copy behind a space if there is one
1322 while (selection.start.par()->size() > selection.start.pos()
1323 && selection.start.par()->isLineSeparator(selection.start.pos())
1324 && (selection.start.par() != selection.end.par()
1325 || selection.start.pos() < selection.end.pos()))
1326 selection.start.pos(selection.start.pos() + 1);
1328 CutAndPaste::copySelection(selection.start.par(),
1329 selection.end.par(),
1330 selection.start.pos(), selection.end.pos(),
1331 bv()->buffer()->params.textclass);
1335 void LyXText::pasteSelection(size_t sel_index)
1337 // this does not make sense, if there is nothing to paste
1338 if (!CutAndPaste::checkPastePossible())
1341 recordUndo(bv(), Undo::INSERT, cursor.par());
1343 ParagraphList::iterator endpit;
1348 boost::tie(ppp, endpit) =
1349 CutAndPaste::pasteSelection(*bv()->buffer(),
1351 cursor.par(), cursor.pos(),
1352 bv()->buffer()->params.textclass,
1354 bufferErrors(*bv()->buffer(), el);
1355 bv()->showErrorList(_("Paste"));
1357 redoParagraphs(cursor.par(), endpit);
1359 setCursor(cursor.par(), cursor.pos());
1362 selection.cursor = cursor;
1363 setCursor(ppp.first, ppp.second);
1369 void LyXText::setSelectionRange(lyx::pos_type length)
1374 selection.cursor = cursor;
1381 // simple replacing. The font of the first selected character is used
1382 void LyXText::replaceSelectionWithString(string const & str)
1384 recordUndo(bv(), Undo::ATOMIC);
1387 if (!selection.set()) { // create a dummy selection
1388 selection.end = cursor;
1389 selection.start = cursor;
1392 // Get font setting before we cut
1393 pos_type pos = selection.end.pos();
1394 LyXFont const font = selection.start.par()
1395 ->getFontSettings(bv()->buffer()->params,
1396 selection.start.pos());
1398 // Insert the new string
1399 string::const_iterator cit = str.begin();
1400 string::const_iterator end = str.end();
1401 for (; cit != end; ++cit) {
1402 selection.end.par()->insertChar(pos, (*cit), font);
1406 // Cut the selection
1407 cutSelection(true, false);
1413 // needed to insert the selection
1414 void LyXText::insertStringAsLines(string const & str)
1416 ParagraphList::iterator pit = cursor.par();
1417 pos_type pos = cursor.pos();
1418 ParagraphList::iterator endpit = boost::next(cursor.par());
1420 recordUndo(bv(), Undo::ATOMIC);
1422 // only to be sure, should not be neccessary
1425 bv()->buffer()->insertStringAsLines(pit, pos, current_font, str);
1427 redoParagraphs(cursor.par(), endpit);
1428 setCursor(cursor.par(), cursor.pos());
1429 selection.cursor = cursor;
1430 setCursor(pit, pos);
1435 // turns double-CR to single CR, others where converted into one
1436 // blank. Then InsertStringAsLines is called
1437 void LyXText::insertStringAsParagraphs(string const & str)
1439 string linestr(str);
1440 bool newline_inserted = false;
1441 string::size_type const siz = linestr.length();
1443 for (string::size_type i = 0; i < siz; ++i) {
1444 if (linestr[i] == '\n') {
1445 if (newline_inserted) {
1446 // we know that \r will be ignored by
1447 // InsertStringA. Of course, it is a dirty
1448 // trick, but it works...
1449 linestr[i - 1] = '\r';
1453 newline_inserted = true;
1455 } else if (IsPrintable(linestr[i])) {
1456 newline_inserted = false;
1459 insertStringAsLines(linestr);
1463 void LyXText::checkParagraph(ParagraphList::iterator pit, pos_type pos)
1465 breakAgain(getRow(pit, pos));
1466 setCursorIntern(cursor.par(), cursor.pos(), false, cursor.boundary());
1470 // returns false if inset wasn't found
1471 bool LyXText::updateInset(InsetOld * inset)
1473 // first check the current paragraph
1474 int pos = cursor.par()->getPositionOfInset(inset);
1476 checkParagraph(cursor.par(), pos);
1480 // check every paragraph
1481 ParagraphList::iterator par = ownerParagraphs().begin();
1482 ParagraphList::iterator end = ownerParagraphs().end();
1483 for (; par != end; ++par) {
1484 pos = par->getPositionOfInset(inset);
1486 checkParagraph(par, pos);
1495 bool LyXText::setCursor(ParagraphList::iterator pit,
1497 bool setfont, bool boundary)
1499 LyXCursor old_cursor = cursor;
1500 setCursorIntern(pit, pos, setfont, boundary);
1501 return deleteEmptyParagraphMechanism(old_cursor);
1505 void LyXText::setCursor(LyXCursor & cur, ParagraphList::iterator pit,
1506 pos_type pos, bool boundary)
1508 Assert(pit != ownerParagraphs().end());
1512 cur.boundary(boundary);
1516 // get the cursor y position in text
1518 RowList::iterator row = getRow(pit, pos, y);
1519 RowList::iterator beg = rows().begin();
1521 RowList::iterator old_row = row;
1522 // if we are before the first char of this row and are still in the
1523 // same paragraph and there is a previous row then put the cursor on
1524 // the end of the previous row
1525 cur.iy(y + row->baseline());
1528 boost::prior(row)->par() == row->par() &&
1529 pos < pit->size() &&
1530 pit->getChar(pos) == Paragraph::META_INSET) {
1531 InsetOld * ins = pit->getInset(pos);
1532 if (ins && (ins->needFullRow() || ins->display())) {
1538 // y is now the beginning of the cursor row
1539 y += row->baseline();
1540 // y is now the cursor baseline
1543 pos_type last = lastPrintablePos(*this, old_row);
1545 // None of these should happen, but we're scaredy-cats
1546 if (pos > pit->size()) {
1547 lyxerr << "dont like 1 please report" << endl;
1550 } else if (pos > last + 1) {
1551 lyxerr << "dont like 2 please report" << endl;
1552 // This shouldn't happen.
1555 } else if (pos < row->pos()) {
1556 lyxerr << "dont like 3 please report" << endl;
1561 // now get the cursors x position
1562 float x = getCursorX(row, pos, last, boundary);
1565 if (old_row != row) {
1566 x = getCursorX(old_row, pos, last, boundary);
1570 /* We take out this for the time being because 1) the redraw code is not
1571 prepared to this yet and 2) because some good policy has yet to be decided
1572 while editting: for instance how to act on rows being created/deleted
1576 //if the cursor is in a visible row, anchor to it
1578 if (topy < y && y < topy + bv()->workHeight())
1584 float LyXText::getCursorX(RowList::iterator rit,
1585 pos_type pos, pos_type last, bool boundary) const
1587 pos_type cursor_vpos = 0;
1589 double fill_separator;
1591 double fill_label_hfill;
1592 // This call HAS to be here because of the BidiTables!!!
1593 prepareToPrint(rit, x, fill_separator, fill_hfill,
1596 ParagraphList::iterator rit_par = rit->par();
1597 pos_type const rit_pos = rit->pos();
1600 cursor_vpos = rit_pos;
1601 else if (pos > last && !boundary)
1602 cursor_vpos = (rit_par->isRightToLeftPar(bv()->buffer()->params))
1603 ? rit_pos : last + 1;
1604 else if (pos > rit_pos && (pos > last || boundary))
1605 /// Place cursor after char at (logical) position pos - 1
1606 cursor_vpos = (bidi_level(pos - 1) % 2 == 0)
1607 ? log2vis(pos - 1) + 1 : log2vis(pos - 1);
1609 /// Place cursor before char at (logical) position pos
1610 cursor_vpos = (bidi_level(pos) % 2 == 0)
1611 ? log2vis(pos) : log2vis(pos) + 1;
1613 pos_type body_pos = rit_par->beginningOfBody();
1615 (body_pos - 1 > last || !rit_par->isLineSeparator(body_pos - 1)))
1618 for (pos_type vpos = rit_pos; vpos < cursor_vpos; ++vpos) {
1619 pos_type pos = vis2log(vpos);
1620 if (body_pos > 0 && pos == body_pos - 1) {
1621 x += fill_label_hfill +
1622 font_metrics::width(
1623 rit_par->layout()->labelsep, getLabelFont(rit_par));
1624 if (rit_par->isLineSeparator(body_pos - 1))
1625 x -= singleWidth(rit_par, body_pos - 1);
1628 if (hfillExpansion(*this, rit, pos)) {
1629 x += singleWidth(rit_par, pos);
1630 if (pos >= body_pos)
1633 x += fill_label_hfill;
1634 } else if (rit_par->isSeparator(pos)) {
1635 x += singleWidth(rit_par, pos);
1636 if (pos >= body_pos)
1637 x += fill_separator;
1639 x += singleWidth(rit_par, pos);
1645 void LyXText::setCursorIntern(ParagraphList::iterator pit,
1646 pos_type pos, bool setfont, bool boundary)
1648 UpdatableInset * it = pit->inInset();
1650 if (it != inset_owner) {
1651 lyxerr[Debug::INSETS] << "InsetText is " << it
1653 << "inset_owner is "
1654 << inset_owner << endl;
1655 #ifdef WITH_WARNINGS
1656 #warning I believe this code is wrong. (Lgb)
1657 #warning Jürgen, have a look at this. (Lgb)
1658 #warning Hmmm, I guess you are right but we
1659 #warning should verify when this is needed
1661 // Jürgen, would you like to have a look?
1662 // I guess we need to move the outer cursor
1663 // and open and lock the inset (bla bla bla)
1664 // stuff I don't know... so can you have a look?
1666 // I moved the lyxerr stuff in here so we can see if
1667 // this is actually really needed and where!
1669 // it->getLyXText(bv())->setCursorIntern(bv(), par, pos, setfont, boundary);
1674 setCursor(cursor, pit, pos, boundary);
1680 void LyXText::setCurrentFont()
1682 pos_type pos = cursor.pos();
1683 ParagraphList::iterator pit = cursor.par();
1685 if (cursor.boundary() && pos > 0)
1689 if (pos == pit->size())
1691 else // potentional bug... BUG (Lgb)
1692 if (pit->isSeparator(pos)) {
1693 if (pos > cursorRow()->pos() &&
1694 bidi_level(pos) % 2 ==
1695 bidi_level(pos - 1) % 2)
1697 else if (pos + 1 < pit->size())
1702 current_font = pit->getFontSettings(bv()->buffer()->params, pos);
1703 real_current_font = getFont(pit, pos);
1705 if (cursor.pos() == pit->size() &&
1706 isBoundary(bv()->buffer(), *pit, cursor.pos()) &&
1707 !cursor.boundary()) {
1708 Language const * lang =
1709 pit->getParLanguage(bv()->buffer()->params);
1710 current_font.setLanguage(lang);
1711 current_font.setNumber(LyXFont::OFF);
1712 real_current_font.setLanguage(lang);
1713 real_current_font.setNumber(LyXFont::OFF);
1718 // returns the column near the specified x-coordinate of the row
1719 // x is set to the real beginning of this column
1721 LyXText::getColumnNearX(RowList::iterator rit, int & x, bool & boundary) const
1724 double fill_separator;
1726 double fill_label_hfill;
1728 prepareToPrint(rit, tmpx, fill_separator, fill_hfill, fill_label_hfill);
1730 pos_type vc = rit->pos();
1731 pos_type last = lastPrintablePos(*this, rit);
1734 ParagraphList::iterator rit_par = rit->par();
1735 LyXLayout_ptr const & layout = rit->par()->layout();
1737 bool left_side = false;
1739 pos_type body_pos = rit_par->beginningOfBody();
1740 double last_tmpx = tmpx;
1743 (body_pos - 1 > last ||
1744 !rit_par->isLineSeparator(body_pos - 1)))
1747 // check for empty row
1748 if (!rit_par->size()) {
1753 while (vc <= last && tmpx <= x) {
1756 if (body_pos > 0 && c == body_pos - 1) {
1757 tmpx += fill_label_hfill +
1758 font_metrics::width(layout->labelsep, getLabelFont(rit_par));
1759 if (rit_par->isLineSeparator(body_pos - 1))
1760 tmpx -= singleWidth(rit_par, body_pos - 1);
1763 if (hfillExpansion(*this, rit, c)) {
1764 tmpx += singleWidth(rit_par, c);
1768 tmpx += fill_label_hfill;
1769 } else if (rit_par->isSeparator(c)) {
1770 tmpx += singleWidth(rit_par, c);
1772 tmpx += fill_separator;
1774 tmpx += singleWidth(rit_par, c);
1779 if ((tmpx + last_tmpx) / 2 > x) {
1784 if (vc > last + 1) // This shouldn't happen.
1788 // This (rtl_support test) is not needed, but gives
1789 // some speedup if rtl_support=false
1790 RowList::iterator next_rit = boost::next(rit);
1792 bool const lastrow = lyxrc.rtl_support &&
1793 (next_rit == rowlist_.end() ||
1794 next_rit->par() != rit_par);
1796 // If lastrow is false, we don't need to compute
1797 // the value of rtl.
1798 bool const rtl = (lastrow)
1799 ? rit_par->isRightToLeftPar(bv()->buffer()->params)
1802 ((rtl && left_side && vc == rit->pos() && x < tmpx - 5) ||
1803 (!rtl && !left_side && vc == last + 1 && x > tmpx + 5)))
1805 else if (vc == rit->pos()) {
1807 if (bidi_level(c) % 2 == 1)
1810 c = vis2log(vc - 1);
1811 bool const rtl = (bidi_level(c) % 2 == 1);
1812 if (left_side == rtl) {
1814 boundary = isBoundary(bv()->buffer(), *rit_par, c);
1818 if (rit->pos() <= last && c > last
1819 && rit_par->isNewline(last)) {
1820 if (bidi_level(last) % 2 == 0)
1821 tmpx -= singleWidth(rit_par, last);
1823 tmpx += singleWidth(rit_par, last);
1833 void LyXText::setCursorFromCoordinates(int x, int y)
1835 //LyXCursor old_cursor = cursor;
1836 setCursorFromCoordinates(cursor, x, y);
1838 #warning DEPM disabled, otherwise crash when entering new table
1839 //deleteEmptyParagraphMechanism(old_cursor);
1846 * return true if the cursor given is at the end of a row,
1847 * and the next row is filled by an inset that spans an entire
1850 bool beforeFullRowInset(LyXText & lt, LyXCursor const & cur)
1852 RowList::iterator row = lt.getRow(cur);
1853 if (boost::next(row) == lt.rows().end())
1856 Row const & next = *boost::next(row);
1858 if (next.pos() != cur.pos() || next.par() != cur.par())
1861 if (cur.pos() == cur.par()->size()
1862 || !cur.par()->isInset(cur.pos()))
1865 InsetOld const * inset = cur.par()->getInset(cur.pos());
1866 if (inset->needFullRow() || inset->display())
1874 void LyXText::setCursorFromCoordinates(LyXCursor & cur, int x, int y)
1876 // Get the row first.
1878 RowList::iterator row = getRowNearY(y);
1880 pos_type const column = getColumnNearX(row, x, bound);
1881 cur.par(row->par());
1882 cur.pos(row->pos() + column);
1884 cur.y(y + row->baseline());
1886 if (beforeFullRowInset(*this, cur)) {
1887 pos_type const last = lastPrintablePos(*this, row);
1888 RowList::iterator next_row = boost::next(row);
1890 float x = getCursorX(next_row, cur.pos(), last, bound);
1892 cur.iy(y + row->height() + next_row->baseline());
1897 cur.boundary(bound);
1901 void LyXText::cursorLeft(bool internal)
1903 if (cursor.pos() > 0) {
1904 bool boundary = cursor.boundary();
1905 setCursor(cursor.par(), cursor.pos() - 1, true, false);
1906 if (!internal && !boundary &&
1907 isBoundary(bv()->buffer(), *cursor.par(), cursor.pos() + 1))
1908 setCursor(cursor.par(), cursor.pos() + 1, true, true);
1909 } else if (cursor.par() != ownerParagraphs().begin()) {
1910 // steps into the paragraph above
1911 ParagraphList::iterator pit = boost::prior(cursor.par());
1912 setCursor(pit, pit->size());
1917 void LyXText::cursorRight(bool internal)
1919 bool const at_end = (cursor.pos() == cursor.par()->size());
1920 bool const at_newline = !at_end &&
1921 cursor.par()->isNewline(cursor.pos());
1923 if (!internal && cursor.boundary() && !at_newline)
1924 setCursor(cursor.par(), cursor.pos(), true, false);
1926 setCursor(cursor.par(), cursor.pos() + 1, true, false);
1928 isBoundary(bv()->buffer(), *cursor.par(), cursor.pos()))
1929 setCursor(cursor.par(), cursor.pos(), true, true);
1930 } else if (boost::next(cursor.par()) != ownerParagraphs().end())
1931 setCursor(boost::next(cursor.par()), 0);
1935 void LyXText::cursorUp(bool selecting)
1938 int x = cursor.x_fix();
1939 int y = cursor.y() - cursorRow()->baseline() - 1;
1940 setCursorFromCoordinates(x, y);
1943 int y1 = cursor.iy() - topy;
1946 InsetOld * inset_hit = checkInsetHit(x, y1);
1947 if (inset_hit && isHighlyEditableInset(inset_hit)) {
1948 inset_hit->localDispatch(
1949 FuncRequest(bv(), LFUN_INSET_EDIT, x, y - (y2 - y1), mouse_button::none));
1953 setCursorFromCoordinates(bv(), cursor.x_fix(),
1954 cursor.y() - cursorRow()->baseline() - 1);
1959 void LyXText::cursorDown(bool selecting)
1962 int x = cursor.x_fix();
1963 int y = cursor.y() - cursorRow()->baseline() + cursorRow()->height() + 1;
1964 setCursorFromCoordinates(x, y);
1965 if (!selecting && cursorRow() == cursorIRow()) {
1967 int y1 = cursor.iy() - topy;
1970 InsetOld * inset_hit = checkInsetHit(x, y1);
1971 if (inset_hit && isHighlyEditableInset(inset_hit)) {
1972 FuncRequest cmd(bv(), LFUN_INSET_EDIT, x, y - (y2 - y1), mouse_button::none);
1973 inset_hit->localDispatch(cmd);
1977 setCursorFromCoordinates(bv(), cursor.x_fix(),
1978 cursor.y() - cursorRow()->baseline()
1979 + cursorRow()->height() + 1);
1984 void LyXText::cursorUpParagraph()
1986 if (cursor.pos() > 0)
1987 setCursor(cursor.par(), 0);
1988 else if (cursor.par() != ownerParagraphs().begin())
1989 setCursor(boost::prior(cursor.par()), 0);
1993 void LyXText::cursorDownParagraph()
1995 ParagraphList::iterator par = cursor.par();
1996 ParagraphList::iterator next_par = boost::next(par);
1998 if (next_par != ownerParagraphs().end())
1999 setCursor(next_par, 0);
2001 setCursor(par, par->size());
2005 // fix the cursor `cur' after a characters has been deleted at `where'
2006 // position. Called by deleteEmptyParagraphMechanism
2007 void LyXText::fixCursorAfterDelete(LyXCursor & cur,
2008 LyXCursor const & where)
2010 // if cursor is not in the paragraph where the delete occured,
2012 if (cur.par() != where.par())
2015 // if cursor position is after the place where the delete occured,
2017 if (cur.pos() > where.pos())
2018 cur.pos(cur.pos()-1);
2020 // check also if we don't want to set the cursor on a spot behind the
2021 // pagragraph because we erased the last character.
2022 if (cur.pos() > cur.par()->size())
2023 cur.pos(cur.par()->size());
2025 // recompute row et al. for this cursor
2026 setCursor(cur, cur.par(), cur.pos(), cur.boundary());
2030 bool LyXText::deleteEmptyParagraphMechanism(LyXCursor const & old_cursor)
2032 // Would be wrong to delete anything if we have a selection.
2033 if (selection.set())
2036 // We allow all kinds of "mumbo-jumbo" when freespacing.
2037 if (old_cursor.par()->layout()->free_spacing
2038 || old_cursor.par()->isFreeSpacing()) {
2042 /* Ok I'll put some comments here about what is missing.
2043 I have fixed BackSpace (and thus Delete) to not delete
2044 double-spaces automagically. I have also changed Cut,
2045 Copy and Paste to hopefully do some sensible things.
2046 There are still some small problems that can lead to
2047 double spaces stored in the document file or space at
2048 the beginning of paragraphs. This happens if you have
2049 the cursor betwenn to spaces and then save. Or if you
2050 cut and paste and the selection have a space at the
2051 beginning and then save right after the paste. I am
2052 sure none of these are very hard to fix, but I will
2053 put out 1.1.4pre2 with FIX_DOUBLE_SPACE defined so
2054 that I can get some feedback. (Lgb)
2057 // If old_cursor.pos() == 0 and old_cursor.pos()(1) == LineSeparator
2058 // delete the LineSeparator.
2061 // If old_cursor.pos() == 1 and old_cursor.pos()(0) == LineSeparator
2062 // delete the LineSeparator.
2065 // If the pos around the old_cursor were spaces, delete one of them.
2066 if (old_cursor.par() != cursor.par()
2067 || old_cursor.pos() != cursor.pos()) {
2068 // Only if the cursor has really moved
2070 if (old_cursor.pos() > 0
2071 && old_cursor.pos() < old_cursor.par()->size()
2072 && old_cursor.par()->isLineSeparator(old_cursor.pos())
2073 && old_cursor.par()->isLineSeparator(old_cursor.pos() - 1)) {
2074 old_cursor.par()->erase(old_cursor.pos() - 1);
2075 redoParagraph(old_cursor.par());
2077 #ifdef WITH_WARNINGS
2078 #warning This will not work anymore when we have multiple views of the same buffer
2079 // In this case, we will have to correct also the cursors held by
2080 // other bufferviews. It will probably be easier to do that in a more
2081 // automated way in LyXCursor code. (JMarc 26/09/2001)
2083 // correct all cursors held by the LyXText
2084 fixCursorAfterDelete(cursor, old_cursor);
2085 fixCursorAfterDelete(selection.cursor, old_cursor);
2086 fixCursorAfterDelete(selection.start, old_cursor);
2087 fixCursorAfterDelete(selection.end, old_cursor);
2088 fixCursorAfterDelete(last_sel_cursor, old_cursor);
2093 // don't delete anything if this is the ONLY paragraph!
2094 if (ownerParagraphs().size() == 1)
2097 // Do not delete empty paragraphs with keepempty set.
2098 if (old_cursor.par()->allowEmpty())
2101 // only do our magic if we changed paragraph
2102 if (old_cursor.par() == cursor.par())
2105 // record if we have deleted a paragraph
2106 // we can't possibly have deleted a paragraph before this point
2107 bool deleted = false;
2109 if (old_cursor.par()->empty() ||
2110 (old_cursor.par()->size() == 1 &&
2111 old_cursor.par()->isLineSeparator(0))) {
2112 // ok, we will delete anything
2113 LyXCursor tmpcursor;
2117 bool selection_position_was_oldcursor_position = (
2118 selection.cursor.par() == old_cursor.par()
2119 && selection.cursor.pos() == old_cursor.pos());
2121 if (getRow(old_cursor) != rows().begin()) {
2122 RowList::iterator prevrow = boost::prior(getRow(old_cursor));
2124 cursor = old_cursor; // that undo can restore the right cursor position
2125 #warning FIXME. --end() iterator is usable here
2126 ParagraphList::iterator endpit = boost::next(old_cursor.par());
2127 while (endpit != ownerParagraphs().end() &&
2128 endpit->getDepth()) {
2132 recordUndo(bv(), Undo::DELETE, old_cursor.par(),
2133 boost::prior(endpit));
2137 removeRow(getRow(old_cursor));
2139 ownerParagraphs().erase(old_cursor.par());
2141 /* Breakagain the next par. Needed because of
2142 * the parindent that can occur or dissappear.
2143 * The next row can change its height, if
2144 * there is another layout before */
2145 RowList::iterator tmprit = boost::next(prevrow);
2146 if (tmprit != rows().end()) {
2150 setHeightOfRow(prevrow);
2152 RowList::iterator nextrow = boost::next(getRow(old_cursor));
2155 cursor = old_cursor; // that undo can restore the right cursor position
2156 #warning FIXME. --end() iterator is usable here
2157 ParagraphList::iterator endpit = boost::next(old_cursor.par());
2158 while (endpit != ownerParagraphs().end() &&
2159 endpit->getDepth()) {
2163 recordUndo(bv(), Undo::DELETE, old_cursor.par(), boost::prior(endpit));
2167 removeRow(getRow(old_cursor));
2169 ownerParagraphs().erase(old_cursor.par());
2171 /* Breakagain the next par. Needed because of
2172 the parindent that can occur or dissappear.
2173 The next row can change its height, if
2174 there is another layout before */
2175 if (nextrow != rows().end()) {
2176 breakAgain(nextrow);
2182 setCursorIntern(cursor.par(), cursor.pos());
2184 if (selection_position_was_oldcursor_position) {
2185 // correct selection
2186 selection.cursor = cursor;
2190 if (old_cursor.par()->stripLeadingSpaces()) {
2191 redoParagraph(old_cursor.par());
2193 setCursorIntern(cursor.par(), cursor.pos());
2194 selection.cursor = cursor;
2201 ParagraphList & LyXText::ownerParagraphs() const
2204 return inset_owner->paragraphs;
2206 return bv_owner->buffer()->paragraphs;
2210 bool LyXText::isInInset() const
2212 // Sub-level has non-null bv owner and
2213 // non-null inset owner.
2214 return inset_owner != 0 && bv_owner != 0;
2218 int defaultRowHeight()
2220 LyXFont const font(LyXFont::ALL_SANE);
2221 return int(font_metrics::maxAscent(font)
2222 + font_metrics::maxDescent(font) * 1.5);