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 "bufferparams.h"
23 #include "BufferView.h"
24 #include "CutAndPaste.h"
25 #include "frontends/Painter.h"
26 #include "frontends/font_metrics.h"
30 #include "FloatList.h"
32 #include "ParagraphParameters.h"
34 #include "lyxrow_funcs.h"
35 #include "paragraph_funcs.h"
37 #include "insets/insetbibitem.h"
38 #include "insets/insetfloat.h"
39 #include "insets/insetwrap.h"
41 #include "support/LAssert.h"
42 #include "support/textutils.h"
43 #include "support/lstrings.h"
45 #include <boost/tuple/tuple.hpp>
55 LyXText::LyXText(BufferView * bv)
56 : height(0), width(0), anchor_row_offset_(0),
57 inset_owner(0), the_locking_inset(0), bv_owner(bv)
59 anchor_row_ = rows().end();
60 need_break_row = rows().end();
61 refresh_row = rows().end();
67 LyXText::LyXText(BufferView * bv, InsetText * inset)
68 : height(0), width(0), anchor_row_offset_(0),
69 inset_owner(inset), the_locking_inset(0), bv_owner(bv)
71 anchor_row_ = rows().end();
72 need_break_row = rows().end();
73 refresh_row = rows().end();
79 void LyXText::init(BufferView * bview, bool reinit)
83 need_break_row = rows().end();
87 } else if (!rowlist_.empty())
90 ParagraphList::iterator pit = ownerParagraphs().begin();
91 ParagraphList::iterator end = ownerParagraphs().end();
93 current_font = getFont(bview->buffer(), pit, 0);
95 for (; pit != end; ++pit) {
96 insertParagraph(pit, rowlist_.end());
98 setCursorIntern(rowlist_.begin()->par(), 0);
99 selection.cursor = cursor;
105 // Gets the fully instantiated font at a given position in a paragraph
106 // Basically the same routine as Paragraph::getFont() in paragraph.C.
107 // The difference is that this one is used for displaying, and thus we
108 // are allowed to make cosmetic improvements. For instance make footnotes
110 // If position is -1, we get the layout font of the paragraph.
111 // If position is -2, we get the font of the manual label of the paragraph.
112 LyXFont const LyXText::getFont(Buffer const * buf, ParagraphList::iterator pit,
115 lyx::Assert(pos >= 0);
117 LyXLayout_ptr const & layout = pit->layout();
119 // We specialize the 95% common case:
120 if (!pit->getDepth()) {
121 if (layout->labeltype == LABEL_MANUAL
122 && pos < pit->beginningOfBody()) {
124 LyXFont f = pit->getFontSettings(buf->params, pos);
126 pit->inInset()->getDrawFont(f);
127 return f.realize(layout->reslabelfont);
129 LyXFont f = pit->getFontSettings(buf->params, pos);
131 pit->inInset()->getDrawFont(f);
132 return f.realize(layout->resfont);
136 // The uncommon case need not be optimized as much
140 if (pos < pit->beginningOfBody()) {
142 layoutfont = layout->labelfont;
145 layoutfont = layout->font;
148 LyXFont tmpfont = pit->getFontSettings(buf->params, pos);
149 tmpfont.realize(layoutfont);
152 pit->inInset()->getDrawFont(tmpfont);
154 // Realize with the fonts of lesser depth.
155 tmpfont.realize(outerFont(pit, ownerParagraphs()));
157 return realizeFont(tmpfont, buf->params);
161 LyXFont const LyXText::getLayoutFont(Buffer const * buf,
162 ParagraphList::iterator pit) const
164 LyXLayout_ptr const & layout = pit->layout();
166 if (!pit->getDepth()) {
167 return layout->resfont;
170 LyXFont font(layout->font);
171 // Realize with the fonts of lesser depth.
172 font.realize(outerFont(pit, ownerParagraphs()));
174 return realizeFont(font, buf->params);
178 LyXFont const LyXText::getLabelFont(Buffer const * buf,
179 ParagraphList::iterator pit) const
181 LyXLayout_ptr const & layout = pit->layout();
183 if (!pit->getDepth()) {
184 return layout->reslabelfont;
187 LyXFont font(layout->labelfont);
188 // Realize with the fonts of lesser depth.
189 font.realize(outerFont(pit, ownerParagraphs()));
191 return realizeFont(layout->labelfont, buf->params);
195 void LyXText::setCharFont(ParagraphList::iterator pit,
196 pos_type pos, LyXFont const & fnt,
199 Buffer const * buf = bv()->buffer();
200 LyXFont font = getFont(buf, pit, pos);
201 font.update(fnt, buf->params.language, toggleall);
202 // Let the insets convert their font
203 if (pit->isInset(pos)) {
204 Inset * inset = pit->getInset(pos);
205 if (isEditableInset(inset)) {
206 UpdatableInset * uinset =
207 static_cast<UpdatableInset *>(inset);
208 uinset->setFont(bv(), fnt, toggleall, true);
212 // Plug thru to version below:
213 setCharFont(buf, pit, pos, font);
217 void LyXText::setCharFont(Buffer const * buf, ParagraphList::iterator pit,
218 pos_type pos, LyXFont const & fnt)
222 LyXTextClass const & tclass = buf->params.getLyXTextClass();
223 LyXLayout_ptr const & layout = pit->layout();
225 // Get concrete layout font to reduce against
228 if (pos < pit->beginningOfBody())
229 layoutfont = layout->labelfont;
231 layoutfont = layout->font;
233 // Realize against environment font information
234 if (pit->getDepth()) {
235 ParagraphList::iterator tp = pit;
236 while (!layoutfont.resolved() &&
237 tp != ownerParagraphs().end() &&
239 tp = outerHook(tp, ownerParagraphs());
240 if (tp != ownerParagraphs().end())
241 layoutfont.realize(tp->layout()->font);
245 layoutfont.realize(tclass.defaultfont());
247 // Now, reduce font against full layout font
248 font.reduce(layoutfont);
250 pit->setFont(pos, font);
254 // removes the row and reset the touched counters
255 void LyXText::removeRow(RowList::iterator rit)
257 /* FIXME: when we cache the bview, this should just
258 * become a postPaint(), I think */
259 if (refresh_row == rit) {
260 if (rit == rows().begin())
261 refresh_row = boost::next(rit);
263 refresh_row = boost::prior(rit);
265 // what about refresh_y
268 if (anchor_row_ == rit) {
269 if (rit != rows().begin()) {
270 anchor_row_ = boost::prior(rit);
271 anchor_row_offset_ += anchor_row_->height();
273 anchor_row_ = boost::next(rit);
274 anchor_row_offset_ -= rit->height();
278 // the text becomes smaller
279 height -= rit->height();
285 // remove all following rows of the paragraph of the specified row.
286 void LyXText::removeParagraph(RowList::iterator rit)
288 ParagraphList::iterator tmppit = rit->par();
291 while (rit != rows().end() && rit->par() == tmppit) {
292 RowList::iterator tmprit = boost::next(rit);
299 void LyXText::insertParagraph(ParagraphList::iterator pit,
300 RowList::iterator rowit)
302 // insert a new row, starting at position 0
304 RowList::iterator rit = rowlist_.insert(rowit, newrow);
306 // and now append the whole paragraph before the new row
307 appendParagraph(rit);
311 Inset * LyXText::getInset() const
313 ParagraphList::iterator pit = cursor.par();
314 pos_type const pos = cursor.pos();
316 if (pos < pit->size() && pit->isInset(pos)) {
317 return pit->getInset(pos);
323 void LyXText::toggleInset()
325 Inset * inset = getInset();
326 // is there an editable inset at cursor position?
327 if (!isEditableInset(inset)) {
328 // No, try to see if we are inside a collapsable inset
329 if (inset_owner && inset_owner->owner()
330 && inset_owner->owner()->isOpen()) {
331 bv()->unlockInset(static_cast<UpdatableInset *>(inset_owner->owner()));
332 inset_owner->owner()->close(bv());
333 bv()->getLyXText()->cursorRight(bv());
337 //bv()->owner()->message(inset->editMessage());
339 // do we want to keep this?? (JMarc)
340 if (!isHighlyEditableInset(inset))
341 setCursorParUndo(bv());
343 if (inset->isOpen()) {
349 bv()->updateInset(inset);
353 /* used in setlayout */
354 // Asger is not sure we want to do this...
355 void LyXText::makeFontEntriesLayoutSpecific(Buffer const & buf,
358 LyXLayout_ptr const & layout = par.layout();
359 pos_type const psize = par.size();
362 for (pos_type pos = 0; pos < psize; ++pos) {
363 if (pos < par.beginningOfBody())
364 layoutfont = layout->labelfont;
366 layoutfont = layout->font;
368 LyXFont tmpfont = par.getFontSettings(buf.params, pos);
369 tmpfont.reduce(layoutfont);
370 par.setFont(pos, tmpfont);
375 ParagraphList::iterator
376 LyXText::setLayout(LyXCursor & cur, LyXCursor & sstart_cur,
377 LyXCursor & send_cur,
378 string const & layout)
380 ParagraphList::iterator endpit = boost::next(send_cur.par());
381 ParagraphList::iterator undoendpit = endpit;
382 ParagraphList::iterator pars_end = ownerParagraphs().end();
384 if (endpit != pars_end && endpit->getDepth()) {
385 while (endpit != pars_end && endpit->getDepth()) {
389 } else if (endpit != pars_end) {
390 // because of parindents etc.
394 setUndo(bv(), Undo::EDIT, sstart_cur.par(), undoendpit);
396 // ok we have a selection. This is always between sstart_cur
397 // and sel_end cursor
399 ParagraphList::iterator pit = sstart_cur.par();
400 ParagraphList::iterator epit = boost::next(send_cur.par());
402 LyXLayout_ptr const & lyxlayout =
403 bv()->buffer()->params.getLyXTextClass()[layout];
406 pit->applyLayout(lyxlayout);
407 makeFontEntriesLayoutSpecific(*bv()->buffer(), *pit);
408 ParagraphList::iterator fppit = pit;
409 fppit->params().spaceTop(lyxlayout->fill_top ?
410 VSpace(VSpace::VFILL)
411 : VSpace(VSpace::NONE));
412 fppit->params().spaceBottom(lyxlayout->fill_bottom ?
413 VSpace(VSpace::VFILL)
414 : VSpace(VSpace::NONE));
415 if (lyxlayout->margintype == MARGIN_MANUAL)
416 pit->setLabelWidthString(lyxlayout->labelstring());
419 } while (pit != epit);
425 // set layout over selection and make a total rebreak of those paragraphs
426 void LyXText::setLayout(string const & layout)
428 LyXCursor tmpcursor = cursor; /* store the current cursor */
430 // if there is no selection just set the layout
431 // of the current paragraph */
432 if (!selection.set()) {
433 selection.start = cursor; // dummy selection
434 selection.end = cursor;
436 ParagraphList::iterator endpit = setLayout(cursor, selection.start,
437 selection.end, layout);
438 redoParagraphs(selection.start, endpit);
440 // we have to reset the selection, because the
441 // geometry could have changed
442 setCursor(selection.start.par(),
443 selection.start.pos(), false);
444 selection.cursor = cursor;
445 setCursor(selection.end.par(), selection.end.pos(), false);
449 setCursor(tmpcursor.par(), tmpcursor.pos(), true);
453 bool LyXText::changeDepth(bv_funcs::DEPTH_CHANGE type, bool test_only)
455 ParagraphList::iterator pit(cursor.par());
456 ParagraphList::iterator end(cursor.par());
457 ParagraphList::iterator start = pit;
459 if (selection.set()) {
460 pit = selection.start.par();
461 end = selection.end.par();
465 ParagraphList::iterator pastend = boost::next(end);
468 setUndo(bv(), Undo::EDIT, start, pastend);
470 bool changed = false;
472 int prev_after_depth = 0;
473 #warning parlist ... could be nicer ?
474 if (start != ownerParagraphs().begin()) {
475 prev_after_depth = boost::prior(start)->getMaxDepthAfter();
479 int const depth = pit->params().depth();
480 if (type == bv_funcs::INC_DEPTH) {
481 if (depth < prev_after_depth
482 && pit->layout()->labeltype != LABEL_BIBLIO) {
485 pit->params().depth(depth + 1);
492 pit->params().depth(depth - 1);
495 prev_after_depth = pit->getMaxDepthAfter();
507 // Wow, redoParagraphs is stupid.
509 setCursor(tmpcursor, start, 0);
511 //redoParagraphs(tmpcursor, &(*pastend));
512 redoParagraphs(tmpcursor, pastend);
514 // We need to actually move the text->cursor. I don't
515 // understand why ...
518 // we have to reset the visual selection because the
519 // geometry could have changed
520 if (selection.set()) {
521 setCursor(selection.start.par(), selection.start.pos());
522 selection.cursor = cursor;
523 setCursor(selection.end.par(), selection.end.pos());
526 // this handles the counter labels, and also fixes up
527 // depth values for follow-on (child) paragraphs
531 setCursor(tmpcursor.par(), tmpcursor.pos());
537 // set font over selection and make a total rebreak of those paragraphs
538 void LyXText::setFont(LyXFont const & font, bool toggleall)
540 // if there is no selection just set the current_font
541 if (!selection.set()) {
542 // Determine basis font
544 if (cursor.pos() < cursor.par()->beginningOfBody()) {
545 layoutfont = getLabelFont(bv()->buffer(),
548 layoutfont = getLayoutFont(bv()->buffer(),
551 // Update current font
552 real_current_font.update(font,
553 bv()->buffer()->params.language,
556 // Reduce to implicit settings
557 current_font = real_current_font;
558 current_font.reduce(layoutfont);
559 // And resolve it completely
560 real_current_font.realize(layoutfont);
565 LyXCursor tmpcursor = cursor; // store the current cursor
567 // ok we have a selection. This is always between sel_start_cursor
568 // and sel_end cursor
570 setUndo(bv(), Undo::EDIT,
571 selection.start.par(), boost::next(selection.end.par()));
573 cursor = selection.start;
574 while (cursor.par() != selection.end.par() ||
575 cursor.pos() < selection.end.pos())
577 if (cursor.pos() < cursor.par()->size()) {
578 // an open footnote should behave like a closed one
579 setCharFont(cursor.par(), cursor.pos(),
581 cursor.pos(cursor.pos() + 1);
584 cursor.par(boost::next(cursor.par()));
589 redoParagraphs(selection.start, boost::next(selection.end.par()));
591 // we have to reset the selection, because the
592 // geometry could have changed, but we keep
593 // it for user convenience
594 setCursor(selection.start.par(), selection.start.pos());
595 selection.cursor = cursor;
596 setCursor(selection.end.par(), selection.end.pos());
598 setCursor(tmpcursor.par(), tmpcursor.pos(), true,
599 tmpcursor.boundary());
603 void LyXText::redoHeightOfParagraph()
605 RowList::iterator tmprow = cursor.row();
606 int y = cursor.y() - tmprow->baseline();
608 setHeightOfRow(tmprow);
610 while (tmprow != rows().begin()
611 && boost::prior(tmprow)->par() == tmprow->par()) {
613 y -= tmprow->height();
614 setHeightOfRow(tmprow);
619 setCursor(cursor.par(), cursor.pos(), false, cursor.boundary());
623 void LyXText::redoDrawingOfParagraph(LyXCursor const & cur)
625 RowList::iterator tmprow = cur.row();
627 int y = cur.y() - tmprow->baseline();
628 setHeightOfRow(tmprow);
630 while (tmprow != rows().begin()
631 && boost::prior(tmprow)->par() == tmprow->par()) {
633 y -= tmprow->height();
637 setCursor(cur.par(), cur.pos());
641 // deletes and inserts again all paragaphs between the cursor
642 // and the specified par
643 // This function is needed after SetLayout and SetFont etc.
644 void LyXText::redoParagraphs(LyXCursor const & cur,
645 ParagraphList::iterator endpit)
647 RowList::iterator tmprit = cur.row();
648 int y = cur.y() - tmprit->baseline();
650 ParagraphList::iterator first_phys_pit;
651 RowList::iterator prevrit;
652 if (tmprit == rows().begin()) {
653 // A trick/hack for UNDO.
654 // This is needed because in an UNDO/REDO we could have
655 // changed the ownerParagrah() so the paragraph inside
656 // the row is NOT my really first par anymore.
657 // Got it Lars ;) (Jug 20011206)
658 first_phys_pit = ownerParagraphs().begin();
659 prevrit = rows().end();
661 first_phys_pit = tmprit->par();
662 while (tmprit != rows().begin()
663 && boost::prior(tmprit)->par() == first_phys_pit)
666 y -= tmprit->height();
668 prevrit = boost::prior(tmprit);
672 while (tmprit != rows().end() && tmprit->par() != endpit) {
673 RowList::iterator tmprit2 = tmprit++;
677 // Reinsert the paragraphs.
678 ParagraphList::iterator tmppit = first_phys_pit;
680 while (tmppit != ownerParagraphs().end()) {
681 insertParagraph(tmppit, tmprit);
682 while (tmprit != rows().end()
683 && tmprit->par() == tmppit) {
687 if (tmppit == endpit)
690 if (prevrit != rows().end()) {
691 setHeightOfRow(prevrit);
692 const_cast<LyXText *>(this)->postPaint(y - prevrit->height());
694 setHeightOfRow(rows().begin());
695 const_cast<LyXText *>(this)->postPaint(0);
697 if (tmprit != rows().end())
698 setHeightOfRow(tmprit);
704 void LyXText::fullRebreak()
706 if (rows().empty()) {
711 RowList::iterator rows_end = rows().end();
713 if (need_break_row != rows_end) {
714 breakAgain(need_break_row);
715 need_break_row = rows_end;
721 // important for the screen
724 // the cursor set functions have a special mechanism. When they
725 // realize, that you left an empty paragraph, they will delete it.
726 // They also delete the corresponding row
728 // need the selection cursor:
729 void LyXText::setSelection()
731 bool const lsel = selection.set();
733 if (!selection.set()) {
734 last_sel_cursor = selection.cursor;
735 selection.start = selection.cursor;
736 selection.end = selection.cursor;
741 // first the toggling area
742 if (cursor.y() < last_sel_cursor.y()
743 || (cursor.y() == last_sel_cursor.y()
744 && cursor.x() < last_sel_cursor.x())) {
745 toggle_end_cursor = last_sel_cursor;
746 toggle_cursor = cursor;
748 toggle_end_cursor = cursor;
749 toggle_cursor = last_sel_cursor;
752 last_sel_cursor = cursor;
754 // and now the whole selection
756 if (selection.cursor.par() == cursor.par())
757 if (selection.cursor.pos() < cursor.pos()) {
758 selection.end = cursor;
759 selection.start = selection.cursor;
761 selection.end = selection.cursor;
762 selection.start = cursor;
764 else if (selection.cursor.y() < cursor.y() ||
765 (selection.cursor.y() == cursor.y()
766 && selection.cursor.x() < cursor.x())) {
767 selection.end = cursor;
768 selection.start = selection.cursor;
771 selection.end = selection.cursor;
772 selection.start = cursor;
775 // a selection with no contents is not a selection
776 if (selection.start.par() == selection.end.par() &&
777 selection.start.pos() == selection.end.pos())
778 selection.set(false);
780 if (inset_owner && (selection.set() || lsel))
781 inset_owner->setUpdateStatus(bv(), InsetText::SELECTION);
785 string const LyXText::selectionAsString(Buffer const * buffer,
788 if (!selection.set()) return string();
790 // should be const ...
791 ParagraphList::iterator startpit = selection.start.par();
792 ParagraphList::iterator endpit = selection.end.par();
793 pos_type const startpos(selection.start.pos());
794 pos_type const endpos(selection.end.pos());
796 if (startpit == endpit) {
797 return startpit->asString(buffer, startpos, endpos, label);
802 // First paragraph in selection
803 result += startpit->asString(buffer, startpos, startpit->size(), label) + "\n\n";
805 // The paragraphs in between (if any)
806 ParagraphList::iterator pit = boost::next(startpit);
807 for (; pit != endpit; ++pit) {
808 result += pit->asString(buffer, 0, pit->size(), label) + "\n\n";
811 // Last paragraph in selection
812 result += endpit->asString(buffer, 0, endpos, label);
818 void LyXText::clearSelection()
820 selection.set(false);
821 selection.mark(false);
822 last_sel_cursor = selection.end = selection.start = selection.cursor = cursor;
823 // reset this in the bv_owner!
824 if (bv_owner && bv_owner->text)
825 bv_owner->text->xsel_cache.set(false);
829 void LyXText::cursorHome()
831 setCursor(cursor.par(), cursor.row()->pos());
835 void LyXText::cursorEnd()
837 if (cursor.par()->empty())
840 RowList::iterator rit = cursor.row();
841 RowList::iterator next_rit = boost::next(rit);
842 ParagraphList::iterator pit = rit->par();
843 pos_type last_pos = lastPos(*this, rit);
845 if (next_rit == rows().end() || next_rit->par() != pit) {
849 (pit->getChar(last_pos) != ' ' && !pit->isNewline(last_pos))) {
854 setCursor(pit, last_pos);
858 void LyXText::cursorTop()
860 setCursor(ownerParagraphs().begin(), 0);
864 void LyXText::cursorBottom()
867 // This is how it should be:
868 // ParagraphList::iterator lastpit = boost::prior(ownerParagraphs().end());
869 ParagraphList::iterator lastpit = &ownerParagraphs().back();
870 int pos = lastpit->size();
871 setCursor(lastpit, pos);
875 void LyXText::toggleFree(LyXFont const & font, bool toggleall)
877 // If the mask is completely neutral, tell user
878 if (font == LyXFont(LyXFont::ALL_IGNORE)) {
879 // Could only happen with user style
880 bv()->owner()->message(_("No font change defined. Use Character under the Layout menu to define font change."));
884 // Try implicit word selection
885 // If there is a change in the language the implicit word selection
887 LyXCursor resetCursor = cursor;
888 bool implicitSelection = (font.language() == ignore_language
889 && font.number() == LyXFont::IGNORE)
890 ? selectWordWhenUnderCursor(WHOLE_WORD_STRICT) : false;
893 setFont(font, toggleall);
895 // Implicit selections are cleared afterwards
896 //and cursor is set to the original position.
897 if (implicitSelection) {
899 cursor = resetCursor;
900 setCursor(cursor.par(), cursor.pos());
901 selection.cursor = cursor;
904 inset_owner->setUpdateStatus(bv(), InsetText::CURSOR_PAR);
908 string LyXText::getStringToIndex()
910 // Try implicit word selection
911 // If there is a change in the language the implicit word selection
913 LyXCursor const reset_cursor = cursor;
914 bool const implicitSelection = selectWordWhenUnderCursor(PREVIOUS_WORD);
917 if (!selection.set())
918 bv()->owner()->message(_("Nothing to index!"));
919 else if (selection.start.par() != selection.end.par())
920 bv()->owner()->message(_("Cannot index more than one paragraph!"));
922 idxstring = selectionAsString(bv()->buffer(), false);
924 // Reset cursors to their original position.
925 cursor = reset_cursor;
926 setCursor(cursor.par(), cursor.pos());
927 selection.cursor = cursor;
929 // Clear the implicit selection.
930 if (implicitSelection)
937 // the DTP switches for paragraphs. LyX will store them in the first
938 // physicla paragraph. When a paragraph is broken, the top settings rest,
939 // the bottom settings are given to the new one. So I can make shure,
940 // they do not duplicate themself and you cannnot make dirty things with
943 void LyXText::setParagraph(bool line_top, bool line_bottom,
944 bool pagebreak_top, bool pagebreak_bottom,
945 VSpace const & space_top,
946 VSpace const & space_bottom,
947 Spacing const & spacing,
949 string const & labelwidthstring,
952 LyXCursor tmpcursor = cursor;
953 if (!selection.set()) {
954 selection.start = cursor;
955 selection.end = cursor;
958 // make sure that the depth behind the selection are restored, too
959 ParagraphList::iterator endpit = boost::next(selection.end.par());
960 ParagraphList::iterator undoendpit = endpit;
961 ParagraphList::iterator pars_end = ownerParagraphs().end();
963 if (endpit != pars_end && endpit->getDepth()) {
964 while (endpit != pars_end && endpit->getDepth()) {
968 } else if (endpit != pars_end) {
969 // because of parindents etc.
973 setUndo(bv(), Undo::EDIT, selection.start.par(), undoendpit);
976 ParagraphList::iterator tmppit = selection.end.par();
978 while (tmppit != boost::prior(selection.start.par())) {
979 setCursor(tmppit, 0);
980 postPaint(cursor.y() - cursor.row()->baseline());
982 ParagraphList::iterator pit = cursor.par();
983 ParagraphParameters & params = pit->params();
985 params.lineTop(line_top);
986 params.lineBottom(line_bottom);
987 params.pagebreakTop(pagebreak_top);
988 params.pagebreakBottom(pagebreak_bottom);
989 params.spaceTop(space_top);
990 params.spaceBottom(space_bottom);
991 params.spacing(spacing);
992 // does the layout allow the new alignment?
993 LyXLayout_ptr const & layout = pit->layout();
995 if (align == LYX_ALIGN_LAYOUT)
996 align = layout->align;
997 if (align & layout->alignpossible) {
998 if (align == layout->align)
999 params.align(LYX_ALIGN_LAYOUT);
1001 params.align(align);
1003 pit->setLabelWidthString(labelwidthstring);
1004 params.noindent(noindent);
1005 tmppit = boost::prior(pit);
1008 redoParagraphs(selection.start, endpit);
1011 setCursor(selection.start.par(), selection.start.pos());
1012 selection.cursor = cursor;
1013 setCursor(selection.end.par(), selection.end.pos());
1015 setCursor(tmpcursor.par(), tmpcursor.pos());
1017 bv()->updateInset(inset_owner);
1021 // set the counter of a paragraph. This includes the labels
1022 void LyXText::setCounter(Buffer const * buf, ParagraphList::iterator pit)
1024 LyXTextClass const & textclass = buf->params.getLyXTextClass();
1025 LyXLayout_ptr const & layout = pit->layout();
1027 if (pit != ownerParagraphs().begin()) {
1029 pit->params().appendix(boost::prior(pit)->params().appendix());
1030 if (!pit->params().appendix() &&
1031 pit->params().startOfAppendix()) {
1032 pit->params().appendix(true);
1033 textclass.counters().reset();
1035 pit->enumdepth = boost::prior(pit)->enumdepth;
1036 pit->itemdepth = boost::prior(pit)->itemdepth;
1038 pit->params().appendix(pit->params().startOfAppendix());
1043 /* Maybe we have to increment the enumeration depth.
1044 * BUT, enumeration in a footnote is considered in isolation from its
1045 * surrounding paragraph so don't increment if this is the
1046 * first line of the footnote
1047 * AND, bibliographies can't have their depth changed ie. they
1048 * are always of depth 0
1050 if (pit != ownerParagraphs().begin()
1051 && boost::prior(pit)->getDepth() < pit->getDepth()
1052 && boost::prior(pit)->layout()->labeltype == LABEL_COUNTER_ENUMI
1053 && pit->enumdepth < 3
1054 && layout->labeltype != LABEL_BIBLIO) {
1058 // Maybe we have to decrement the enumeration depth, see note above
1059 if (pit != ownerParagraphs().begin()
1060 && boost::prior(pit)->getDepth() > pit->getDepth()
1061 && layout->labeltype != LABEL_BIBLIO) {
1062 pit->enumdepth = depthHook(pit, ownerParagraphs(),
1063 pit->getDepth())->enumdepth;
1066 if (!pit->params().labelString().empty()) {
1067 pit->params().labelString(string());
1070 if (layout->margintype == MARGIN_MANUAL) {
1071 if (pit->params().labelWidthString().empty()) {
1072 pit->setLabelWidthString(layout->labelstring());
1075 pit->setLabelWidthString(string());
1078 // is it a layout that has an automatic label?
1079 if (layout->labeltype >= LABEL_COUNTER_CHAPTER) {
1080 int const i = layout->labeltype - LABEL_COUNTER_CHAPTER;
1084 if (i >= 0 && i <= buf->params.secnumdepth) {
1088 textclass.counters().step(layout->latexname());
1090 // Is there a label? Useful for Chapter layout
1091 if (!pit->params().appendix()) {
1092 s << buf->B_(layout->labelstring());
1094 s << buf->B_(layout->labelstring_appendix());
1097 // Use of an integer is here less than elegant. For now.
1098 int head = textclass.maxcounter() - LABEL_COUNTER_CHAPTER;
1099 if (!pit->params().appendix()) {
1100 numbertype = "sectioning";
1102 numbertype = "appendix";
1103 if (pit->isRightToLeftPar(buf->params))
1104 langtype = "hebrew";
1110 << textclass.counters()
1111 .numberLabel(layout->latexname(),
1112 numbertype, langtype, head);
1114 pit->params().labelString(STRCONV(s.str()));
1116 // reset enum counters
1117 textclass.counters().reset("enum");
1118 } else if (layout->labeltype < LABEL_COUNTER_ENUMI) {
1119 textclass.counters().reset("enum");
1120 } else if (layout->labeltype == LABEL_COUNTER_ENUMI) {
1122 // Yes I know this is a really, really! bad solution
1124 string enumcounter("enum");
1126 switch (pit->enumdepth) {
1135 enumcounter += "iv";
1138 // not a valid enumdepth...
1142 textclass.counters().step(enumcounter);
1144 s << textclass.counters()
1145 .numberLabel(enumcounter, "enumeration");
1146 pit->params().labelString(STRCONV(s.str()));
1148 } else if (layout->labeltype == LABEL_BIBLIO) {// ale970302
1149 textclass.counters().step("bibitem");
1150 int number = textclass.counters().value("bibitem");
1151 if (pit->bibitem()) {
1152 pit->bibitem()->setCounter(number);
1153 pit->params().labelString(layout->labelstring());
1155 // In biblio should't be following counters but...
1157 string s = buf->B_(layout->labelstring());
1159 // the caption hack:
1160 if (layout->labeltype == LABEL_SENSITIVE) {
1161 ParagraphList::iterator tmppit = pit;
1164 while (tmppit != ownerParagraphs().end() &&
1166 // the single '=' is intended below
1167 && (in = tmppit->inInset()->owner())) {
1168 if (in->lyxCode() == Inset::FLOAT_CODE ||
1169 in->lyxCode() == Inset::WRAP_CODE) {
1173 tmppit = in->parOwner();
1180 if (in->lyxCode() == Inset::FLOAT_CODE)
1181 type = static_cast<InsetFloat*>(in)->params().type;
1182 else if (in->lyxCode() == Inset::WRAP_CODE)
1183 type = static_cast<InsetWrap*>(in)->params().type;
1187 Floating const & fl = textclass.floats().getType(type);
1189 textclass.counters().step(fl.type());
1191 // Doesn't work... yet.
1192 s = bformat(_("%1$s #:"), buf->B_(fl.name()));
1194 // par->SetLayout(0);
1195 // s = layout->labelstring;
1196 s = _("Senseless: ");
1199 pit->params().labelString(s);
1201 // reset the enumeration counter. They are always reset
1202 // when there is any other layout between
1203 // Just fall-through between the cases so that all
1204 // enum counters deeper than enumdepth is also reset.
1205 switch (pit->enumdepth) {
1207 textclass.counters().reset("enumi");
1209 textclass.counters().reset("enumii");
1211 textclass.counters().reset("enumiii");
1213 textclass.counters().reset("enumiv");
1219 // Updates all counters. Paragraphs with changed label string will be rebroken
1220 void LyXText::updateCounters()
1222 RowList::iterator rowit = rows().begin();
1223 ParagraphList::iterator pit = rowit->par();
1225 // CHECK if this is really needed. (Lgb)
1226 bv()->buffer()->params.getLyXTextClass().counters().reset();
1228 for (; pit != ownerParagraphs().end(); ++pit) {
1229 while (rowit->par() != pit)
1232 string const oldLabel = pit->params().labelString();
1235 if (pit != ownerParagraphs().begin())
1236 maxdepth = boost::prior(pit)->getMaxDepthAfter();
1238 if (pit->params().depth() > maxdepth)
1239 pit->params().depth(maxdepth);
1241 // setCounter can potentially change the labelString.
1242 setCounter(bv()->buffer(), pit);
1244 string const & newLabel = pit->params().labelString();
1246 if (oldLabel.empty() && !newLabel.empty()) {
1247 removeParagraph(rowit);
1248 appendParagraph(rowit);
1254 void LyXText::insertInset(Inset * inset)
1256 if (!cursor.par()->insetAllowed(inset->lyxCode()))
1258 setUndo(bv(), Undo::FINISH, cursor.par(),
1259 boost::next(cursor.par()));
1261 cursor.par()->insertInset(cursor.pos(), inset);
1262 // Just to rebreak and refresh correctly.
1263 // The character will not be inserted a second time
1264 insertChar(Paragraph::META_INSET);
1265 // If we enter a highly editable inset the cursor should be to before
1266 // the inset. This couldn't happen before as Undo was not handled inside
1267 // inset now after the Undo LyX tries to call inset->Edit(...) again
1268 // and cannot do this as the cursor is behind the inset and GetInset
1269 // does not return the inset!
1270 if (isHighlyEditableInset(inset)) {
1277 void LyXText::cutSelection(bool doclear, bool realcut)
1279 // Stuff what we got on the clipboard. Even if there is no selection.
1281 // There is a problem with having the stuffing here in that the
1282 // larger the selection the slower LyX will get. This can be
1283 // solved by running the line below only when the selection has
1284 // finished. The solution used currently just works, to make it
1285 // faster we need to be more clever and probably also have more
1286 // calls to stuffClipboard. (Lgb)
1287 bv()->stuffClipboard(selectionAsString(bv()->buffer(), true));
1289 // This doesn't make sense, if there is no selection
1290 if (!selection.set())
1293 // OK, we have a selection. This is always between selection.start
1294 // and selection.end
1296 // make sure that the depth behind the selection are restored, too
1297 ParagraphList::iterator endpit = boost::next(selection.end.par());
1298 ParagraphList::iterator undoendpit = endpit;
1299 ParagraphList::iterator pars_end = ownerParagraphs().end();
1301 if (endpit != pars_end && endpit->getDepth()) {
1302 while (endpit != pars_end && endpit->getDepth()) {
1304 undoendpit = endpit;
1306 } else if (endpit != pars_end) {
1307 // because of parindents etc.
1311 setUndo(bv(), Undo::DELETE, selection.start.par(), undoendpit);
1314 endpit = selection.end.par();
1315 int endpos = selection.end.pos();
1317 boost::tie(endpit, endpos) = realcut ?
1318 CutAndPaste::cutSelection(ownerParagraphs(),
1319 selection.start.par(), endpit,
1320 selection.start.pos(), endpos,
1321 bv()->buffer()->params.textclass,
1323 : CutAndPaste::eraseSelection(ownerParagraphs(),
1324 selection.start.par(), endpit,
1325 selection.start.pos(), endpos,
1327 // sometimes necessary
1329 selection.start.par()->stripLeadingSpaces();
1331 redoParagraphs(selection.start, boost::next(endpit));
1332 #warning FIXME latent bug
1333 // endpit will be invalidated on redoParagraphs once ParagraphList
1334 // becomes a std::list? There are maybe other places on which this
1335 // can happend? (Ab)
1336 // cutSelection can invalidate the cursor so we need to set
1338 // we prefer the end for when tracking changes
1342 // need a valid cursor. (Lgb)
1345 setCursor(cursor.par(), cursor.pos());
1346 selection.cursor = cursor;
1351 void LyXText::copySelection()
1353 // stuff the selection onto the X clipboard, from an explicit copy request
1354 bv()->stuffClipboard(selectionAsString(bv()->buffer(), true));
1356 // this doesnt make sense, if there is no selection
1357 if (!selection.set())
1360 // ok we have a selection. This is always between selection.start
1361 // and sel_end cursor
1363 // copy behind a space if there is one
1364 while (selection.start.par()->size() > selection.start.pos()
1365 && selection.start.par()->isLineSeparator(selection.start.pos())
1366 && (selection.start.par() != selection.end.par()
1367 || selection.start.pos() < selection.end.pos()))
1368 selection.start.pos(selection.start.pos() + 1);
1370 CutAndPaste::copySelection(selection.start.par(),
1371 selection.end.par(),
1372 selection.start.pos(), selection.end.pos(),
1373 bv()->buffer()->params.textclass);
1377 void LyXText::pasteSelection()
1379 // this does not make sense, if there is nothing to paste
1380 if (!CutAndPaste::checkPastePossible())
1383 setUndo(bv(), Undo::INSERT,
1384 cursor.par(), boost::next(cursor.par()));
1386 ParagraphList::iterator endpit;
1389 boost::tie(ppp, endpit) =
1390 CutAndPaste::pasteSelection(ownerParagraphs(),
1391 cursor.par(), cursor.pos(),
1392 bv()->buffer()->params.textclass);
1394 redoParagraphs(cursor, endpit);
1396 setCursor(cursor.par(), cursor.pos());
1399 selection.cursor = cursor;
1400 setCursor(ppp.first, ppp.second);
1406 void LyXText::setSelectionRange(lyx::pos_type length)
1411 selection.cursor = cursor;
1418 // simple replacing. The font of the first selected character is used
1419 void LyXText::replaceSelectionWithString(string const & str)
1421 setCursorParUndo(bv());
1424 if (!selection.set()) { // create a dummy selection
1425 selection.end = cursor;
1426 selection.start = cursor;
1429 // Get font setting before we cut
1430 pos_type pos = selection.end.pos();
1431 LyXFont const font = selection.start.par()
1432 ->getFontSettings(bv()->buffer()->params,
1433 selection.start.pos());
1435 // Insert the new string
1436 for (string::const_iterator cit = str.begin(); cit != str.end(); ++cit) {
1437 selection.end.par()->insertChar(pos, (*cit), font);
1441 // Cut the selection
1442 cutSelection(true, false);
1448 // needed to insert the selection
1449 void LyXText::insertStringAsLines(string const & str)
1451 ParagraphList::iterator pit = cursor.par();
1452 pos_type pos = cursor.pos();
1453 ParagraphList::iterator endpit = boost::next(cursor.par());
1455 setCursorParUndo(bv());
1457 // only to be sure, should not be neccessary
1460 bv()->buffer()->insertStringAsLines(pit, pos, current_font, str);
1462 redoParagraphs(cursor, endpit);
1463 setCursor(cursor.par(), cursor.pos());
1464 selection.cursor = cursor;
1465 setCursor(pit, pos);
1470 // turns double-CR to single CR, others where converted into one
1471 // blank. Then InsertStringAsLines is called
1472 void LyXText::insertStringAsParagraphs(string const & str)
1474 string linestr(str);
1475 bool newline_inserted = false;
1476 for (string::size_type i = 0; i < linestr.length(); ++i) {
1477 if (linestr[i] == '\n') {
1478 if (newline_inserted) {
1479 // we know that \r will be ignored by
1480 // InsertStringA. Of course, it is a dirty
1481 // trick, but it works...
1482 linestr[i - 1] = '\r';
1486 newline_inserted = true;
1488 } else if (IsPrintable(linestr[i])) {
1489 newline_inserted = false;
1492 insertStringAsLines(linestr);
1496 void LyXText::checkParagraph(ParagraphList::iterator pit, pos_type pos)
1498 LyXCursor tmpcursor;
1502 RowList::iterator row = getRow(pit, pos, y);
1503 RowList::iterator beg = rows().begin();
1505 // is there a break one row above
1507 && boost::prior(row)->par() == row->par()) {
1508 z = rowBreakPoint(*boost::prior(row));
1509 if (z >= row->pos()) {
1510 // set the dimensions of the row above
1511 y -= boost::prior(row)->height();
1514 breakAgain(boost::prior(row));
1516 // set the cursor again. Otherwise
1517 // dangling pointers are possible
1518 setCursor(cursor.par(), cursor.pos(),
1519 false, cursor.boundary());
1520 selection.cursor = cursor;
1525 int const tmpheight = row->height();
1526 pos_type const tmplast = lastPos(*this, row);
1529 if (row->height() == tmpheight && lastPos(*this, row) == tmplast) {
1530 postRowPaint(row, y);
1535 // check the special right address boxes
1536 if (pit->layout()->margintype == MARGIN_RIGHT_ADDRESS_BOX) {
1543 redoDrawingOfParagraph(tmpcursor);
1546 // set the cursor again. Otherwise dangling pointers are possible
1547 // also set the selection
1549 if (selection.set()) {
1551 setCursorIntern(selection.cursor.par(), selection.cursor.pos(),
1552 false, selection.cursor.boundary());
1553 selection.cursor = cursor;
1554 setCursorIntern(selection.start.par(),
1555 selection.start.pos(),
1556 false, selection.start.boundary());
1557 selection.start = cursor;
1558 setCursorIntern(selection.end.par(),
1559 selection.end.pos(),
1560 false, selection.end.boundary());
1561 selection.end = cursor;
1562 setCursorIntern(last_sel_cursor.par(),
1563 last_sel_cursor.pos(),
1564 false, last_sel_cursor.boundary());
1565 last_sel_cursor = cursor;
1568 setCursorIntern(cursor.par(), cursor.pos(),
1569 false, cursor.boundary());
1573 // returns false if inset wasn't found
1574 bool LyXText::updateInset(Inset * inset)
1576 // first check the current paragraph
1577 int pos = cursor.par()->getPositionOfInset(inset);
1579 checkParagraph(cursor.par(), pos);
1583 // check every paragraph
1585 ParagraphList::iterator par = ownerParagraphs().begin();
1586 ParagraphList::iterator end = ownerParagraphs().end();
1587 for (; par != end; ++par) {
1588 pos = par->getPositionOfInset(inset);
1590 checkParagraph(par, pos);
1599 bool LyXText::setCursor(ParagraphList::iterator pit,
1601 bool setfont, bool boundary)
1603 LyXCursor old_cursor = cursor;
1604 setCursorIntern(pit, pos, setfont, boundary);
1605 return deleteEmptyParagraphMechanism(old_cursor);
1609 void LyXText::setCursor(LyXCursor & cur, ParagraphList::iterator pit,
1610 pos_type pos, bool boundary)
1612 lyx::Assert(pit != ownerParagraphs().end());
1616 cur.boundary(boundary);
1618 // get the cursor y position in text
1620 RowList::iterator row = getRow(pit, pos, y);
1621 RowList::iterator beg = rows().begin();
1623 RowList::iterator old_row = row;
1625 // if we are before the first char of this row and are still in the
1626 // same paragraph and there is a previous row then put the cursor on
1627 // the end of the previous row
1628 cur.iy(y + row->baseline());
1631 boost::prior(row)->par() == row->par() &&
1632 pos < pit->size() &&
1633 pit->getChar(pos) == Paragraph::META_INSET) {
1634 Inset * ins = pit->getInset(pos);
1635 if (ins && (ins->needFullRow() || ins->display())) {
1642 // y is now the beginning of the cursor row
1643 y += row->baseline();
1644 // y is now the cursor baseline
1647 pos_type last = lastPrintablePos(*this, old_row);
1649 // None of these should happen, but we're scaredy-cats
1650 if (pos > pit->size()) {
1651 lyxerr << "dont like 1 please report" << endl;
1654 } else if (pos > last + 1) {
1655 lyxerr << "dont like 2 please report" << endl;
1656 // This shouldn't happen.
1659 } else if (pos < row->pos()) {
1660 lyxerr << "dont like 3 please report" << endl;
1665 // now get the cursors x position
1666 float x = getCursorX(row, pos, last, boundary);
1669 if (old_row != row) {
1670 x = getCursorX(old_row, pos, last, boundary);
1674 /* We take out this for the time being because 1) the redraw code is not
1675 prepared to this yet and 2) because some good policy has yet to be decided
1676 while editting: for instance how to act on rows being created/deleted
1680 //if the cursor is in a visible row, anchor to it
1682 if (topy < y && y < topy + bv()->workHeight())
1688 float LyXText::getCursorX(RowList::iterator rit,
1689 pos_type pos, pos_type last, bool boundary) const
1691 pos_type cursor_vpos = 0;
1693 float fill_separator;
1695 float fill_label_hfill;
1696 // This call HAS to be here because of the BidiTables!!!
1697 prepareToPrint(rit, x, fill_separator, fill_hfill,
1700 ParagraphList::iterator rit_par = rit->par();
1701 pos_type const rit_pos = rit->pos();
1704 cursor_vpos = rit_pos;
1705 else if (pos > last && !boundary)
1706 cursor_vpos = (rit_par->isRightToLeftPar(bv()->buffer()->params))
1707 ? rit_pos : last + 1;
1708 else if (pos > rit_pos && (pos > last || boundary))
1709 /// Place cursor after char at (logical) position pos - 1
1710 cursor_vpos = (bidi_level(pos - 1) % 2 == 0)
1711 ? log2vis(pos - 1) + 1 : log2vis(pos - 1);
1713 /// Place cursor before char at (logical) position pos
1714 cursor_vpos = (bidi_level(pos) % 2 == 0)
1715 ? log2vis(pos) : log2vis(pos) + 1;
1717 pos_type body_pos = rit_par->beginningOfBody();
1718 if ((body_pos > 0) &&
1719 ((body_pos - 1 > last) || !rit_par->isLineSeparator(body_pos - 1)))
1722 for (pos_type vpos = rit_pos; vpos < cursor_vpos; ++vpos) {
1723 pos_type pos = vis2log(vpos);
1724 if (body_pos > 0 && pos == body_pos - 1) {
1725 x += fill_label_hfill +
1726 font_metrics::width(
1727 rit_par->layout()->labelsep,
1728 getLabelFont(bv()->buffer(), rit_par));
1729 if (rit_par->isLineSeparator(body_pos - 1))
1730 x -= singleWidth(rit_par, body_pos - 1);
1733 if (hfillExpansion(*this, rit, pos)) {
1734 x += singleWidth(rit_par, pos);
1735 if (pos >= body_pos)
1738 x += fill_label_hfill;
1739 } else if (rit_par->isSeparator(pos)) {
1740 x += singleWidth(rit_par, pos);
1741 if (pos >= body_pos)
1742 x += fill_separator;
1744 x += singleWidth(rit_par, pos);
1750 void LyXText::setCursorIntern(ParagraphList::iterator pit,
1751 pos_type pos, bool setfont, bool boundary)
1753 InsetText * it = static_cast<InsetText *>(pit->inInset());
1755 if (it != inset_owner) {
1756 lyxerr[Debug::INSETS] << "InsetText is " << it
1758 << "inset_owner is "
1759 << inset_owner << endl;
1760 #ifdef WITH_WARNINGS
1761 #warning I believe this code is wrong. (Lgb)
1762 #warning Jürgen, have a look at this. (Lgb)
1763 #warning Hmmm, I guess you are right but we
1764 #warning should verify when this is needed
1766 // Jürgen, would you like to have a look?
1767 // I guess we need to move the outer cursor
1768 // and open and lock the inset (bla bla bla)
1769 // stuff I don't know... so can you have a look?
1771 // I moved the lyxerr stuff in here so we can see if
1772 // this is actually really needed and where!
1774 // it->getLyXText(bv())->setCursorIntern(bv(), par, pos, setfont, boundary);
1779 setCursor(cursor, pit, pos, boundary);
1785 void LyXText::setCurrentFont()
1787 pos_type pos = cursor.pos();
1788 ParagraphList::iterator pit = cursor.par();
1790 if (cursor.boundary() && pos > 0)
1794 if (pos == pit->size())
1796 else // potentional bug... BUG (Lgb)
1797 if (pit->isSeparator(pos)) {
1798 if (pos > cursor.row()->pos() &&
1799 bidi_level(pos) % 2 ==
1800 bidi_level(pos - 1) % 2)
1802 else if (pos + 1 < pit->size())
1808 pit->getFontSettings(bv()->buffer()->params, pos);
1809 real_current_font = getFont(bv()->buffer(), pit, pos);
1811 if (cursor.pos() == pit->size() &&
1812 isBoundary(bv()->buffer(), *pit, cursor.pos()) &&
1813 !cursor.boundary()) {
1814 Language const * lang =
1815 pit->getParLanguage(bv()->buffer()->params);
1816 current_font.setLanguage(lang);
1817 current_font.setNumber(LyXFont::OFF);
1818 real_current_font.setLanguage(lang);
1819 real_current_font.setNumber(LyXFont::OFF);
1824 // returns the column near the specified x-coordinate of the row
1825 // x is set to the real beginning of this column
1827 LyXText::getColumnNearX(RowList::iterator rit, int & x, bool & boundary) const
1830 float fill_separator;
1832 float fill_label_hfill;
1834 prepareToPrint(rit, tmpx, fill_separator,
1835 fill_hfill, fill_label_hfill);
1837 pos_type vc = rit->pos();
1838 pos_type last = lastPrintablePos(*this, rit);
1841 ParagraphList::iterator rit_par = rit->par();
1842 LyXLayout_ptr const & layout = rit->par()->layout();
1844 bool left_side = false;
1846 pos_type body_pos = rit_par->beginningOfBody();
1847 float last_tmpx = tmpx;
1850 (body_pos - 1 > last ||
1851 !rit_par->isLineSeparator(body_pos - 1)))
1854 // check for empty row
1855 if (!rit_par->size()) {
1860 while (vc <= last && tmpx <= x) {
1863 if (body_pos > 0 && c == body_pos - 1) {
1864 tmpx += fill_label_hfill +
1865 font_metrics::width(layout->labelsep,
1866 getLabelFont(bv()->buffer(), rit_par));
1867 if (rit_par->isLineSeparator(body_pos - 1))
1868 tmpx -= singleWidth(rit_par, body_pos - 1);
1871 if (hfillExpansion(*this, rit, c)) {
1872 tmpx += singleWidth(rit_par, c);
1876 tmpx += fill_label_hfill;
1877 } else if (rit_par->isSeparator(c)) {
1878 tmpx += singleWidth(rit_par, c);
1880 tmpx+= fill_separator;
1882 tmpx += singleWidth(rit_par, c);
1887 if ((tmpx + last_tmpx) / 2 > x) {
1892 if (vc > last + 1) // This shouldn't happen.
1896 // This (rtl_support test) is not needed, but gives
1897 // some speedup if rtl_support=false
1898 bool const lastrow = lyxrc.rtl_support &&
1899 (boost::next(rit) == rowlist_.end() ||
1900 boost::next(rit)->par() != rit_par);
1901 // If lastrow is false, we don't need to compute
1902 // the value of rtl.
1903 bool const rtl = (lastrow)
1904 ? rit_par->isRightToLeftPar(bv()->buffer()->params)
1907 ((rtl && left_side && vc == rit->pos() && x < tmpx - 5) ||
1908 (!rtl && !left_side && vc == last + 1 && x > tmpx + 5)))
1910 else if (vc == rit->pos()) {
1912 if (bidi_level(c) % 2 == 1)
1915 c = vis2log(vc - 1);
1916 bool const rtl = (bidi_level(c) % 2 == 1);
1917 if (left_side == rtl) {
1919 boundary = isBoundary(bv()->buffer(), *rit_par, c);
1923 if (rit->pos() <= last && c > last
1924 && rit_par->isNewline(last)) {
1925 if (bidi_level(last) % 2 == 0)
1926 tmpx -= singleWidth(rit_par, last);
1928 tmpx += singleWidth(rit_par, last);
1938 void LyXText::setCursorFromCoordinates(int x, int y)
1940 LyXCursor old_cursor = cursor;
1942 setCursorFromCoordinates(cursor, x, y);
1944 deleteEmptyParagraphMechanism(old_cursor);
1951 * return true if the cursor given is at the end of a row,
1952 * and the next row is filled by an inset that spans an entire
1955 bool beforeFullRowInset(LyXText & lt, LyXCursor const & cur) {
1956 RowList::iterator row = cur.row();
1957 if (boost::next(row) == lt.rows().end())
1959 Row const & next = *boost::next(row);
1961 if (next.pos() != cur.pos() || next.par() != cur.par())
1964 if (cur.pos() == cur.par()->size()
1965 || !cur.par()->isInset(cur.pos()))
1967 Inset const * inset = cur.par()->getInset(cur.pos());
1968 if (inset->needFullRow() || inset->display())
1975 void LyXText::setCursorFromCoordinates(LyXCursor & cur, int x, int y)
1977 // Get the row first.
1979 RowList::iterator row = getRowNearY(y);
1981 pos_type const column = getColumnNearX(row, x, bound);
1982 cur.par(row->par());
1983 cur.pos(row->pos() + column);
1985 cur.y(y + row->baseline());
1988 if (beforeFullRowInset(*this, cur)) {
1989 pos_type last = lastPrintablePos(*this, row);
1990 float x = getCursorX(boost::next(row), cur.pos(), last, bound);
1992 cur.iy(y + row->height() + boost::next(row)->baseline());
1993 cur.irow(boost::next(row));
1999 cur.boundary(bound);
2003 void LyXText::cursorLeft(bool internal)
2005 if (cursor.pos() > 0) {
2006 bool boundary = cursor.boundary();
2007 setCursor(cursor.par(), cursor.pos() - 1, true, false);
2008 if (!internal && !boundary &&
2009 isBoundary(bv()->buffer(), *cursor.par(), cursor.pos() + 1))
2010 setCursor(cursor.par(), cursor.pos() + 1, true, true);
2011 } else if (cursor.par() != ownerParagraphs().begin()) { // steps into the above paragraph.
2012 ParagraphList::iterator pit = boost::prior(cursor.par());
2013 setCursor(pit, pit->size());
2018 void LyXText::cursorRight(bool internal)
2020 bool const at_end = (cursor.pos() == cursor.par()->size());
2021 bool const at_newline = !at_end &&
2022 cursor.par()->isNewline(cursor.pos());
2024 if (!internal && cursor.boundary() && !at_newline)
2025 setCursor(cursor.par(), cursor.pos(), true, false);
2027 setCursor(cursor.par(), cursor.pos() + 1, true, false);
2029 isBoundary(bv()->buffer(), *cursor.par(), cursor.pos()))
2030 setCursor(cursor.par(), cursor.pos(), true, true);
2031 } else if (boost::next(cursor.par()) != ownerParagraphs().end())
2032 setCursor(boost::next(cursor.par()), 0);
2036 void LyXText::cursorUp(bool selecting)
2039 int x = cursor.x_fix();
2040 int y = cursor.y() - cursor.row()->baseline() - 1;
2041 setCursorFromCoordinates(x, y);
2044 int y1 = cursor.iy() - topy;
2047 Inset * inset_hit = checkInsetHit(x, y1);
2048 if (inset_hit && isHighlyEditableInset(inset_hit)) {
2049 inset_hit->edit(bv(), x, y - (y2 - y1), mouse_button::none);
2053 setCursorFromCoordinates(bv(), cursor.x_fix(),
2054 cursor.y() - cursor.row()->baseline() - 1);
2059 void LyXText::cursorDown(bool selecting)
2062 int x = cursor.x_fix();
2063 int y = cursor.y() - cursor.row()->baseline() +
2064 cursor.row()->height() + 1;
2065 setCursorFromCoordinates(x, y);
2066 if (!selecting && cursor.row() == cursor.irow()) {
2068 int y1 = cursor.iy() - topy;
2071 Inset * inset_hit = checkInsetHit(x, y1);
2072 if (inset_hit && isHighlyEditableInset(inset_hit)) {
2073 inset_hit->edit(bv(), x, y - (y2 - y1), mouse_button::none);
2077 setCursorFromCoordinates(bv(), cursor.x_fix(),
2078 cursor.y() - cursor.row()->baseline()
2079 + cursor.row()->height() + 1);
2084 void LyXText::cursorUpParagraph()
2086 if (cursor.pos() > 0) {
2087 setCursor(cursor.par(), 0);
2089 else if (cursor.par() != ownerParagraphs().begin()) {
2090 setCursor(boost::prior(cursor.par()), 0);
2095 void LyXText::cursorDownParagraph()
2097 if (boost::next(cursor.par()) != ownerParagraphs().end()) {
2098 setCursor(boost::next(cursor.par()), 0);
2100 setCursor(cursor.par(), cursor.par()->size());
2104 // fix the cursor `cur' after a characters has been deleted at `where'
2105 // position. Called by deleteEmptyParagraphMechanism
2106 void LyXText::fixCursorAfterDelete(LyXCursor & cur,
2107 LyXCursor const & where)
2109 // if cursor is not in the paragraph where the delete occured,
2111 if (cur.par() != where.par())
2114 // if cursor position is after the place where the delete occured,
2116 if (cur.pos() > where.pos())
2117 cur.pos(cur.pos()-1);
2119 // check also if we don't want to set the cursor on a spot behind the
2120 // pagragraph because we erased the last character.
2121 if (cur.pos() > cur.par()->size())
2122 cur.pos(cur.par()->size());
2124 // recompute row et al. for this cursor
2125 setCursor(cur, cur.par(), cur.pos(), cur.boundary());
2129 bool LyXText::deleteEmptyParagraphMechanism(LyXCursor const & old_cursor)
2131 // Would be wrong to delete anything if we have a selection.
2132 if (selection.set())
2135 // We allow all kinds of "mumbo-jumbo" when freespacing.
2136 if (old_cursor.par()->layout()->free_spacing
2137 || old_cursor.par()->isFreeSpacing()) {
2141 /* Ok I'll put some comments here about what is missing.
2142 I have fixed BackSpace (and thus Delete) to not delete
2143 double-spaces automagically. I have also changed Cut,
2144 Copy and Paste to hopefully do some sensible things.
2145 There are still some small problems that can lead to
2146 double spaces stored in the document file or space at
2147 the beginning of paragraphs. This happens if you have
2148 the cursor betwenn to spaces and then save. Or if you
2149 cut and paste and the selection have a space at the
2150 beginning and then save right after the paste. I am
2151 sure none of these are very hard to fix, but I will
2152 put out 1.1.4pre2 with FIX_DOUBLE_SPACE defined so
2153 that I can get some feedback. (Lgb)
2156 // If old_cursor.pos() == 0 and old_cursor.pos()(1) == LineSeparator
2157 // delete the LineSeparator.
2160 // If old_cursor.pos() == 1 and old_cursor.pos()(0) == LineSeparator
2161 // delete the LineSeparator.
2164 // If the pos around the old_cursor were spaces, delete one of them.
2165 if (old_cursor.par() != cursor.par()
2166 || old_cursor.pos() != cursor.pos()) {
2167 // Only if the cursor has really moved
2169 if (old_cursor.pos() > 0
2170 && old_cursor.pos() < old_cursor.par()->size()
2171 && old_cursor.par()->isLineSeparator(old_cursor.pos())
2172 && old_cursor.par()->isLineSeparator(old_cursor.pos() - 1)) {
2173 old_cursor.par()->erase(old_cursor.pos() - 1);
2174 redoParagraphs(old_cursor, boost::next(old_cursor.par()));
2176 #ifdef WITH_WARNINGS
2177 #warning This will not work anymore when we have multiple views of the same buffer
2178 // In this case, we will have to correct also the cursors held by
2179 // other bufferviews. It will probably be easier to do that in a more
2180 // automated way in LyXCursor code. (JMarc 26/09/2001)
2182 // correct all cursors held by the LyXText
2183 fixCursorAfterDelete(cursor, old_cursor);
2184 fixCursorAfterDelete(selection.cursor,
2186 fixCursorAfterDelete(selection.start,
2188 fixCursorAfterDelete(selection.end, old_cursor);
2189 fixCursorAfterDelete(last_sel_cursor,
2191 fixCursorAfterDelete(toggle_cursor, old_cursor);
2192 fixCursorAfterDelete(toggle_end_cursor,
2198 // don't delete anything if this is the ONLY paragraph!
2199 if (ownerParagraphs().size() == 1)
2202 // Do not delete empty paragraphs with keepempty set.
2203 if (old_cursor.par()->layout()->keepempty)
2206 // only do our magic if we changed paragraph
2207 if (old_cursor.par() == cursor.par())
2210 // record if we have deleted a paragraph
2211 // we can't possibly have deleted a paragraph before this point
2212 bool deleted = false;
2214 if (old_cursor.par()->empty() ||
2215 (old_cursor.par()->size() == 1 &&
2216 old_cursor.par()->isLineSeparator(0))) {
2217 // ok, we will delete anything
2218 LyXCursor tmpcursor;
2222 bool selection_position_was_oldcursor_position = (
2223 selection.cursor.par() == old_cursor.par()
2224 && selection.cursor.pos() == old_cursor.pos());
2226 if (old_cursor.row() != rows().begin()) {
2228 prevrow = boost::prior(old_cursor.row());
2229 const_cast<LyXText *>(this)->postPaint(old_cursor.y() - old_cursor.row()->baseline() - prevrow->height());
2231 cursor = old_cursor; // that undo can restore the right cursor position
2232 #warning FIXME. --end() iterator is usable here
2233 ParagraphList::iterator endpit = boost::next(old_cursor.par());
2234 while (endpit != ownerParagraphs().end() &&
2235 endpit->getDepth()) {
2239 setUndo(bv(), Undo::DELETE, old_cursor.par(), endpit);
2243 removeRow(old_cursor.row());
2245 ownerParagraphs().erase(old_cursor.par());
2247 /* Breakagain the next par. Needed because of
2248 * the parindent that can occur or dissappear.
2249 * The next row can change its height, if
2250 * there is another layout before */
2251 if (boost::next(prevrow) != rows().end()) {
2252 breakAgain(boost::next(prevrow));
2255 setHeightOfRow(prevrow);
2257 RowList::iterator nextrow = boost::next(old_cursor.row());
2258 const_cast<LyXText *>(this)->postPaint(
2259 old_cursor.y() - old_cursor.row()->baseline());
2262 cursor = old_cursor; // that undo can restore the right cursor position
2263 #warning FIXME. --end() iterator is usable here
2264 ParagraphList::iterator endpit = boost::next(old_cursor.par());
2265 while (endpit != ownerParagraphs().end() &&
2266 endpit->getDepth()) {
2270 setUndo(bv(), Undo::DELETE, old_cursor.par(), endpit);
2274 removeRow(old_cursor.row());
2276 ownerParagraphs().erase(old_cursor.par());
2278 /* Breakagain the next par. Needed because of
2279 the parindent that can occur or dissappear.
2280 The next row can change its height, if
2281 there is another layout before */
2282 if (nextrow != rows().end()) {
2283 breakAgain(nextrow);
2289 setCursorIntern(cursor.par(), cursor.pos());
2291 if (selection_position_was_oldcursor_position) {
2292 // correct selection
2293 selection.cursor = cursor;
2297 if (old_cursor.par()->stripLeadingSpaces()) {
2298 redoParagraphs(old_cursor, boost::next(old_cursor.par()));
2300 setCursorIntern(cursor.par(), cursor.pos());
2301 selection.cursor = cursor;
2308 ParagraphList & LyXText::ownerParagraphs() const
2311 return inset_owner->paragraphs;
2313 return bv_owner->buffer()->paragraphs;
2317 LyXText::refresh_status LyXText::refreshStatus() const
2319 return refresh_status_;
2323 void LyXText::clearPaint()
2325 refresh_status_ = REFRESH_NONE;
2326 refresh_row = rows().end();
2331 void LyXText::postPaint(int start_y)
2333 refresh_status old = refresh_status_;
2335 refresh_status_ = REFRESH_AREA;
2336 refresh_row = rows().end();
2338 if (old != REFRESH_NONE && refresh_y < start_y)
2341 refresh_y = start_y;
2346 // We are an inset's lyxtext. Tell the top-level lyxtext
2347 // it needs to update the row we're in.
2348 LyXText * t = bv()->text;
2349 t->postRowPaint(t->cursor.row(), t->cursor.y() - t->cursor.row()->baseline());
2353 // FIXME: we should probably remove this y parameter,
2354 // make refresh_y be 0, and use row->y etc.
2355 void LyXText::postRowPaint(RowList::iterator rit, int start_y)
2357 if (refresh_status_ != REFRESH_NONE && refresh_y < start_y) {
2358 refresh_status_ = REFRESH_AREA;
2361 refresh_y = start_y;
2364 if (refresh_status_ == REFRESH_AREA)
2367 refresh_status_ = REFRESH_ROW;
2373 // We are an inset's lyxtext. Tell the top-level lyxtext
2374 // it needs to update the row we're in.
2375 LyXText * t = bv()->text;
2376 t->postRowPaint(t->cursor.row(), t->cursor.y() - t->cursor.row()->baseline());
2380 bool LyXText::isInInset() const
2382 // Sub-level has non-null bv owner and
2383 // non-null inset owner.
2384 return inset_owner != 0 && bv_owner != 0;
2388 int defaultRowHeight()
2390 LyXFont const font(LyXFont::ALL_SANE);
2391 return int(font_metrics::maxAscent(font)
2392 + font_metrics::maxDescent(font) * 1.5);