#include "lyxtext.h"
#include "lyxrow.h"
-#include "lyxtextclasslist.h"
#include "paragraph.h"
#include "gettext.h"
#include "bufferparams.h"
#include "buffer.h"
#include "debug.h"
+#include "intl.h"
#include "lyxrc.h"
#include "encoding.h"
#include "frontends/LyXView.h"
#include "frontends/Painter.h"
#include "frontends/font_metrics.h"
#include "frontends/screen.h"
+#include "frontends/WorkArea.h"
#include "bufferview_funcs.h"
#include "BufferView.h"
#include "language.h"
#include "ParagraphParameters.h"
#include "undo_funcs.h"
+#include "WordLangTuple.h"
+#include "paragraph_funcs.h"
#include "insets/insetbib.h"
#include "insets/insettext.h"
Buffer::inset_iterator it = bview->buffer()->inset_iterator_begin();
Buffer::inset_iterator end = bview->buffer()->inset_iterator_end();
for (; it != end; ++it) {
- if (*it == inset) {
+ if (&(*it) == inset) {
par = it.getPar();
pos = it.getPos();
break;
}
if (Encodings::is_arabic(next_char)) {
- if (Encodings::is_arabic(prev_char))
+ if (Encodings::is_arabic(prev_char) &&
+ !Encodings::is_arabic_special(prev_char))
return Encodings::TransformChar(c, Encodings::FORM_MEDIAL);
else
return Encodings::TransformChar(c, Encodings::FORM_INITIAL);
} else {
- if (Encodings::is_arabic(prev_char))
+ if (Encodings::is_arabic(prev_char) &&
+ !Encodings::is_arabic_special(prev_char))
return Encodings::TransformChar(c, Encodings::FORM_FINAL);
else
return Encodings::TransformChar(c, Encodings::FORM_ISOLATED);
if (orig_font != getFont(p.bv->buffer(), p.row->par(), pos))
break;
+ if (arabic)
+ c = transformChar(c, p.row->par(), pos);
str += c;
++vpos;
}
if ((!hebrew && !arabic)
|| (hebrew && !Encodings::IsComposeChar_hebrew(c))
|| (arabic && !Encodings::IsComposeChar_arabic(c))) {
- drawChars(p, vpos, true, false);
+ drawChars(p, vpos, hebrew, arabic);
} else if (hebrew) {
drawHebrewComposeChar(p, vpos);
} else if (arabic) {
drawForeignMark(p, orig_x, orig_font);
-#ifdef INHERIT_LANGUAGE
-#ifdef WITH_WARNINGS
- if ((font.language() == inherit_language) ||
- (font.language() == ignore_language))
- lyxerr << "No this shouldn't happen!\n";
-#endif
-#endif
return true;
}
return LYX_PAPER_MARGIN;
LyXTextClass const & tclass =
- textclasslist[bview->buffer()->params.textclass];
+ bview->buffer()->params.getLyXTextClass();
LyXLayout_ptr const & layout = row->par()->layout();
string parindent = layout->parindent;
} else {
// find the next level paragraph
- Paragraph * newpar =
- row->par()->outerHook();
+ Paragraph * newpar = row->par()->outerHook();
// make a corresponding row. Needed to call LeftMargin()
LyXLength const len = row->par()->params().leftIndent();
int const tw = inset_owner ?
inset_owner->latexTextWidth(bview) : workWidth(bview);
- x += len.inPixels(tw, bview->text->defaultHeight());
+ x += len.inPixels(tw);
}
LyXAlignment align; // wrong type
(ins->needFullRow() || ins->display()))
return LYX_PAPER_MARGIN;
- LyXTextClass const & tclass = textclasslist[buf->params.textclass];
+ LyXTextClass const & tclass = buf->params.getLyXTextClass();
LyXLayout_ptr const & layout = row->par()->layout();
int x = LYX_PAPER_MARGIN
void LyXText::breakParagraph(BufferView * bview, char keep_layout)
{
LyXTextClass const & tclass =
- textclasslist[bview->buffer()->params.textclass];
+ bview->buffer()->params.getLyXTextClass();
LyXLayout_ptr const & layout = cursor.par()->layout();
// this is only allowed, if the current paragraph is not empty or caption
// and if it has not the keepempty flag aktive
- if ((cursor.par()->size() <= 0)
+ if (cursor.par()->empty()
&& layout->labeltype != LABEL_SENSITIVE
&& !layout->keepempty)
return;
// breakParagraph call should return a bool if it inserts the
// paragraph before or behind and we should react on that one
// but we can fix this in 1.3.0 (Jug 20020509)
- bool const isempty = (layout->keepempty && !cursor.par()->size());
- cursor.par()->breakParagraph(bview->buffer()->params, cursor.pos(),
- keep_layout);
+ bool const isempty = (layout->keepempty && cursor.par()->empty());
+ ::breakParagraph(bview->buffer()->params, cursor.par(), cursor.pos(),
+ keep_layout);
// well this is the caption hack since one caption is really enough
if (layout->labeltype == LABEL_SENSITIVE) {
setHeightOfRow(bview, cursor.row());
- while (cursor.par()->next()->size()
+ while (!cursor.par()->next()->empty()
&& cursor.par()->next()->isNewline(0))
cursor.par()->next()->erase(0);
insertParagraph(bview, cursor.par()->next(), cursor.row());
- updateCounters(bview, cursor.row()->previous());
+ updateCounters(bview);
// This check is necessary. Otherwise the new empty paragraph will
// be deleted automatically. And it is more friendly for the user!
// we would not get a rebreak!
row->fill(fill(bview, row, workWidth(bview)));
}
+
if (c == Paragraph::META_INSET || row->fill() < 0) {
refresh_y = y;
refresh_row = row;
- refresh_x = cursor.x();
- refresh_pos = cursor.pos();
status(bview, LyXText::NEED_MORE_REFRESH);
breakAgainOneRow(bview, row);
// will the cursor be in another row now?
need_break_row = 0;
} else {
refresh_y = y;
- refresh_x = cursor.x();
refresh_row = row;
- refresh_pos = cursor.pos();
int const tmpheight = row->height();
setHeightOfRow(bview, row);
}
-void LyXText::cursorLeftOneWord(LyXCursor & cur) const
+void LyXText::cursorLeftOneWord(LyXCursor & cur) const
{
// treat HFills, floats and Insets as words
cur = cursor;
}
} else { // Here, cur != 0
while (cur.pos() > 0 &&
- cur.par()->isWord(cur.pos()-1))
+ cur.par()->isWord(cur.pos() - 1))
cur.pos(cur.pos() - 1);
}
}
if (cursor.pos() == 0 || cursor.pos() == cursor.par()->size()
|| cursor.par()->isSeparator(cursor.pos())
|| cursor.par()->isKomma(cursor.pos())
- || cursor.par()->isSeparator(cursor.pos() -1)
- || cursor.par()->isKomma(cursor.pos() -1)) {
+ || cursor.par()->isSeparator(cursor.pos() - 1)
+ || cursor.par()->isKomma(cursor.pos() - 1)) {
to = from;
return;
}
// This function is only used by the spellchecker for NextWord().
// It doesn't handle LYX_ACCENTs and probably never will.
-string const LyXText::selectNextWordToSpellcheck(BufferView * bview,
- float & value) const
+WordLangTuple const
+LyXText::selectNextWordToSpellcheck(BufferView * bview, float & value) const
{
if (the_locking_inset) {
- string str = the_locking_inset->selectNextWordToSpellcheck(bview, value);
- if (!str.empty()) {
- value += float(cursor.y())/float(height);
- return str;
+ WordLangTuple word = the_locking_inset->selectNextWordToSpellcheck(bview, value);
+ if (!word.word().empty()) {
+ value += float(cursor.y());
+ value /= float(height);
+ return word;
}
- // we have to go on checking so move cusor to the next char
+ // we have to go on checking so move cursor to the next char
if (cursor.pos() == cursor.par()->size()) {
if (!cursor.par()->next())
- return str;
+ return word;
cursor.par(cursor.par()->next());
cursor.pos(0);
} else
// Start the selection from here
selection.cursor = cursor;
+ string lang_code(
+ getFont(bview->buffer(), cursor.par(), cursor.pos())
+ .language()->code());
// and find the end of the word (insets like optional hyphens
// and ligature break are part of a word)
while (cursor.pos() < cursor.par()->size()
str += cursor.par()->getChar(i);
}
}
- return str;
+ return WordLangTuple(str, lang_code);
}
// Delete from cursor up to the end of the current or next word.
void LyXText::deleteWordForward(BufferView * bview)
{
- if (!cursor.par()->size())
+ if (cursor.par()->empty())
cursorRight(bview);
else {
LyXCursor tmpcursor = cursor;
// Delete from cursor to start of current or prior word.
void LyXText::deleteWordBackward(BufferView * bview)
{
- if (!cursor.par()->size())
+ if (cursor.par()->empty())
cursorLeft(bview);
else {
LyXCursor tmpcursor = cursor;
// Kill to end of line.
void LyXText::deleteLineForward(BufferView * bview)
{
- if (!cursor.par()->size())
+ if (cursor.par()->empty())
// Paragraph is empty, so we just go to the right
cursorRight(bview);
else {
// different wether it is open or closed.
// Correction: Pasting is always allowed with standard-layout
- LyXTextClass const & tclass = textclasslist[bview->buffer()->params.textclass];
+ LyXTextClass const & tclass =
+ bview->buffer()->params.getLyXTextClass();
if (cursor.par() != tmppar
&& (cursor.par()->layout() == tmppar->layout()
&& cursor.par()->getAlign() == tmppar->getAlign()) {
removeParagraph(tmprow);
removeRow(tmprow);
- cursor.par()->pasteParagraph(bview->buffer()->params);
+ mergeParagraph(bview->buffer()->params, cursor.par());
if (!cursor.pos() || !cursor.par()->isSeparator(cursor.pos() - 1))
; //cursor.par()->insertChar(cursor.pos(), ' ');
// This rebuilds the rows.
appendParagraph(bview, cursor.row());
- updateCounters(bview, cursor.row());
+ updateCounters(bview);
// the row may have changed, block, hfills etc.
setCursor(bview, cursor.par(), cursor.pos(), false);
}
// delete newlines at the beginning of paragraphs
- while (cursor.par()->size() &&
+ while (!cursor.par()->empty() &&
cursor.par()->isNewline(cursor.pos()) &&
cursor.pos() == beginningOfMainBody(bview->buffer(),
cursor.par())) {
}
return;
} else if (startrow != row && endrow != row) {
- int w = p.width;
- int h = row->height();
if (p.y > starty && p.y < endy) {
+ int w = p.width;
+ int h = row->height();
p.pain->fillRectangle(p.xo, p.yo, w, h, LColor::selection);
}
return;
}
- if (!((startrow != row && !is_rtl) || (endrow != row && is_rtl))) {
- return;
- }
-
- float tmpx = p.x;
-
- p.pain->fillRectangle(p.xo, p.yo, int(p.x), row->height(), LColor::selection);
+ if ((startrow != row && !is_rtl) || (endrow != row && is_rtl))
+ p.pain->fillRectangle(p.xo, p.yo, int(p.x), row->height(), LColor::selection);
Buffer const * buffer = p.bv->buffer();
Paragraph * par = row->par();
pos_type main_body = beginningOfMainBody(buffer, par);
pos_type const last = rowLastPrintable(row);
+ float tmpx = p.x;
for (pos_type vpos = row->pos(); vpos <= last; ++vpos) {
pos_type pos = vis2log(vpos);
int(tmpx - old_tmpx + 1),
row->height(), LColor::selection);
}
+ }
- if ((startrow != row && is_rtl) || (endrow != row && !is_rtl)) {
- p.pain->fillRectangle(p.xo + int(tmpx),
- p.yo, int(p.bv->workWidth() - tmpx),
- row->height(), LColor::selection);
- }
+ if ((startrow != row && is_rtl) || (endrow != row && !is_rtl)) {
+ p.pain->fillRectangle(p.xo + int(tmpx),
+ p.yo, int(p.bv->workWidth() - tmpx),
+ row->height(), LColor::selection);
}
}
switch (vsp.kind()) {
case VSpace::LENGTH:
{
- str = prefix + " (" + vsp.asLyXCommand() + ")";
+ str = prefix + " (" + vsp.asLyXCommand() + ')';
// adding or removing space
bool const added = !(vsp.length().len().value() < 0.0);
ty1 = added ? (start + arrow_size) : start;
by2 = added ? end : (end - arrow_size);
break;
}
- case VSpace:: VFILL:
- str = prefix + " (vertical fill)";
+ case VSpace::VFILL:
+ str = prefix + _(" (vertical fill)");
ty1 = ty2 = start;
by1 = by2 = end;
break;
p.pain->rectText(leftx + 2 * arrow_size + 5,
start + ((end - start) / 2) + d,
- str, font,
- backgroundColor(),
- backgroundColor());
+ str, font);
// top arrow
p.pain->line(leftx, ty1, midx, ty2, LColor::added_space);
}
+int LyXText::paintPageBreak(string const & label, int y, DrawRowParams & p)
+{
+ LyXFont pb_font;
+ pb_font.setColor(LColor::pagebreak).decSize();
+
+ int w = 0;
+ int a = 0;
+ int d = 0;
+ font_metrics::rectText(label, pb_font, w, a, d);
+
+ int const text_start = p.xo + ((p.width - w) / 2);
+ int const text_end = text_start + w;
+
+ p.pain->rectText(text_start, y + d, label, pb_font);
+
+ p.pain->line(p.xo, y, text_start, y,
+ LColor::pagebreak, Painter::line_onoffdash);
+ p.pain->line(text_end, y, p.xo + p.width, y,
+ LColor::pagebreak, Painter::line_onoffdash);
+
+ return 3 * defaultHeight();
+}
+
+
void LyXText::paintFirstRow(DrawRowParams & p)
{
Paragraph * par = p.row->par();
// draw a top pagebreak
if (parparams.pagebreakTop()) {
- int const y = p.yo + y_top + 2*defaultHeight();
- p.pain->line(p.xo, y, p.xo + p.width, y,
- LColor::pagebreak, Painter::line_onoffdash);
-
- int w = 0;
- int a = 0;
- int d = 0;
-
- LyXFont pb_font;
- pb_font.setColor(LColor::pagebreak).decSize();
- font_metrics::rectText(_("Page Break (top)"), pb_font, w, a, d);
- p.pain->rectText((p.width - w)/2, y + d,
- _("Page Break (top)"), pb_font,
- backgroundColor(),
- backgroundColor());
- y_top += 3 * defaultHeight();
+ y_top += paintPageBreak(_("Page Break (top)"),
+ p.yo + y_top + 2 * defaultHeight(), p);
}
// draw the additional space if needed:
// draw a bottom pagebreak
if (parparams.pagebreakBottom()) {
- LyXFont pb_font;
- pb_font.setColor(LColor::pagebreak).decSize();
- int const y = p.yo + y_bottom - 2 * defaultHeight();
-
- p.pain->line(p.xo, y, p.xo + p.width, y, LColor::pagebreak,
- Painter::line_onoffdash);
-
- int w = 0;
- int a = 0;
- int d = 0;
- font_metrics::rectText(_("Page Break (bottom)"), pb_font, w, a, d);
- p.pain->rectText((ww - w) / 2, y + d,
- _("Page Break (bottom)"),
- pb_font, backgroundColor(), backgroundColor());
-
- y_bottom -= 3 * defaultHeight();
+ y_bottom -= paintPageBreak(_("Page Break (bottom)"),
+ p.yo + y_bottom - 2 * defaultHeight(), p);
}
// draw the additional space if needed:
}
}
+
void LyXText::paintRowText(DrawRowParams & p)
{
Paragraph * par = p.row->par();
}
if (hfillExpansion(bview->buffer(), row, c)) {
- x += singleWidth(bview, row->par(), c);
+ tmpx += singleWidth(bview, row->par(), c);
if (c >= main_body)
tmpx += fill_hfill;
else
projects / lyx.git / blobdiff