#include "Text.h"
+#include "Bidi.h"
#include "Buffer.h"
#include "buffer_funcs.h"
#include "BufferList.h"
#include "BufferParams.h"
#include "BufferView.h"
#include "Bullet.h"
-#include "Color.h"
+#include "Changes.h"
#include "Cursor.h"
#include "CutAndPaste.h"
-#include "debug.h"
#include "DispatchResult.h"
#include "ErrorList.h"
#include "FuncRequest.h"
-#include "gettext.h"
#include "Language.h"
+#include "Layout.h"
#include "Lexer.h"
#include "LyXFunc.h"
#include "LyXRC.h"
#include "Paragraph.h"
#include "paragraph_funcs.h"
#include "ParagraphParameters.h"
-#include "ParIterator.h"
-#include "Server.h"
-#include "ServerSocket.h"
-#include "Undo.h"
+#include "TextClass.h"
+#include "TextMetrics.h"
#include "VSpace.h"
#include "frontends/FontMetrics.h"
#include "mathed/InsetMathHull.h"
+#include "support/debug.h"
+#include "support/gettext.h"
#include "support/textutils.h"
-#include <boost/current_function.hpp>
+#include <boost/next_prior.hpp>
#include <sstream>
-using std::endl;
-using std::ostringstream;
-using std::string;
-using std::max;
-using std::min;
-using std::istringstream;
+using namespace std;
namespace lyx {
}
-Font Text::getLayoutFont(Buffer const & buffer, pit_type const pit) const
+FontInfo Text::getLayoutFont(Buffer const & buffer, pit_type const pit) const
{
LayoutPtr const & layout = pars_[pit].layout();
if (!pars_[pit].getDepth()) {
- Font lf = layout->resfont;
+ FontInfo lf = layout->resfont;
// In case the default family has been customized
- if (layout->font.family() == Font::INHERIT_FAMILY)
- lf.setFamily(buffer.params().getFont().family());
+ if (layout->font.family() == INHERIT_FAMILY)
+ lf.setFamily(buffer.params().getFont().fontInfo().family());
return lf;
}
- Font font = layout->font;
+ FontInfo font = layout->font;
// Realize with the fonts of lesser depth.
//font.realize(outerFont(pit, paragraphs()));
- font.realize(buffer.params().getFont());
+ font.realize(buffer.params().getFont().fontInfo());
return font;
}
-Font Text::getLabelFont(Buffer const & buffer, Paragraph const & par) const
+FontInfo Text::getLabelFont(Buffer const & buffer, Paragraph const & par) const
{
LayoutPtr const & layout = par.layout();
if (!par.getDepth()) {
- Font lf = layout->reslabelfont;
+ FontInfo lf = layout->reslabelfont;
// In case the default family has been customized
- if (layout->labelfont.family() == Font::INHERIT_FAMILY)
- lf.setFamily(buffer.params().getFont().family());
+ if (layout->labelfont.family() == INHERIT_FAMILY)
+ lf.setFamily(buffer.params().getFont().fontInfo().family());
return lf;
}
- Font font = layout->labelfont;
+ FontInfo font = layout->labelfont;
// Realize with the fonts of lesser depth.
- font.realize(buffer.params().getFont());
+ font.realize(buffer.params().getFont().fontInfo());
return font;
}
LayoutPtr const & layout = pars_[pit].layout();
// Get concrete layout font to reduce against
- Font layoutfont;
+ FontInfo layoutfont;
if (pos < pars_[pit].beginOfBody())
layoutfont = layout->labelfont;
// Inside inset, apply the inset's font attributes if any
// (charstyle!)
if (!isMainText(buffer))
- layoutfont.realize(display_font);
+ layoutfont.realize(display_font.fontInfo());
- layoutfont.realize(buffer.params().getFont());
+ layoutfont.realize(buffer.params().getFont().fontInfo());
// Now, reduce font against full layout font
- font.reduce(layoutfont);
+ font.fontInfo().reduce(layoutfont);
pars_[pit].setFont(pos, font);
}
void Text::setInsetFont(BufferView const & bv, pit_type pit,
pos_type pos, Font const & font, bool toggleall)
{
- BOOST_ASSERT(pars_[pit].isInset(pos) &&
- pars_[pit].getInset(pos)->noFontChange());
-
Inset * const inset = pars_[pit].getInset(pos);
+ BOOST_ASSERT(inset && inset->noFontChange());
+
CursorSlice::idx_type endidx = inset->nargs();
for (CursorSlice cs(*inset); cs.idx() != endidx; ++cs.idx()) {
Text * text = cs.text();
LayoutPtr const & lyxlayout = params.getTextClass()[layout];
if (lyxlayout->is_environment) {
// move everything in a new environment inset
- LYXERR(Debug::DEBUG) << "setting layout " << to_utf8(layout) << endl;
+ LYXERR(Debug::DEBUG, "setting layout " << to_utf8(layout));
lyx::dispatch(FuncRequest(LFUN_LINE_BEGIN));
lyx::dispatch(FuncRequest(LFUN_LINE_END_SELECT));
lyx::dispatch(FuncRequest(LFUN_CUT));
BOOST_ASSERT(this == cur.text());
pit_type const beg = cur.selBegin().pit();
pit_type const end = cur.selEnd().pit() + 1;
- recordUndoSelection(cur);
+ cur.recordUndoSelection();
int max_depth = (beg != 0 ? pars_[beg - 1].getMaxDepthAfter() : 0);
for (pit_type pit = beg; pit != end; ++pit) {
BOOST_ASSERT(this == cur.text());
// Set the current_font
// Determine basis font
- Font layoutfont;
+ FontInfo layoutfont;
pit_type pit = cur.pit();
if (cur.pos() < pars_[pit].beginOfBody())
layoutfont = getLabelFont(cur.buffer(), pars_[pit]);
// Reduce to implicit settings
cur.current_font = cur.real_current_font;
- cur.current_font.reduce(layoutfont);
+ cur.current_font.fontInfo().reduce(layoutfont);
// And resolve it completely
- cur.real_current_font.realize(layoutfont);
+ cur.real_current_font.fontInfo().realize(layoutfont);
// if there is no selection that's all we need to do
if (!cur.selection())
return;
// Ok, we have a selection.
- recordUndoSelection(cur);
+ cur.recordUndoSelection();
setFont(cur.bv(), cur.selectionBegin().top(),
cur.selectionEnd().top(), font, toggleall);
if (dit.pos() != dit.lastpos()) {
pit_type const pit = dit.pit();
pos_type const pos = dit.pos();
- if (pars_[pit].isInset(pos) &&
- pars_[pit].getInset(pos)->noFontChange())
+ Inset * inset = pars_[pit].getInset(pos);
+ if (inset && inset->noFontChange()) {
// We need to propagate the font change to all
// text cells of the inset (bug 1973).
// FIXME: This should change, see documentation
// of noFontChange in Inset.h
setInsetFont(bv, pit, pos, font, toggleall);
+ }
TextMetrics const & tm = bv.textMetrics(this);
Font f = tm.getDisplayFont(pit, pos);
f.update(font, language, toggleall);
{
BOOST_ASSERT(this == cur.text());
// If the mask is completely neutral, tell user
- if (font == Font(Font::ALL_IGNORE)) {
+ if (font.fontInfo() == ignore_font &&
+ (font.language() == 0 || font.language() == ignore_language)) {
// Could only happen with user style
cur.message(_("No font change defined."));
return;
CursorSlice resetCursor = cur.top();
bool implicitSelection =
font.language() == ignore_language
- && font.number() == Font::IGNORE
+ && font.fontInfo().number() == FONT_IGNORE
&& selectWordWhenUnderCursor(cur, WHOLE_WORD_STRICT);
// Set font
if (!front && cur.pos() == 0)
return false;
Inset * inset = front ? cur.nextInset() : cur.prevInset();
- if (!isHighlyEditableInset(inset))
+ if (!inset || inset->editable() != Inset::HIGHLY_EDITABLE)
return false;
/*
* Apparently, when entering an inset we are expected to be positioned
}
-bool Text::cursorLeft(Cursor & cur)
+bool Text::checkAndActivateInsetVisual(Cursor & cur, bool movingForward, bool movingLeft)
+{
+ if (cur.selection())
+ return false;
+ if (cur.pos() == -1)
+ return false;
+ if (cur.pos() == cur.lastpos())
+ return false;
+ Paragraph & par = cur.paragraph();
+ Inset * inset = par.isInset(cur.pos()) ? par.getInset(cur.pos()) : 0;
+ if (!inset || inset->editable() != Inset::HIGHLY_EDITABLE)
+ return false;
+ inset->edit(cur, movingForward,
+ movingLeft ? Inset::ENTRY_DIRECTION_RIGHT : Inset::ENTRY_DIRECTION_LEFT);
+ return true;
+}
+
+
+bool Text::cursorBackward(Cursor & cur)
{
// Tell BufferView to test for FitCursor in any case!
cur.updateFlags(Update::FitCursor);
}
-bool Text::cursorRight(Cursor & cur)
+bool Text::cursorVisLeft(Cursor & cur, bool skip_inset)
+{
+ pit_type new_pit = cur.pit(); // the paragraph to which we will move
+ pos_type new_pos; // the position we will move to
+ bool new_boundary; // will we move to a boundary position?
+ pos_type left_pos; // position visually left of current cursor
+ pos_type right_pos; // position visually right of current cursor
+ bool new_pos_is_RTL; // is new position we're moving to RTL?
+
+ cur.getSurroundingPos(left_pos, right_pos);
+
+ LYXERR(Debug::RTL, left_pos <<"|"<< right_pos << " (pos: "<<cur.pos()<<")");
+
+ // Are we at an inset?
+ Cursor temp_cur = cur;
+ temp_cur.pos() = left_pos;
+ temp_cur.boundary(false);
+ if (!skip_inset &&
+ checkAndActivateInsetVisual(temp_cur, left_pos >= cur.pos(), true)) {
+ LYXERR(Debug::RTL, "entering inset at: " << temp_cur.pos());
+ cur = temp_cur; // set the real cursor to new position inside inset!
+ return false;
+ }
+
+ // Are we already at leftmost pos in row?
+ if (left_pos == -1) {
+
+ Cursor new_cur = cur;
+ if (!new_cur.posVisToNewRow(true)) {
+ LYXERR(Debug::RTL, "not moving!");
+ return false;
+ }
+
+ // we actually move the cursor at the end of this function, for now
+ // just keep track of the new position...
+ new_pit = new_cur.pit();
+ new_pos = new_cur.pos();
+ new_boundary = new_cur.boundary();
+
+ LYXERR(Debug::RTL, "left edge, moving: " << int(new_pit) << ","
+ << int(new_pos) << "," << (new_boundary ? 1 : 0));
+
+ }
+ // normal movement to the left
+ else {
+ // Recall, if the cursor is at position 'x', that means *before*
+ // the character at position 'x'. In RTL, "before" means "to the
+ // right of", in LTR, "to the left of". So currently our situation
+ // is this: the position to our left is 'left_pos' (i.e., we're
+ // currently to the right of 'left_pos'). In order to move to the
+ // left, it depends whether or not the character at 'left_pos' is RTL.
+ new_pos_is_RTL = cur.paragraph().getFontSettings(
+ cur.bv().buffer().params(), left_pos).isVisibleRightToLeft();
+ // If the character at 'left_pos' *is* RTL, then in order to move to
+ // the left of it, we need to be *after* 'left_pos', i.e., move to
+ // position 'left_pos' + 1.
+ if (new_pos_is_RTL) {
+ new_pos = left_pos + 1;
+ // if the position *after* left_pos is not RTL, set boundary to
+ // true (we want to be *after* left_pos, not before left_pos + 1!)
+ new_boundary = !cur.paragraph().getFontSettings(
+ cur.bv().buffer().params(), new_pos).isVisibleRightToLeft();
+ }
+ // Otherwise (if the character at position 'left_pos' is LTR), then
+ // moving to the left of it is as easy as setting the new position
+ // to 'left_pos'.
+ else {
+ new_pos = left_pos;
+ new_boundary = false;
+ }
+
+ }
+
+ LYXERR(Debug::RTL, "moving to: " << new_pos
+ << (new_boundary ? " (boundary)" : ""));
+
+ return setCursor(cur, new_pit, new_pos, true, new_boundary);
+}
+
+
+bool Text::cursorVisRight(Cursor & cur, bool skip_inset)
+{
+ pit_type new_pit = cur.pit(); // the paragraph to which we will move
+ pos_type new_pos; // the position we will move to
+ bool new_boundary; // will we move to a boundary position?
+ pos_type left_pos; // position visually left of current cursor
+ pos_type right_pos; // position visually right of current cursor
+ bool new_pos_is_RTL; // is new position we're moving to RTL?
+
+ cur.getSurroundingPos(left_pos, right_pos);
+
+ LYXERR(Debug::RTL, left_pos <<"|"<< right_pos << " (pos: "<<cur.pos()<<")");
+
+ // Are we at an inset?
+ Cursor temp_cur = cur;
+ temp_cur.pos() = right_pos;
+ temp_cur.boundary(false);
+ if (!skip_inset &&
+ checkAndActivateInsetVisual(temp_cur, right_pos >= cur.pos(), false)) {
+ LYXERR(Debug::RTL, "entering inset at: " << temp_cur.pos());
+ cur = temp_cur; // set the real cursor to new position inside inset!
+ return false;
+ }
+
+ // Are we already at rightmost pos in row?
+ if (right_pos == -1) {
+
+ Cursor new_cur = cur;
+ if (!new_cur.posVisToNewRow(false)) {
+ LYXERR(Debug::RTL, "not moving!");
+ return false;
+ }
+
+ // we actually move the cursor at the end of this function, for now
+ // just keep track of the new position...
+ new_pit = new_cur.pit();
+ new_pos = new_cur.pos();
+ new_boundary = new_cur.boundary();
+
+ LYXERR(Debug::RTL, "right edge, moving: " << int(new_pit) << ","
+ << int(new_pos) << "," << (new_boundary ? 1 : 0));
+
+ }
+ // normal movement to the right
+ else {
+ // Recall, if the cursor is at position 'x', that means *before*
+ // the character at position 'x'. In RTL, "before" means "to the
+ // right of", in LTR, "to the left of". So currently our situation
+ // is this: the position to our right is 'right_pos' (i.e., we're
+ // currently to the left of 'right_pos'). In order to move to the
+ // right, it depends whether or not the character at 'right_pos' is RTL.
+ new_pos_is_RTL = cur.paragraph().getFontSettings(
+ cur.bv().buffer().params(), right_pos).isVisibleRightToLeft();
+ // If the character at 'right_pos' *is* LTR, then in order to move to
+ // the right of it, we need to be *after* 'right_pos', i.e., move to
+ // position 'right_pos' + 1.
+ if (!new_pos_is_RTL) {
+ new_pos = right_pos + 1;
+ // if the position *after* right_pos is RTL, set boundary to
+ // true (we want to be *after* right_pos, not before right_pos + 1!)
+ new_boundary = cur.paragraph().getFontSettings(
+ cur.bv().buffer().params(), new_pos).isVisibleRightToLeft();
+ }
+ // Otherwise (if the character at position 'right_pos' is RTL), then
+ // moving to the right of it is as easy as setting the new position
+ // to 'right_pos'.
+ else {
+ new_pos = right_pos;
+ new_boundary = false;
+ }
+
+ }
+
+ LYXERR(Debug::RTL, "moving to: " << new_pos
+ << (new_boundary ? " (boundary)" : ""));
+
+ return setCursor(cur, new_pit, new_pos, true, new_boundary);
+}
+
+
+bool Text::cursorForward(Cursor & cur)
{
// Tell BufferView to test for FitCursor in any case!
cur.updateFlags(Update::FitCursor);
bool Text::deleteEmptyParagraphMechanism(Cursor & cur,
Cursor & old, bool & need_anchor_change)
{
- //LYXERR(Debug::DEBUG) << "DEPM: cur:\n" << cur << "old:\n" << old << endl;
+ //LYXERR(Debug::DEBUG, "DEPM: cur:\n" << cur << "old:\n" << old);
Paragraph & oldpar = old.paragraph();
if (oldpar.empty() || (oldpar.size() == 1 && oldpar.isLineSeparator(0))) {
// Delete old par.
- recordUndo(old, Undo::ATOMIC,
+ old.recordUndo(ATOMIC_UNDO,
max(old.pit() - 1, pit_type(0)),
min(old.pit() + 1, old.lastpit()));
ParagraphList & plist = old.text()->paragraphs();
bool const soa = oldpar.params().startOfAppendix();
plist.erase(boost::next(plist.begin(), old.pit()));
// do not lose start of appendix marker (bug 4212)
- if (soa)
+ if (soa && old.pit() < pit_type(plist.size()))
plist[old.pit()].params().startOfAppendix(true);
// see #warning (FIXME?) above
void Text::recUndo(Cursor & cur, pit_type first, pit_type last) const
{
- recordUndo(cur, Undo::ATOMIC, first, last);
+ cur.recordUndo(ATOMIC_UNDO, first, last);
}
void Text::recUndo(Cursor & cur, pit_type par) const
{
- recordUndo(cur, Undo::ATOMIC, par, par);
+ cur.recordUndo(ATOMIC_UNDO, par, par);
}
} // namespace lyx
projects / lyx.git / blobdiff