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();
72 LyXText::LyXText(BufferView * bv, InsetText * inset)
73 : height(0), width(0), anchor_row_offset_(0),
74 inset_owner(inset), the_locking_inset(0), bv_owner(bv)
76 anchor_row_ = rows().end();
81 void LyXText::init(BufferView * bview)
89 anchor_row_ = rows().end();
90 anchor_row_offset_ = 0;
92 ParagraphList::iterator pit = ownerParagraphs().begin();
93 ParagraphList::iterator end = ownerParagraphs().end();
95 current_font = getFont(bview->buffer(), pit, 0);
97 for (; pit != end; ++pit)
98 insertParagraph(pit, rowlist_.end());
100 setCursorIntern(rowlist_.begin()->par(), 0);
101 selection.cursor = cursor;
107 // Gets the fully instantiated font at a given position in a paragraph
108 // Basically the same routine as Paragraph::getFont() in paragraph.C.
109 // The difference is that this one is used for displaying, and thus we
110 // are allowed to make cosmetic improvements. For instance make footnotes
112 // If position is -1, we get the layout font of the paragraph.
113 // If position is -2, we get the font of the manual label of the paragraph.
114 LyXFont const LyXText::getFont(Buffer const * buf, ParagraphList::iterator pit,
119 LyXLayout_ptr const & layout = pit->layout();
121 // We specialize the 95% common case:
122 if (!pit->getDepth()) {
123 if (layout->labeltype == LABEL_MANUAL
124 && pos < pit->beginningOfBody()) {
126 LyXFont f = pit->getFontSettings(buf->params, pos);
128 pit->inInset()->getDrawFont(f);
129 return f.realize(layout->reslabelfont);
131 LyXFont f = pit->getFontSettings(buf->params, pos);
133 pit->inInset()->getDrawFont(f);
134 return f.realize(layout->resfont);
138 // The uncommon case need not be optimized as much
142 if (pos < pit->beginningOfBody()) {
144 layoutfont = layout->labelfont;
147 layoutfont = layout->font;
150 LyXFont tmpfont = pit->getFontSettings(buf->params, pos);
151 tmpfont.realize(layoutfont);
154 pit->inInset()->getDrawFont(tmpfont);
156 // Realize with the fonts of lesser depth.
157 tmpfont.realize(outerFont(pit, ownerParagraphs()));
159 return realizeFont(tmpfont, buf->params);
163 LyXFont const LyXText::getLayoutFont(Buffer const * buf,
164 ParagraphList::iterator pit) const
166 LyXLayout_ptr const & layout = pit->layout();
168 if (!pit->getDepth()) {
169 return layout->resfont;
172 LyXFont font(layout->font);
173 // Realize with the fonts of lesser depth.
174 font.realize(outerFont(pit, ownerParagraphs()));
176 return realizeFont(font, buf->params);
180 LyXFont const LyXText::getLabelFont(Buffer const * buf,
181 ParagraphList::iterator pit) const
183 LyXLayout_ptr const & layout = pit->layout();
185 if (!pit->getDepth()) {
186 return layout->reslabelfont;
189 LyXFont font(layout->labelfont);
190 // Realize with the fonts of lesser depth.
191 font.realize(outerFont(pit, ownerParagraphs()));
193 return realizeFont(layout->labelfont, buf->params);
197 void LyXText::setCharFont(ParagraphList::iterator pit,
198 pos_type pos, LyXFont const & fnt,
201 Buffer const * buf = bv()->buffer();
202 LyXFont font = getFont(buf, pit, pos);
203 font.update(fnt, buf->params.language, toggleall);
204 // Let the insets convert their font
205 if (pit->isInset(pos)) {
206 InsetOld * inset = pit->getInset(pos);
207 if (isEditableInset(inset)) {
208 UpdatableInset * uinset =
209 static_cast<UpdatableInset *>(inset);
210 uinset->setFont(bv(), fnt, toggleall, true);
214 // Plug thru to version below:
215 setCharFont(buf, pit, pos, font);
219 void LyXText::setCharFont(Buffer const * buf, ParagraphList::iterator pit,
220 pos_type pos, LyXFont const & fnt)
224 LyXTextClass const & tclass = buf->params.getLyXTextClass();
225 LyXLayout_ptr const & layout = pit->layout();
227 // Get concrete layout font to reduce against
230 if (pos < pit->beginningOfBody())
231 layoutfont = layout->labelfont;
233 layoutfont = layout->font;
235 // Realize against environment font information
236 if (pit->getDepth()) {
237 ParagraphList::iterator tp = pit;
238 while (!layoutfont.resolved() &&
239 tp != ownerParagraphs().end() &&
241 tp = outerHook(tp, ownerParagraphs());
242 if (tp != ownerParagraphs().end())
243 layoutfont.realize(tp->layout()->font);
247 layoutfont.realize(tclass.defaultfont());
249 // Now, reduce font against full layout font
250 font.reduce(layoutfont);
252 pit->setFont(pos, font);
256 // removes the row and reset the touched counters
257 void LyXText::removeRow(RowList::iterator rit)
259 if (anchor_row_ == rit) {
260 if (rit != rows().begin()) {
261 anchor_row_ = boost::prior(rit);
262 anchor_row_offset_ += anchor_row_->height();
264 anchor_row_ = boost::next(rit);
265 anchor_row_offset_ -= rit->height();
269 // the text becomes smaller
270 height -= rit->height();
276 // remove all following rows of the paragraph of the specified row.
277 void LyXText::removeParagraph(RowList::iterator rit)
279 ParagraphList::iterator tmppit = rit->par();
282 while (rit != rows().end() && rit->par() == tmppit) {
283 RowList::iterator tmprit = boost::next(rit);
290 void LyXText::insertParagraph(ParagraphList::iterator pit,
291 RowList::iterator rowit)
293 // insert a new row, starting at position 0
295 RowList::iterator rit = rowlist_.insert(rowit, newrow);
297 // and now append the whole paragraph before the new row
298 appendParagraph(rit);
302 InsetOld * LyXText::getInset() const
304 ParagraphList::iterator pit = cursor.par();
305 pos_type const pos = cursor.pos();
307 if (pos < pit->size() && pit->isInset(pos)) {
308 return pit->getInset(pos);
314 void LyXText::toggleInset()
316 InsetOld * inset = getInset();
317 // is there an editable inset at cursor position?
318 if (!isEditableInset(inset)) {
319 // No, try to see if we are inside a collapsable inset
320 if (inset_owner && inset_owner->owner()
321 && inset_owner->owner()->isOpen()) {
322 bv()->unlockInset(inset_owner->owner());
323 inset_owner->owner()->close(bv());
324 bv()->getLyXText()->cursorRight(bv());
328 //bv()->owner()->message(inset->editMessage());
330 // do we want to keep this?? (JMarc)
331 if (!isHighlyEditableInset(inset))
332 recordUndo(bv(), Undo::ATOMIC);
334 if (inset->isOpen()) {
340 bv()->updateInset(inset);
344 /* used in setlayout */
345 // Asger is not sure we want to do this...
346 void LyXText::makeFontEntriesLayoutSpecific(Buffer const & buf,
349 LyXLayout_ptr const & layout = par.layout();
350 pos_type const psize = par.size();
353 for (pos_type pos = 0; pos < psize; ++pos) {
354 if (pos < par.beginningOfBody())
355 layoutfont = layout->labelfont;
357 layoutfont = layout->font;
359 LyXFont tmpfont = par.getFontSettings(buf.params, pos);
360 tmpfont.reduce(layoutfont);
361 par.setFont(pos, tmpfont);
366 ParagraphList::iterator
367 LyXText::setLayout(LyXCursor & cur, LyXCursor & sstart_cur,
368 LyXCursor & send_cur,
369 string const & layout)
371 ParagraphList::iterator endpit = boost::next(send_cur.par());
372 ParagraphList::iterator undoendpit = endpit;
373 ParagraphList::iterator pars_end = ownerParagraphs().end();
375 if (endpit != pars_end && endpit->getDepth()) {
376 while (endpit != pars_end && endpit->getDepth()) {
380 } else if (endpit != pars_end) {
381 // because of parindents etc.
385 recordUndo(bv(), Undo::ATOMIC, sstart_cur.par(), boost::prior(undoendpit));
387 // ok we have a selection. This is always between sstart_cur
388 // and sel_end cursor
390 ParagraphList::iterator pit = sstart_cur.par();
391 ParagraphList::iterator epit = boost::next(send_cur.par());
393 LyXLayout_ptr const & lyxlayout =
394 bv()->buffer()->params.getLyXTextClass()[layout];
397 pit->applyLayout(lyxlayout);
398 makeFontEntriesLayoutSpecific(*bv()->buffer(), *pit);
399 ParagraphList::iterator fppit = pit;
400 fppit->params().spaceTop(lyxlayout->fill_top ?
401 VSpace(VSpace::VFILL)
402 : VSpace(VSpace::NONE));
403 fppit->params().spaceBottom(lyxlayout->fill_bottom ?
404 VSpace(VSpace::VFILL)
405 : VSpace(VSpace::NONE));
406 if (lyxlayout->margintype == MARGIN_MANUAL)
407 pit->setLabelWidthString(lyxlayout->labelstring());
410 } while (pit != epit);
416 // set layout over selection and make a total rebreak of those paragraphs
417 void LyXText::setLayout(string const & layout)
419 LyXCursor tmpcursor = cursor; // store the current cursor
421 // if there is no selection just set the layout
422 // of the current paragraph
423 if (!selection.set()) {
424 selection.start = cursor; // dummy selection
425 selection.end = cursor;
428 // special handling of new environment insets
429 BufferParams const & params = bv()->buffer()->params;
430 LyXLayout_ptr const & lyxlayout = params.getLyXTextClass()[layout];
431 if (lyxlayout->is_environment) {
432 // move everything in a new environment inset
433 lyxerr << "setting layout " << layout << endl;
434 bv()->owner()->dispatch(FuncRequest(LFUN_HOME));
435 bv()->owner()->dispatch(FuncRequest(LFUN_ENDSEL));
436 bv()->owner()->dispatch(FuncRequest(LFUN_CUT));
437 InsetOld * inset = new InsetEnvironment(params, layout);
438 if (bv()->insertInset(inset)) {
440 //bv()->owner()->dispatch(FuncRequest(LFUN_PASTE));
447 ParagraphList::iterator endpit = setLayout(cursor, selection.start,
448 selection.end, layout);
449 redoParagraphs(selection.start, endpit);
451 // we have to reset the selection, because the
452 // geometry could have changed
453 setCursor(selection.start.par(), selection.start.pos(), false);
454 selection.cursor = cursor;
455 setCursor(selection.end.par(), selection.end.pos(), false);
459 setCursor(tmpcursor.par(), tmpcursor.pos(), true);
463 bool LyXText::changeDepth(bv_funcs::DEPTH_CHANGE type, bool test_only)
465 ParagraphList::iterator pit(cursor.par());
466 ParagraphList::iterator end(cursor.par());
467 ParagraphList::iterator start = pit;
469 if (selection.set()) {
470 pit = selection.start.par();
471 end = selection.end.par();
475 ParagraphList::iterator pastend = boost::next(end);
478 recordUndo(bv(), Undo::ATOMIC, start, end);
480 bool changed = false;
482 int prev_after_depth = 0;
483 #warning parlist ... could be nicer ?
484 if (start != ownerParagraphs().begin()) {
485 prev_after_depth = boost::prior(start)->getMaxDepthAfter();
489 int const depth = pit->params().depth();
490 if (type == bv_funcs::INC_DEPTH) {
491 if (depth < prev_after_depth
492 && pit->layout()->labeltype != LABEL_BIBLIO) {
495 pit->params().depth(depth + 1);
502 pit->params().depth(depth - 1);
505 prev_after_depth = pit->getMaxDepthAfter();
517 // Wow, redoParagraphs is stupid.
519 setCursor(tmpcursor, start, 0);
521 redoParagraphs(tmpcursor, pastend);
523 // We need to actually move the text->cursor. I don't
524 // understand why ...
527 // we have to reset the visual selection because the
528 // geometry could have changed
529 if (selection.set()) {
530 setCursor(selection.start.par(), selection.start.pos());
531 selection.cursor = cursor;
532 setCursor(selection.end.par(), selection.end.pos());
535 // this handles the counter labels, and also fixes up
536 // depth values for follow-on (child) paragraphs
540 setCursor(tmpcursor.par(), tmpcursor.pos());
546 // set font over selection and make a total rebreak of those paragraphs
547 void LyXText::setFont(LyXFont const & font, bool toggleall)
549 // if there is no selection just set the current_font
550 if (!selection.set()) {
551 // Determine basis font
553 if (cursor.pos() < cursor.par()->beginningOfBody()) {
554 layoutfont = getLabelFont(bv()->buffer(),
557 layoutfont = getLayoutFont(bv()->buffer(),
560 // Update current font
561 real_current_font.update(font,
562 bv()->buffer()->params.language,
565 // Reduce to implicit settings
566 current_font = real_current_font;
567 current_font.reduce(layoutfont);
568 // And resolve it completely
569 real_current_font.realize(layoutfont);
574 LyXCursor tmpcursor = cursor; // store the current cursor
576 // ok we have a selection. This is always between sel_start_cursor
577 // and sel_end cursor
579 recordUndo(bv(), Undo::ATOMIC, selection.start.par(), selection.end.par());
581 cursor = selection.start;
582 while (cursor.par() != selection.end.par() ||
583 cursor.pos() < selection.end.pos())
585 if (cursor.pos() < cursor.par()->size()) {
586 // an open footnote should behave like a closed one
587 setCharFont(cursor.par(), cursor.pos(),
589 cursor.pos(cursor.pos() + 1);
592 cursor.par(boost::next(cursor.par()));
597 redoParagraphs(selection.start, boost::next(selection.end.par()));
599 // we have to reset the selection, because the
600 // geometry could have changed, but we keep
601 // it for user convenience
602 setCursor(selection.start.par(), selection.start.pos());
603 selection.cursor = cursor;
604 setCursor(selection.end.par(), selection.end.pos());
606 setCursor(tmpcursor.par(), tmpcursor.pos(), true,
607 tmpcursor.boundary());
611 void LyXText::redoHeightOfParagraph()
613 RowList::iterator tmprow = cursorRow();
615 setHeightOfRow(tmprow);
617 while (tmprow != rows().begin()
618 && boost::prior(tmprow)->par() == tmprow->par()) {
620 setHeightOfRow(tmprow);
625 setCursor(cursor.par(), cursor.pos(), false, cursor.boundary());
629 // deletes and inserts again all paragraphs between the cursor
630 // and the specified par
631 // This function is needed after SetLayout and SetFont etc.
632 void LyXText::redoParagraphs(LyXCursor const & cur,
633 ParagraphList::iterator endpit)
635 RowList::iterator tmprit = getRow(cur);
637 ParagraphList::iterator first_phys_pit;
638 RowList::iterator prevrit;
639 if (tmprit == rows().begin()) {
640 // A trick/hack for UNDO.
641 // This is needed because in an UNDO/REDO we could have
642 // changed the ownerParagraph() so the paragraph inside
643 // the row is NOT my really first par anymore.
644 // Got it Lars ;) (Jug 20011206)
645 first_phys_pit = ownerParagraphs().begin();
646 prevrit = rows().end();
648 first_phys_pit = tmprit->par();
649 while (tmprit != rows().begin()
650 && boost::prior(tmprit)->par() == first_phys_pit)
654 prevrit = boost::prior(tmprit);
658 while (tmprit != rows().end() && tmprit->par() != endpit) {
659 RowList::iterator tmprit2 = tmprit++;
663 // Reinsert the paragraphs.
664 ParagraphList::iterator tmppit = first_phys_pit;
666 while (tmppit != ownerParagraphs().end()) {
667 insertParagraph(tmppit, tmprit);
668 while (tmprit != rows().end()
669 && tmprit->par() == tmppit) {
673 if (tmppit == endpit)
676 if (prevrit != rows().end())
677 setHeightOfRow(prevrit);
679 setHeightOfRow(rows().begin());
681 if (tmprit != rows().end())
682 setHeightOfRow(tmprit);
688 void LyXText::fullRebreak()
691 setCursorIntern(cursor.par(), cursor.pos());
695 void LyXText::metrics(MetricsInfo & mi, Dimension & dim)
697 //lyxerr << "LyXText::metrics: width: " << mi.base.textwidth << "\n";
703 anchor_row_ = rows().end();
704 anchor_row_offset_ = 0;
706 ParagraphList::iterator pit = ownerParagraphs().begin();
707 ParagraphList::iterator end = ownerParagraphs().end();
709 for (; pit != end; ++pit) {
710 InsetList::iterator ii = pit->insetlist.begin();
711 InsetList::iterator iend = pit->insetlist.end();
712 for (; ii != iend; ++ii) {
715 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);
727 //lyxerr << "height 0: " << height << "\n";
728 //for (RowList::iterator rit = rows().begin(); rit != rows().end(); ++rit) {
729 // height += rit->height();
731 //lyxerr << "height 1: " << height << "\n";
734 dim.asc = rows().begin()->ascent_of_text();
735 dim.des = height - dim.asc;
736 dim.wid = std::max(mi.base.textwidth, int(width));
740 void LyXText::partialRebreak()
742 if (rows().empty()) {
746 breakAgain(rows().begin());
750 // important for the screen
753 // the cursor set functions have a special mechanism. When they
754 // realize, that you left an empty paragraph, they will delete it.
755 // They also delete the corresponding row
757 // need the selection cursor:
758 void LyXText::setSelection()
760 bool const lsel = TextCursor::setSelection();
762 if (inset_owner && (selection.set() || lsel))
763 inset_owner->setUpdateStatus(InsetText::SELECTION);
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;
850 inset_owner->setUpdateStatus(InsetText::CURSOR_PAR);
854 string LyXText::getStringToIndex()
856 // Try implicit word selection
857 // If there is a change in the language the implicit word selection
859 LyXCursor const reset_cursor = cursor;
860 bool const implicitSelection =
861 selectWordWhenUnderCursor(lyx::PREVIOUS_WORD);
864 if (!selection.set())
865 bv()->owner()->message(_("Nothing to index!"));
866 else if (selection.start.par() != selection.end.par())
867 bv()->owner()->message(_("Cannot index more than one paragraph!"));
869 idxstring = selectionAsString(bv()->buffer(), false);
871 // Reset cursors to their original position.
872 cursor = reset_cursor;
873 setCursor(cursor.par(), cursor.pos());
874 selection.cursor = cursor;
876 // Clear the implicit selection.
877 if (implicitSelection)
884 // the DTP switches for paragraphs. LyX will store them in the first
885 // physicla paragraph. When a paragraph is broken, the top settings rest,
886 // the bottom settings are given to the new one. So I can make shure,
887 // they do not duplicate themself and you cannnot make dirty things with
890 void LyXText::setParagraph(bool line_top, bool line_bottom,
891 bool pagebreak_top, bool pagebreak_bottom,
892 VSpace const & space_top,
893 VSpace const & space_bottom,
894 Spacing const & spacing,
896 string const & labelwidthstring,
899 LyXCursor tmpcursor = cursor;
900 if (!selection.set()) {
901 selection.start = cursor;
902 selection.end = cursor;
905 // make sure that the depth behind the selection are restored, too
906 ParagraphList::iterator endpit = boost::next(selection.end.par());
907 ParagraphList::iterator undoendpit = endpit;
908 ParagraphList::iterator pars_end = ownerParagraphs().end();
910 if (endpit != pars_end && endpit->getDepth()) {
911 while (endpit != pars_end && endpit->getDepth()) {
915 } else if (endpit != pars_end) {
916 // because of parindents etc.
920 recordUndo(bv(), Undo::ATOMIC, selection.start.par(),
921 boost::prior(undoendpit));
924 ParagraphList::iterator tmppit = selection.end.par();
926 while (tmppit != boost::prior(selection.start.par())) {
927 setCursor(tmppit, 0);
929 ParagraphList::iterator pit = cursor.par();
930 ParagraphParameters & params = pit->params();
932 params.lineTop(line_top);
933 params.lineBottom(line_bottom);
934 params.pagebreakTop(pagebreak_top);
935 params.pagebreakBottom(pagebreak_bottom);
936 params.spaceTop(space_top);
937 params.spaceBottom(space_bottom);
938 params.spacing(spacing);
939 // does the layout allow the new alignment?
940 LyXLayout_ptr const & layout = pit->layout();
942 if (align == LYX_ALIGN_LAYOUT)
943 align = layout->align;
944 if (align & layout->alignpossible) {
945 if (align == layout->align)
946 params.align(LYX_ALIGN_LAYOUT);
950 pit->setLabelWidthString(labelwidthstring);
951 params.noindent(noindent);
952 tmppit = boost::prior(pit);
956 redoParagraphs(selection.start, endpit);
959 setCursor(selection.start.par(), selection.start.pos());
960 selection.cursor = cursor;
961 setCursor(selection.end.par(), selection.end.pos());
963 setCursor(tmpcursor.par(), tmpcursor.pos());
965 bv()->updateInset(inset_owner);
969 // set the counter of a paragraph. This includes the labels
970 void LyXText::setCounter(Buffer const * buf, ParagraphList::iterator pit)
972 LyXTextClass const & textclass = buf->params.getLyXTextClass();
973 LyXLayout_ptr const & layout = pit->layout();
975 if (pit != ownerParagraphs().begin()) {
977 pit->params().appendix(boost::prior(pit)->params().appendix());
978 if (!pit->params().appendix() &&
979 pit->params().startOfAppendix()) {
980 pit->params().appendix(true);
981 textclass.counters().reset();
983 pit->enumdepth = boost::prior(pit)->enumdepth;
984 pit->itemdepth = boost::prior(pit)->itemdepth;
986 pit->params().appendix(pit->params().startOfAppendix());
991 /* Maybe we have to increment the enumeration depth.
992 * BUT, enumeration in a footnote is considered in isolation from its
993 * surrounding paragraph so don't increment if this is the
994 * first line of the footnote
995 * AND, bibliographies can't have their depth changed ie. they
996 * are always of depth 0
998 if (pit != ownerParagraphs().begin()
999 && boost::prior(pit)->getDepth() < pit->getDepth()
1000 && boost::prior(pit)->layout()->labeltype == LABEL_COUNTER_ENUMI
1001 && pit->enumdepth < 3
1002 && layout->labeltype != LABEL_BIBLIO) {
1006 // Maybe we have to decrement the enumeration depth, see note above
1007 if (pit != ownerParagraphs().begin()
1008 && boost::prior(pit)->getDepth() > pit->getDepth()
1009 && layout->labeltype != LABEL_BIBLIO) {
1010 pit->enumdepth = depthHook(pit, ownerParagraphs(),
1011 pit->getDepth())->enumdepth;
1014 if (!pit->params().labelString().empty()) {
1015 pit->params().labelString(string());
1018 if (layout->margintype == MARGIN_MANUAL) {
1019 if (pit->params().labelWidthString().empty()) {
1020 pit->setLabelWidthString(layout->labelstring());
1023 pit->setLabelWidthString(string());
1026 // is it a layout that has an automatic label?
1027 if (layout->labeltype >= LABEL_COUNTER_CHAPTER) {
1028 int const i = layout->labeltype - LABEL_COUNTER_CHAPTER;
1032 if (i >= 0 && i <= buf->params.secnumdepth) {
1036 textclass.counters().step(layout->latexname());
1038 // Is there a label? Useful for Chapter layout
1039 if (!pit->params().appendix()) {
1040 s << buf->B_(layout->labelstring());
1042 s << buf->B_(layout->labelstring_appendix());
1045 // Use of an integer is here less than elegant. For now.
1046 int head = textclass.maxcounter() - LABEL_COUNTER_CHAPTER;
1047 if (!pit->params().appendix()) {
1048 numbertype = "sectioning";
1050 numbertype = "appendix";
1051 if (pit->isRightToLeftPar(buf->params))
1052 langtype = "hebrew";
1058 << textclass.counters()
1059 .numberLabel(layout->latexname(),
1060 numbertype, langtype, head);
1062 pit->params().labelString(STRCONV(s.str()));
1064 // reset enum counters
1065 textclass.counters().reset("enum");
1066 } else if (layout->labeltype < LABEL_COUNTER_ENUMI) {
1067 textclass.counters().reset("enum");
1068 } else if (layout->labeltype == LABEL_COUNTER_ENUMI) {
1070 // Yes I know this is a really, really! bad solution
1072 string enumcounter("enum");
1074 switch (pit->enumdepth) {
1083 enumcounter += "iv";
1086 // not a valid enumdepth...
1090 textclass.counters().step(enumcounter);
1092 s << textclass.counters()
1093 .numberLabel(enumcounter, "enumeration");
1094 pit->params().labelString(STRCONV(s.str()));
1096 } else if (layout->labeltype == LABEL_BIBLIO) {// ale970302
1097 textclass.counters().step("bibitem");
1098 int number = textclass.counters().value("bibitem");
1099 if (pit->bibitem()) {
1100 pit->bibitem()->setCounter(number);
1101 pit->params().labelString(layout->labelstring());
1103 // In biblio should't be following counters but...
1105 string s = buf->B_(layout->labelstring());
1107 // the caption hack:
1108 if (layout->labeltype == LABEL_SENSITIVE) {
1109 ParagraphList::iterator tmppit = pit;
1112 while (tmppit != ownerParagraphs().end() &&
1114 // the single '=' is intended below
1115 && (in = tmppit->inInset()->owner())) {
1116 if (in->lyxCode() == InsetOld::FLOAT_CODE ||
1117 in->lyxCode() == InsetOld::WRAP_CODE) {
1121 tmppit = std::find(ownerParagraphs().begin(), ownerParagraphs().end(), *in->parOwner());
1128 if (in->lyxCode() == InsetOld::FLOAT_CODE)
1129 type = static_cast<InsetFloat*>(in)->params().type;
1130 else if (in->lyxCode() == InsetOld::WRAP_CODE)
1131 type = static_cast<InsetWrap*>(in)->params().type;
1135 Floating const & fl = textclass.floats().getType(type);
1137 textclass.counters().step(fl.type());
1139 // Doesn't work... yet.
1140 s = bformat(_("%1$s #:"), buf->B_(fl.name()));
1142 // par->SetLayout(0);
1143 // s = layout->labelstring;
1144 s = _("Senseless: ");
1147 pit->params().labelString(s);
1149 // reset the enumeration counter. They are always reset
1150 // when there is any other layout between
1151 // Just fall-through between the cases so that all
1152 // enum counters deeper than enumdepth is also reset.
1153 switch (pit->enumdepth) {
1155 textclass.counters().reset("enumi");
1157 textclass.counters().reset("enumii");
1159 textclass.counters().reset("enumiii");
1161 textclass.counters().reset("enumiv");
1167 // Updates all counters. Paragraphs with changed label string will be rebroken
1168 void LyXText::updateCounters()
1170 RowList::iterator rowit = rows().begin();
1171 ParagraphList::iterator pit = rowit->par();
1173 // CHECK if this is really needed. (Lgb)
1174 bv()->buffer()->params.getLyXTextClass().counters().reset();
1176 ParagraphList::iterator beg = ownerParagraphs().begin();
1177 ParagraphList::iterator end = ownerParagraphs().end();
1178 for (; pit != end; ++pit) {
1179 while (rowit->par() != pit)
1182 string const oldLabel = pit->params().labelString();
1184 size_t maxdepth = 0;
1186 maxdepth = boost::prior(pit)->getMaxDepthAfter();
1188 if (pit->params().depth() > maxdepth)
1189 pit->params().depth(maxdepth);
1191 // setCounter can potentially change the labelString.
1192 setCounter(bv()->buffer(), pit);
1194 string const & newLabel = pit->params().labelString();
1196 if (oldLabel.empty() && !newLabel.empty()) {
1197 removeParagraph(rowit);
1198 appendParagraph(rowit);
1204 void LyXText::insertInset(InsetOld * inset)
1206 if (!cursor.par()->insetAllowed(inset->lyxCode()))
1208 recordUndo(bv(), Undo::ATOMIC, cursor.par());
1210 cursor.par()->insertInset(cursor.pos(), inset);
1211 // Just to rebreak and refresh correctly.
1212 // The character will not be inserted a second time
1213 insertChar(Paragraph::META_INSET);
1214 // If we enter a highly editable inset the cursor should be to before
1215 // the inset. This couldn't happen before as Undo was not handled inside
1216 // inset now after the Undo LyX tries to call inset->Edit(...) again
1217 // and cannot do this as the cursor is behind the inset and GetInset
1218 // does not return the inset!
1219 if (isHighlyEditableInset(inset)) {
1226 void LyXText::cutSelection(bool doclear, bool realcut)
1228 // Stuff what we got on the clipboard. Even if there is no selection.
1230 // There is a problem with having the stuffing here in that the
1231 // larger the selection the slower LyX will get. This can be
1232 // solved by running the line below only when the selection has
1233 // finished. The solution used currently just works, to make it
1234 // faster we need to be more clever and probably also have more
1235 // calls to stuffClipboard. (Lgb)
1236 bv()->stuffClipboard(selectionAsString(bv()->buffer(), true));
1238 // This doesn't make sense, if there is no selection
1239 if (!selection.set())
1242 // OK, we have a selection. This is always between selection.start
1243 // and selection.end
1245 // make sure that the depth behind the selection are restored, too
1246 ParagraphList::iterator endpit = boost::next(selection.end.par());
1247 ParagraphList::iterator undoendpit = endpit;
1248 ParagraphList::iterator pars_end = ownerParagraphs().end();
1250 if (endpit != pars_end && endpit->getDepth()) {
1251 while (endpit != pars_end && endpit->getDepth()) {
1253 undoendpit = endpit;
1255 } else if (endpit != pars_end) {
1256 // because of parindents etc.
1260 recordUndo(bv(), Undo::DELETE, selection.start.par(),
1261 boost::prior(undoendpit));
1264 endpit = selection.end.par();
1265 int endpos = selection.end.pos();
1267 boost::tie(endpit, endpos) = realcut ?
1268 CutAndPaste::cutSelection(bv()->buffer()->params,
1270 selection.start.par(), endpit,
1271 selection.start.pos(), endpos,
1272 bv()->buffer()->params.textclass,
1274 : CutAndPaste::eraseSelection(bv()->buffer()->params,
1276 selection.start.par(), endpit,
1277 selection.start.pos(), endpos,
1279 // sometimes necessary
1281 selection.start.par()->stripLeadingSpaces();
1283 redoParagraphs(selection.start, boost::next(endpit));
1284 #warning FIXME latent bug
1285 // endpit will be invalidated on redoParagraphs once ParagraphList
1286 // becomes a std::list? There are maybe other places on which this
1287 // can happend? (Ab)
1288 // cutSelection can invalidate the cursor so we need to set
1290 // we prefer the end for when tracking changes
1294 // need a valid cursor. (Lgb)
1297 setCursor(cursor.par(), cursor.pos());
1298 selection.cursor = cursor;
1303 void LyXText::copySelection()
1305 // stuff the selection onto the X clipboard, from an explicit copy request
1306 bv()->stuffClipboard(selectionAsString(bv()->buffer(), true));
1308 // this doesnt make sense, if there is no selection
1309 if (!selection.set())
1312 // ok we have a selection. This is always between selection.start
1313 // and sel_end cursor
1315 // copy behind a space if there is one
1316 while (selection.start.par()->size() > selection.start.pos()
1317 && selection.start.par()->isLineSeparator(selection.start.pos())
1318 && (selection.start.par() != selection.end.par()
1319 || selection.start.pos() < selection.end.pos()))
1320 selection.start.pos(selection.start.pos() + 1);
1322 CutAndPaste::copySelection(selection.start.par(),
1323 selection.end.par(),
1324 selection.start.pos(), selection.end.pos(),
1325 bv()->buffer()->params.textclass);
1329 void LyXText::pasteSelection(size_t sel_index)
1331 // this does not make sense, if there is nothing to paste
1332 if (!CutAndPaste::checkPastePossible())
1335 recordUndo(bv(), Undo::INSERT, cursor.par());
1337 ParagraphList::iterator endpit;
1342 boost::tie(ppp, endpit) =
1343 CutAndPaste::pasteSelection(*bv()->buffer(),
1345 cursor.par(), cursor.pos(),
1346 bv()->buffer()->params.textclass,
1348 bufferErrors(*bv()->buffer(), el);
1349 bv()->showErrorList(_("Paste"));
1351 redoParagraphs(cursor, endpit);
1353 setCursor(cursor.par(), cursor.pos());
1356 selection.cursor = cursor;
1357 setCursor(ppp.first, ppp.second);
1363 void LyXText::setSelectionRange(lyx::pos_type length)
1368 selection.cursor = cursor;
1375 // simple replacing. The font of the first selected character is used
1376 void LyXText::replaceSelectionWithString(string const & str)
1378 recordUndo(bv(), Undo::ATOMIC);
1381 if (!selection.set()) { // create a dummy selection
1382 selection.end = cursor;
1383 selection.start = cursor;
1386 // Get font setting before we cut
1387 pos_type pos = selection.end.pos();
1388 LyXFont const font = selection.start.par()
1389 ->getFontSettings(bv()->buffer()->params,
1390 selection.start.pos());
1392 // Insert the new string
1393 string::const_iterator cit = str.begin();
1394 string::const_iterator end = str.end();
1395 for (; cit != end; ++cit) {
1396 selection.end.par()->insertChar(pos, (*cit), font);
1400 // Cut the selection
1401 cutSelection(true, false);
1407 // needed to insert the selection
1408 void LyXText::insertStringAsLines(string const & str)
1410 ParagraphList::iterator pit = cursor.par();
1411 pos_type pos = cursor.pos();
1412 ParagraphList::iterator endpit = boost::next(cursor.par());
1414 recordUndo(bv(), Undo::ATOMIC);
1416 // only to be sure, should not be neccessary
1419 bv()->buffer()->insertStringAsLines(pit, pos, current_font, str);
1421 redoParagraphs(cursor, endpit);
1422 setCursor(cursor.par(), cursor.pos());
1423 selection.cursor = cursor;
1424 setCursor(pit, pos);
1429 // turns double-CR to single CR, others where converted into one
1430 // blank. Then InsertStringAsLines is called
1431 void LyXText::insertStringAsParagraphs(string const & str)
1433 string linestr(str);
1434 bool newline_inserted = false;
1435 string::size_type const siz = linestr.length();
1437 for (string::size_type i = 0; i < siz; ++i) {
1438 if (linestr[i] == '\n') {
1439 if (newline_inserted) {
1440 // we know that \r will be ignored by
1441 // InsertStringA. Of course, it is a dirty
1442 // trick, but it works...
1443 linestr[i - 1] = '\r';
1447 newline_inserted = true;
1449 } else if (IsPrintable(linestr[i])) {
1450 newline_inserted = false;
1453 insertStringAsLines(linestr);
1457 void LyXText::checkParagraph(ParagraphList::iterator pit, pos_type pos)
1459 LyXCursor tmpcursor;
1462 RowList::iterator row = getRow(pit, pos);
1463 RowList::iterator beg = rows().begin();
1465 // is there a break one row above
1466 if (row != beg && boost::prior(row)->par() == row->par()) {
1467 z = rowBreakPoint(*boost::prior(row));
1468 if (z >= row->pos()) {
1469 // set the dimensions of the row above
1472 breakAgain(boost::prior(row));
1474 // set the cursor again. Otherwise
1475 // dangling pointers are possible
1476 setCursor(cursor.par(), cursor.pos(),
1477 false, cursor.boundary());
1478 selection.cursor = cursor;
1486 // set the cursor again. Otherwise dangling pointers are possible
1487 // also set the selection
1489 if (selection.set()) {
1491 setCursorIntern(selection.cursor.par(), selection.cursor.pos(),
1492 false, selection.cursor.boundary());
1493 selection.cursor = cursor;
1494 setCursorIntern(selection.start.par(),
1495 selection.start.pos(),
1496 false, selection.start.boundary());
1497 selection.start = cursor;
1498 setCursorIntern(selection.end.par(),
1499 selection.end.pos(),
1500 false, selection.end.boundary());
1501 selection.end = cursor;
1502 setCursorIntern(last_sel_cursor.par(),
1503 last_sel_cursor.pos(),
1504 false, last_sel_cursor.boundary());
1505 last_sel_cursor = cursor;
1508 setCursorIntern(cursor.par(), cursor.pos(),
1509 false, cursor.boundary());
1513 // returns false if inset wasn't found
1514 bool LyXText::updateInset(InsetOld * inset)
1516 // first check the current paragraph
1517 int pos = cursor.par()->getPositionOfInset(inset);
1519 checkParagraph(cursor.par(), pos);
1523 // check every paragraph
1525 ParagraphList::iterator par = ownerParagraphs().begin();
1526 ParagraphList::iterator end = ownerParagraphs().end();
1527 for (; par != end; ++par) {
1528 pos = par->getPositionOfInset(inset);
1530 checkParagraph(par, pos);
1539 bool LyXText::setCursor(ParagraphList::iterator pit,
1541 bool setfont, bool boundary)
1543 LyXCursor old_cursor = cursor;
1544 setCursorIntern(pit, pos, setfont, boundary);
1545 return deleteEmptyParagraphMechanism(old_cursor);
1549 void LyXText::setCursor(LyXCursor & cur, ParagraphList::iterator pit,
1550 pos_type pos, bool boundary)
1552 Assert(pit != ownerParagraphs().end());
1556 cur.boundary(boundary);
1560 // get the cursor y position in text
1562 RowList::iterator row = getRow(pit, pos, y);
1563 RowList::iterator beg = rows().begin();
1565 RowList::iterator old_row = row;
1566 // if we are before the first char of this row and are still in the
1567 // same paragraph and there is a previous row then put the cursor on
1568 // the end of the previous row
1569 cur.iy(y + row->baseline());
1572 boost::prior(row)->par() == row->par() &&
1573 pos < pit->size() &&
1574 pit->getChar(pos) == Paragraph::META_INSET) {
1575 InsetOld * ins = pit->getInset(pos);
1576 if (ins && (ins->needFullRow() || ins->display())) {
1582 // y is now the beginning of the cursor row
1583 y += row->baseline();
1584 // y is now the cursor baseline
1587 pos_type last = lastPrintablePos(*this, old_row);
1589 // None of these should happen, but we're scaredy-cats
1590 if (pos > pit->size()) {
1591 lyxerr << "dont like 1 please report" << endl;
1594 } else if (pos > last + 1) {
1595 lyxerr << "dont like 2 please report" << endl;
1596 // This shouldn't happen.
1599 } else if (pos < row->pos()) {
1600 lyxerr << "dont like 3 please report" << endl;
1605 // now get the cursors x position
1606 float x = getCursorX(row, pos, last, boundary);
1609 if (old_row != row) {
1610 x = getCursorX(old_row, pos, last, boundary);
1614 /* We take out this for the time being because 1) the redraw code is not
1615 prepared to this yet and 2) because some good policy has yet to be decided
1616 while editting: for instance how to act on rows being created/deleted
1620 //if the cursor is in a visible row, anchor to it
1622 if (topy < y && y < topy + bv()->workHeight())
1628 float LyXText::getCursorX(RowList::iterator rit,
1629 pos_type pos, pos_type last, bool boundary) const
1631 pos_type cursor_vpos = 0;
1635 int fill_label_hfill;
1636 // This call HAS to be here because of the BidiTables!!!
1637 prepareToPrint(rit, x, fill_separator, fill_hfill,
1640 ParagraphList::iterator rit_par = rit->par();
1641 pos_type const rit_pos = rit->pos();
1644 cursor_vpos = rit_pos;
1645 else if (pos > last && !boundary)
1646 cursor_vpos = (rit_par->isRightToLeftPar(bv()->buffer()->params))
1647 ? rit_pos : last + 1;
1648 else if (pos > rit_pos && (pos > last || boundary))
1649 /// Place cursor after char at (logical) position pos - 1
1650 cursor_vpos = (bidi_level(pos - 1) % 2 == 0)
1651 ? log2vis(pos - 1) + 1 : log2vis(pos - 1);
1653 /// Place cursor before char at (logical) position pos
1654 cursor_vpos = (bidi_level(pos) % 2 == 0)
1655 ? log2vis(pos) : log2vis(pos) + 1;
1657 pos_type body_pos = rit_par->beginningOfBody();
1658 if ((body_pos > 0) &&
1659 ((body_pos - 1 > last) || !rit_par->isLineSeparator(body_pos - 1)))
1662 for (pos_type vpos = rit_pos; vpos < cursor_vpos; ++vpos) {
1663 pos_type pos = vis2log(vpos);
1664 if (body_pos > 0 && pos == body_pos - 1) {
1665 x += fill_label_hfill +
1666 font_metrics::width(
1667 rit_par->layout()->labelsep,
1668 getLabelFont(bv()->buffer(), rit_par));
1669 if (rit_par->isLineSeparator(body_pos - 1))
1670 x -= singleWidth(rit_par, body_pos - 1);
1673 if (hfillExpansion(*this, rit, pos)) {
1674 x += singleWidth(rit_par, pos);
1675 if (pos >= body_pos)
1678 x += fill_label_hfill;
1679 } else if (rit_par->isSeparator(pos)) {
1680 x += singleWidth(rit_par, pos);
1681 if (pos >= body_pos)
1682 x += fill_separator;
1684 x += singleWidth(rit_par, pos);
1690 void LyXText::setCursorIntern(ParagraphList::iterator pit,
1691 pos_type pos, bool setfont, bool boundary)
1693 UpdatableInset * it = pit->inInset();
1695 if (it != inset_owner) {
1696 lyxerr[Debug::INSETS] << "InsetText is " << it
1698 << "inset_owner is "
1699 << inset_owner << endl;
1700 #ifdef WITH_WARNINGS
1701 #warning I believe this code is wrong. (Lgb)
1702 #warning Jürgen, have a look at this. (Lgb)
1703 #warning Hmmm, I guess you are right but we
1704 #warning should verify when this is needed
1706 // Jürgen, would you like to have a look?
1707 // I guess we need to move the outer cursor
1708 // and open and lock the inset (bla bla bla)
1709 // stuff I don't know... so can you have a look?
1711 // I moved the lyxerr stuff in here so we can see if
1712 // this is actually really needed and where!
1714 // it->getLyXText(bv())->setCursorIntern(bv(), par, pos, setfont, boundary);
1719 setCursor(cursor, pit, pos, boundary);
1725 void LyXText::setCurrentFont()
1727 pos_type pos = cursor.pos();
1728 ParagraphList::iterator pit = cursor.par();
1730 if (cursor.boundary() && pos > 0)
1734 if (pos == pit->size())
1736 else // potentional bug... BUG (Lgb)
1737 if (pit->isSeparator(pos)) {
1738 if (pos > cursorRow()->pos() &&
1739 bidi_level(pos) % 2 ==
1740 bidi_level(pos - 1) % 2)
1742 else if (pos + 1 < pit->size())
1748 pit->getFontSettings(bv()->buffer()->params, pos);
1749 real_current_font = getFont(bv()->buffer(), pit, pos);
1751 if (cursor.pos() == pit->size() &&
1752 isBoundary(bv()->buffer(), *pit, cursor.pos()) &&
1753 !cursor.boundary()) {
1754 Language const * lang =
1755 pit->getParLanguage(bv()->buffer()->params);
1756 current_font.setLanguage(lang);
1757 current_font.setNumber(LyXFont::OFF);
1758 real_current_font.setLanguage(lang);
1759 real_current_font.setNumber(LyXFont::OFF);
1764 // returns the column near the specified x-coordinate of the row
1765 // x is set to the real beginning of this column
1767 LyXText::getColumnNearX(RowList::iterator rit, int & x, bool & boundary) const
1772 int fill_label_hfill;
1774 prepareToPrint(rit, tmpx, fill_separator, fill_hfill, fill_label_hfill);
1776 pos_type vc = rit->pos();
1777 pos_type last = lastPrintablePos(*this, rit);
1780 ParagraphList::iterator rit_par = rit->par();
1781 LyXLayout_ptr const & layout = rit->par()->layout();
1783 bool left_side = false;
1785 pos_type body_pos = rit_par->beginningOfBody();
1786 int last_tmpx = tmpx;
1789 (body_pos - 1 > last ||
1790 !rit_par->isLineSeparator(body_pos - 1)))
1793 // check for empty row
1794 if (!rit_par->size()) {
1799 while (vc <= last && tmpx <= x) {
1802 if (body_pos > 0 && c == body_pos - 1) {
1803 tmpx += fill_label_hfill +
1804 font_metrics::width(layout->labelsep,
1805 getLabelFont(bv()->buffer(), rit_par));
1806 if (rit_par->isLineSeparator(body_pos - 1))
1807 tmpx -= singleWidth(rit_par, body_pos - 1);
1810 if (hfillExpansion(*this, rit, c)) {
1811 tmpx += singleWidth(rit_par, c);
1815 tmpx += fill_label_hfill;
1816 } else if (rit_par->isSeparator(c)) {
1817 tmpx += singleWidth(rit_par, c);
1819 tmpx += fill_separator;
1821 tmpx += singleWidth(rit_par, c);
1826 if ((tmpx + last_tmpx) / 2 > x) {
1831 if (vc > last + 1) // This shouldn't happen.
1835 // This (rtl_support test) is not needed, but gives
1836 // some speedup if rtl_support=false
1837 RowList::iterator next_rit = boost::next(rit);
1839 bool const lastrow = lyxrc.rtl_support &&
1840 (next_rit == rowlist_.end() ||
1841 next_rit->par() != rit_par);
1843 // If lastrow is false, we don't need to compute
1844 // the value of rtl.
1845 bool const rtl = (lastrow)
1846 ? rit_par->isRightToLeftPar(bv()->buffer()->params)
1849 ((rtl && left_side && vc == rit->pos() && x < tmpx - 5) ||
1850 (!rtl && !left_side && vc == last + 1 && x > tmpx + 5)))
1852 else if (vc == rit->pos()) {
1854 if (bidi_level(c) % 2 == 1)
1857 c = vis2log(vc - 1);
1858 bool const rtl = (bidi_level(c) % 2 == 1);
1859 if (left_side == rtl) {
1861 boundary = isBoundary(bv()->buffer(), *rit_par, c);
1865 if (rit->pos() <= last && c > last
1866 && rit_par->isNewline(last)) {
1867 if (bidi_level(last) % 2 == 0)
1868 tmpx -= singleWidth(rit_par, last);
1870 tmpx += singleWidth(rit_par, last);
1880 void LyXText::setCursorFromCoordinates(int x, int y)
1882 //LyXCursor old_cursor = cursor;
1883 setCursorFromCoordinates(cursor, x, y);
1885 #warning DEPM disabled, otherwise crash when entering new table
1886 //deleteEmptyParagraphMechanism(old_cursor);
1893 * return true if the cursor given is at the end of a row,
1894 * and the next row is filled by an inset that spans an entire
1897 bool beforeFullRowInset(LyXText & lt, LyXCursor const & cur)
1899 RowList::iterator row = lt.getRow(cur);
1900 if (boost::next(row) == lt.rows().end())
1903 Row const & next = *boost::next(row);
1905 if (next.pos() != cur.pos() || next.par() != cur.par())
1908 if (cur.pos() == cur.par()->size()
1909 || !cur.par()->isInset(cur.pos()))
1912 InsetOld const * inset = cur.par()->getInset(cur.pos());
1913 if (inset->needFullRow() || inset->display())
1921 void LyXText::setCursorFromCoordinates(LyXCursor & cur, int x, int y)
1923 // Get the row first.
1925 RowList::iterator row = getRowNearY(y);
1927 pos_type const column = getColumnNearX(row, x, bound);
1928 cur.par(row->par());
1929 cur.pos(row->pos() + column);
1931 cur.y(y + row->baseline());
1933 if (beforeFullRowInset(*this, cur)) {
1934 pos_type const last = lastPrintablePos(*this, row);
1935 RowList::iterator next_row = boost::next(row);
1937 float x = getCursorX(next_row, cur.pos(), last, bound);
1939 cur.iy(y + row->height() + next_row->baseline());
1944 cur.boundary(bound);
1948 void LyXText::cursorLeft(bool internal)
1950 if (cursor.pos() > 0) {
1951 bool boundary = cursor.boundary();
1952 setCursor(cursor.par(), cursor.pos() - 1, true, false);
1953 if (!internal && !boundary &&
1954 isBoundary(bv()->buffer(), *cursor.par(), cursor.pos() + 1))
1955 setCursor(cursor.par(), cursor.pos() + 1, true, true);
1956 } else if (cursor.par() != ownerParagraphs().begin()) { // steps into the above paragraph.
1957 ParagraphList::iterator pit = boost::prior(cursor.par());
1958 setCursor(pit, pit->size());
1963 void LyXText::cursorRight(bool internal)
1965 bool const at_end = (cursor.pos() == cursor.par()->size());
1966 bool const at_newline = !at_end &&
1967 cursor.par()->isNewline(cursor.pos());
1969 if (!internal && cursor.boundary() && !at_newline)
1970 setCursor(cursor.par(), cursor.pos(), true, false);
1972 setCursor(cursor.par(), cursor.pos() + 1, true, false);
1974 isBoundary(bv()->buffer(), *cursor.par(), cursor.pos()))
1975 setCursor(cursor.par(), cursor.pos(), true, true);
1976 } else if (boost::next(cursor.par()) != ownerParagraphs().end())
1977 setCursor(boost::next(cursor.par()), 0);
1981 void LyXText::cursorUp(bool selecting)
1984 int x = cursor.x_fix();
1985 int y = cursor.y() - cursorRow()->baseline() - 1;
1986 setCursorFromCoordinates(x, y);
1989 int y1 = cursor.iy() - topy;
1992 InsetOld * inset_hit = checkInsetHit(x, y1);
1993 if (inset_hit && isHighlyEditableInset(inset_hit)) {
1994 inset_hit->localDispatch(
1995 FuncRequest(bv(), LFUN_INSET_EDIT, x, y - (y2 - y1), mouse_button::none));
1999 setCursorFromCoordinates(bv(), cursor.x_fix(),
2000 cursor.y() - cursorRow()->baseline() - 1);
2005 void LyXText::cursorDown(bool selecting)
2008 int x = cursor.x_fix();
2009 int y = cursor.y() - cursorRow()->baseline() + cursorRow()->height() + 1;
2010 setCursorFromCoordinates(x, y);
2011 if (!selecting && cursorRow() == cursorIRow()) {
2013 int y1 = cursor.iy() - topy;
2016 InsetOld * inset_hit = checkInsetHit(x, y1);
2017 if (inset_hit && isHighlyEditableInset(inset_hit)) {
2018 FuncRequest cmd(bv(), LFUN_INSET_EDIT, x, y - (y2 - y1), mouse_button::none);
2019 inset_hit->localDispatch(cmd);
2023 setCursorFromCoordinates(bv(), cursor.x_fix(),
2024 cursor.y() - cursorRow()->baseline()
2025 + cursorRow()->height() + 1);
2030 void LyXText::cursorUpParagraph()
2032 if (cursor.pos() > 0) {
2033 setCursor(cursor.par(), 0);
2035 else if (cursor.par() != ownerParagraphs().begin()) {
2036 setCursor(boost::prior(cursor.par()), 0);
2041 void LyXText::cursorDownParagraph()
2043 ParagraphList::iterator par = cursor.par();
2044 ParagraphList::iterator next_par = boost::next(par);
2046 if (next_par != ownerParagraphs().end()) {
2047 setCursor(next_par, 0);
2049 setCursor(par, par->size());
2053 // fix the cursor `cur' after a characters has been deleted at `where'
2054 // position. Called by deleteEmptyParagraphMechanism
2055 void LyXText::fixCursorAfterDelete(LyXCursor & cur,
2056 LyXCursor const & where)
2058 // if cursor is not in the paragraph where the delete occured,
2060 if (cur.par() != where.par())
2063 // if cursor position is after the place where the delete occured,
2065 if (cur.pos() > where.pos())
2066 cur.pos(cur.pos()-1);
2068 // check also if we don't want to set the cursor on a spot behind the
2069 // pagragraph because we erased the last character.
2070 if (cur.pos() > cur.par()->size())
2071 cur.pos(cur.par()->size());
2073 // recompute row et al. for this cursor
2074 setCursor(cur, cur.par(), cur.pos(), cur.boundary());
2078 bool LyXText::deleteEmptyParagraphMechanism(LyXCursor const & old_cursor)
2080 // Would be wrong to delete anything if we have a selection.
2081 if (selection.set())
2084 // We allow all kinds of "mumbo-jumbo" when freespacing.
2085 if (old_cursor.par()->layout()->free_spacing
2086 || old_cursor.par()->isFreeSpacing()) {
2090 /* Ok I'll put some comments here about what is missing.
2091 I have fixed BackSpace (and thus Delete) to not delete
2092 double-spaces automagically. I have also changed Cut,
2093 Copy and Paste to hopefully do some sensible things.
2094 There are still some small problems that can lead to
2095 double spaces stored in the document file or space at
2096 the beginning of paragraphs. This happens if you have
2097 the cursor betwenn to spaces and then save. Or if you
2098 cut and paste and the selection have a space at the
2099 beginning and then save right after the paste. I am
2100 sure none of these are very hard to fix, but I will
2101 put out 1.1.4pre2 with FIX_DOUBLE_SPACE defined so
2102 that I can get some feedback. (Lgb)
2105 // If old_cursor.pos() == 0 and old_cursor.pos()(1) == LineSeparator
2106 // delete the LineSeparator.
2109 // If old_cursor.pos() == 1 and old_cursor.pos()(0) == LineSeparator
2110 // delete the LineSeparator.
2113 // If the pos around the old_cursor were spaces, delete one of them.
2114 if (old_cursor.par() != cursor.par()
2115 || old_cursor.pos() != cursor.pos()) {
2116 // Only if the cursor has really moved
2118 if (old_cursor.pos() > 0
2119 && old_cursor.pos() < old_cursor.par()->size()
2120 && old_cursor.par()->isLineSeparator(old_cursor.pos())
2121 && old_cursor.par()->isLineSeparator(old_cursor.pos() - 1)) {
2122 old_cursor.par()->erase(old_cursor.pos() - 1);
2123 redoParagraphs(old_cursor, boost::next(old_cursor.par()));
2125 #ifdef WITH_WARNINGS
2126 #warning This will not work anymore when we have multiple views of the same buffer
2127 // In this case, we will have to correct also the cursors held by
2128 // other bufferviews. It will probably be easier to do that in a more
2129 // automated way in LyXCursor code. (JMarc 26/09/2001)
2131 // correct all cursors held by the LyXText
2132 fixCursorAfterDelete(cursor, old_cursor);
2133 fixCursorAfterDelete(selection.cursor,
2135 fixCursorAfterDelete(selection.start,
2137 fixCursorAfterDelete(selection.end, old_cursor);
2138 fixCursorAfterDelete(last_sel_cursor,
2140 fixCursorAfterDelete(toggle_cursor, old_cursor);
2141 fixCursorAfterDelete(toggle_end_cursor,
2147 // don't delete anything if this is the ONLY paragraph!
2148 if (ownerParagraphs().size() == 1)
2151 // Do not delete empty paragraphs with keepempty set.
2152 if (old_cursor.par()->allowEmpty())
2155 // only do our magic if we changed paragraph
2156 if (old_cursor.par() == cursor.par())
2159 // record if we have deleted a paragraph
2160 // we can't possibly have deleted a paragraph before this point
2161 bool deleted = false;
2163 if (old_cursor.par()->empty() ||
2164 (old_cursor.par()->size() == 1 &&
2165 old_cursor.par()->isLineSeparator(0))) {
2166 // ok, we will delete anything
2167 LyXCursor tmpcursor;
2171 bool selection_position_was_oldcursor_position = (
2172 selection.cursor.par() == old_cursor.par()
2173 && selection.cursor.pos() == old_cursor.pos());
2175 if (getRow(old_cursor) != rows().begin()) {
2176 RowList::iterator prevrow = boost::prior(getRow(old_cursor));
2179 cursor = old_cursor; // that undo can restore the right cursor position
2180 #warning FIXME. --end() iterator is usable here
2181 ParagraphList::iterator endpit = boost::next(old_cursor.par());
2182 while (endpit != ownerParagraphs().end() &&
2183 endpit->getDepth()) {
2187 recordUndo(bv(), Undo::DELETE, old_cursor.par(),
2188 boost::prior(endpit));
2192 removeRow(getRow(old_cursor));
2194 ownerParagraphs().erase(old_cursor.par());
2196 /* Breakagain the next par. Needed because of
2197 * the parindent that can occur or dissappear.
2198 * The next row can change its height, if
2199 * there is another layout before */
2200 RowList::iterator tmprit = boost::next(prevrow);
2201 if (tmprit != rows().end()) {
2205 setHeightOfRow(prevrow);
2207 RowList::iterator nextrow = boost::next(getRow(old_cursor));
2211 cursor = old_cursor; // that undo can restore the right cursor position
2212 #warning FIXME. --end() iterator is usable here
2213 ParagraphList::iterator endpit = boost::next(old_cursor.par());
2214 while (endpit != ownerParagraphs().end() &&
2215 endpit->getDepth()) {
2219 recordUndo(bv(), Undo::DELETE, old_cursor.par(), boost::prior(endpit));
2223 removeRow(getRow(old_cursor));
2225 ownerParagraphs().erase(old_cursor.par());
2227 /* Breakagain the next par. Needed because of
2228 the parindent that can occur or dissappear.
2229 The next row can change its height, if
2230 there is another layout before */
2231 if (nextrow != rows().end()) {
2232 breakAgain(nextrow);
2238 setCursorIntern(cursor.par(), cursor.pos());
2240 if (selection_position_was_oldcursor_position) {
2241 // correct selection
2242 selection.cursor = cursor;
2246 if (old_cursor.par()->stripLeadingSpaces()) {
2247 redoParagraphs(old_cursor, boost::next(old_cursor.par()));
2249 setCursorIntern(cursor.par(), cursor.pos());
2250 selection.cursor = cursor;
2257 ParagraphList & LyXText::ownerParagraphs() const
2260 return inset_owner->paragraphs;
2262 return bv_owner->buffer()->paragraphs;
2266 bool LyXText::needRefresh() const
2268 return need_refresh_;
2272 void LyXText::clearPaint()
2274 need_refresh_ = false;
2278 void LyXText::postPaint()
2280 need_refresh_ = true;
2282 // We are an inset's lyxtext. Tell the top-level lyxtext
2283 // it needs to update the row we're in.
2285 bv()->text->postPaint();
2289 bool LyXText::isInInset() const
2291 // Sub-level has non-null bv owner and
2292 // non-null inset owner.
2293 return inset_owner != 0 && bv_owner != 0;
2297 int defaultRowHeight()
2299 LyXFont const font(LyXFont::ALL_SANE);
2300 return int(font_metrics::maxAscent(font)
2301 + font_metrics::maxDescent(font) * 1.5);