* ====================================================== */
#include <config.h>
-#include <cstdlib>
-#include <cctype>
+//#include <cstdlib> //these two do not seem useful anymore (JMarc)
+//#include <cctype>
#include <algorithm>
#include "lyxtext.h"
}
+int LyXText::workWidth(BufferView * bview, Inset * inset) const
+{
+ Buffer::inset_iterator it;
+ Paragraph * par = 0;
+ Paragraph::size_type pos = 0;
+
+ for(it=bview->buffer()->inset_iterator_begin();
+ it != bview->buffer()->inset_iterator_end();
+ ++it)
+ {
+ if (*it == inset) {
+ par = it.getPar();
+ pos = it.getPos();
+ break;
+ }
+ }
+ if (!par) {
+ return workWidth(bview);
+ }
+
+ LyXLayout const & layout =
+ textclasslist.Style(bview->buffer()->params.textclass,
+ par->getLayout());
+
+ if (layout.margintype != MARGIN_RIGHT_ADDRESS_BOX) {
+ // Optimization here: in most cases, the real row is
+ // not needed, but only the par/pos values. So we just
+ // construct a dummy row for leftMargin. (JMarc)
+ Row dummyrow;
+ dummyrow.par(par);
+ dummyrow.pos(pos);
+ return workWidth(bview) - leftMargin(bview, &dummyrow);
+ } else {
+ int dummy_y;
+ Row * row = getRow(par, pos, dummy_y);
+ Row * frow = row;
+ while(frow->previous() && frow->par() == frow->previous()->par())
+ frow = frow->previous();
+ int maxw = 0;
+ while(frow->next() && frow->par() == frow->next()->par()) {
+ if ((frow != row) && (maxw < frow->width()))
+ maxw = frow->width();
+ frow = frow->next();
+ }
+ if (maxw)
+ return maxw;
+ }
+ return workWidth(bview);
+}
+
+
int LyXText::getRealCursorX(BufferView * bview) const
{
int x = cursor.x();
// exactly the label-width.
int LyXText::leftMargin(BufferView * bview, Row const * row) const
{
- LyXLayout const & layout =
- textclasslist.Style(bview->buffer()->params.textclass,
- row->par()->getLayout());
+ LyXTextClass const & tclass =
+ textclasslist.TextClass(bview->buffer()->params.textclass);
+ LyXLayout const & layout = tclass[row->par()->getLayout()];
string parindent = layout.parindent;
int x = LYX_PAPER_MARGIN;
- x += lyxfont::signedWidth(textclasslist
- .TextClass(bview->buffer()->params.textclass)
- .leftmargin(),
- textclasslist
- .TextClass(bview->buffer()->params.textclass)
- .defaultfont());
+ x += lyxfont::signedWidth(tclass.leftmargin(), tclass.defaultfont());
// this is the way, LyX handles the LaTeX-Environments.
// I have had this idea very late, so it seems to be a
Paragraph * newpar = row->par()
->depthHook(row->par()->getDepth());
if (newpar &&
- textclasslist.Style(bview->buffer()->params.textclass,
- newpar->getLayout())
- .nextnoindent)
+ tclass[newpar->getLayout()].nextnoindent)
parindent.erase();
}
}
// make a corresponding row. Needed to call LeftMargin()
// check wether it is a sufficent paragraph
- if (newpar
- && textclasslist
- .Style(bview->buffer()->params.textclass,
- newpar->getLayout()).isEnvironment()) {
+ if (newpar && tclass[newpar->getLayout()].isEnvironment())
+ {
Row dummyrow;
dummyrow.par(newpar);
dummyrow.pos(newpar->size());
if (newpar->params().noindent())
parindent.erase();
else
- parindent = textclasslist
- .Style(bview->buffer()->params.textclass,
- newpar->getLayout()).parindent;
+ parindent = tclass[newpar->getLayout()].parindent;
}
}
case MARGIN_DYNAMIC:
if (!layout.leftmargin.empty()) {
x += lyxfont::signedWidth(layout.leftmargin,
- textclasslist
- .TextClass(bview->buffer()->params.
- textclass)
- .defaultfont());
+ tclass.defaultfont());
}
if (!row->par()->getLabelstring().empty()) {
x += lyxfont::signedWidth(layout.labelindent,
}
break;
case MARGIN_STATIC:
- x += lyxfont::signedWidth(layout.leftmargin, textclasslist.TextClass(bview->buffer()->params.textclass).defaultfont()) * 4
+ x += lyxfont::signedWidth(layout.leftmargin, tclass.defaultfont()) * 4
/ (row->par()->getDepth() + 4);
break;
case MARGIN_FIRST_DYNAMIC:
}
x += lyxfont::signedWidth(layout.leftmargin,
- textclasslist
- .TextClass(bview->buffer()->params.textclass)
- .defaultfont());
+ tclass.defaultfont());
x += minfill;
}
break;
}
- int align; // wrong type
+ LyXAlignment align; // wrong type
if (row->par()->params().align() == LYX_ALIGN_LAYOUT)
align = layout.align;
bview->buffer()->params.paragraph_separation ==
BufferParams::PARSEP_INDENT))
x += lyxfont::signedWidth(parindent,
- textclasslist
- .TextClass(bview->buffer()->params
- .textclass)
- .defaultfont());
+ tclass.defaultfont());
else if (layout.labeltype == LABEL_BIBLIO) {
// ale970405 Right width for bibitems
- x += bibitemMaxWidth(bview,textclasslist
- .TextClass(bview->buffer()->params
- .textclass)
- .defaultfont());
+ x += bibitemMaxWidth(bview, tclass.defaultfont());
}
}
return x;
int LyXText::rightMargin(Buffer const * buf, Row const * row) const
{
- LyXLayout const & layout =
- textclasslist.Style(buf->params.textclass,
- row->par()->getLayout());
-
+ LyXTextClass const & tclass =
+ textclasslist.TextClass(buf->params.textclass);
+ LyXLayout const & layout = tclass[row->par()->getLayout()];
+
int x = LYX_PAPER_MARGIN
- + lyxfont::signedWidth(textclasslist
- .TextClass(buf->params.textclass)
- .rightmargin(),
- textclasslist
- .TextClass(buf->params.textclass)
- .defaultfont());
+ + lyxfont::signedWidth(tclass.rightmargin(),
+ tclass.defaultfont());
// this is the way, LyX handles the LaTeX-Environments.
// I have had this idea very late, so it seems to be a
// check wether it is a sufficent paragraph
if (newpar
- && textclasslist.Style(buf->params.textclass,
- newpar->getLayout())
- .isEnvironment()) {
+ && tclass[newpar->getLayout()].isEnvironment()) {
Row dummyrow;
dummyrow.par(newpar);
dummyrow.pos(0);
}
//lyxerr << "rightmargin: " << layout->rightmargin << endl;
- x += lyxfont::signedWidth(layout.rightmargin, textclasslist
- .TextClass(buf->params.textclass)
- .defaultfont()) * 4 / (row->par()->getDepth()
- + 4);
+ x += lyxfont::signedWidth(layout.rightmargin, tclass.defaultfont())
+ * 4 / (row->par()->getDepth() + 4);
return x;
}
Paragraph::size_type const main_body =
beginningOfMainBody(bview->buffer(), par);
LyXLayout const & layout =
- textclasslist.Style(bview->buffer()->params.textclass, par->getLayout());
+ textclasslist.Style(bview->buffer()->params.textclass,
+ par->getLayout());
Paragraph::size_type i = pos;
if (layout.margintype == MARGIN_RIGHT_ADDRESS_BOX) {
// special handling of the right address boxes
if (textclasslist.Style(bview->buffer()->params.textclass,
row->par()->getLayout()).margintype
- == MARGIN_RIGHT_ADDRESS_BOX) {
+ == MARGIN_RIGHT_ADDRESS_BOX)
+ {
int const tmpfill = row->fill();
row->fill(0); // the minfill in MarginLeft()
w = leftMargin(bview, row);
--last;
int w = 0;
- int i = row->pos();
+ Paragraph::size_type i = row->pos();
while (i <= last) {
w += singleWidth(bview, row->par(), i);
++i;
first = max(first, beginningOfMainBody(buf, row->par()));
int n = 0;
- for (int p = first; p <= last; ++p) { // last, because the end is ignored!
+ for (Paragraph::size_type p = first; p <= last; ++p) {
+ // last, because the end is ignored!
if (row->par()->isHfill(p)) {
++n;
}
int maxdesc = int(lyxfont::maxDescent(font) *
layout.spacing.getValue() *
spacing_val);
- int const pos_end = rowLast(row_ptr);
+ Paragraph::size_type const pos_end = rowLast(row_ptr);
int labeladdon = 0;
int maxwidth = 0;
// Check if any insets are larger
- for (int pos = row_ptr->pos(); pos <= pos_end; ++pos) {
+ for (Paragraph::size_type pos = row_ptr->pos(); pos <= pos_end; ++pos) {
if (row_ptr->par()->getChar(pos) == Paragraph::META_INSET) {
tmpfont = getFont(bview->buffer(), row_ptr->par(), pos);
tmpinset = row_ptr->par()->getInset(pos);
row_ptr->baseline(maxasc + labeladdon);
height += row_ptr->height();
- float x;
- float dummy;
- prepareToPrint(bview, row_ptr, x, dummy, dummy, dummy, false);
+ float x = 0;
+ if (layout.margintype != MARGIN_RIGHT_ADDRESS_BOX) {
+ float dummy;
+ prepareToPrint(bview, row_ptr, x, dummy, dummy, dummy, false);
+ }
row_ptr->width(int(maxwidth + x));
if (inset_owner) {
Row * r = firstrow;
// The last character position of a paragraph is an invariant so we can
// safely get it here. (Asger)
- int const lastposition = row->par()->size();
+ Paragraph::size_type const lastposition = row->par()->size();
do {
// Get the next breakpoint
- int z = nextBreakPoint(bview, row, workWidth(bview));
+ Paragraph::size_type z = nextBreakPoint(bview, row, workWidth(bview));
Row * tmprow = row;
// This function is only used by the spellchecker for NextWord().
// It doesn't handle LYX_ACCENTs and probably never will.
-string const LyXText::selectNextWord(BufferView * bview,
- float & value) const
+string const LyXText::selectNextWordToSpellcheck(BufferView * bview,
+ float & value) const
{
if (the_locking_inset) {
- string str = the_locking_inset->selectNextWord(bview, value);
+ string str = the_locking_inset->selectNextWordToSpellcheck(bview, value);
if (!str.empty()) {
value += float(cursor.y())/float(height);
return str;
}
#warning Dekel please have a look on this one RTL? (Jug)
+#warning DEKEL!
// we have to go on checking so move cusor to the right
if (cursor.pos() == cursor.par()->size()) {
if (!cursor.par()->next())
while ((cursor.par()->size() > cursor.pos()
&& (!cursor.par()->isLetter(cursor.pos()))
&& (!cursor.par()->isInset(cursor.pos()) ||
- !cursor.par()->getInset(cursor.pos())->isTextInset()))
+ !cursor.par()->getInset(cursor.pos())->allowSpellcheck()))
|| (cursor.par()->size() == cursor.pos()
&& cursor.par()->next()))
- {
+ {
if (cursor.pos() == cursor.par()->size()) {
cursor.par(cursor.par()->next());
cursor.pos(0);
// now check if we hit an inset so it has to be a inset containing text!
if (cursor.pos() < cursor.par()->size() &&
- cursor.par()->isInset(cursor.pos()))
+ cursor.par()->isInset(cursor.pos()))
{
// lock the inset!
cursor.par()->getInset(cursor.pos())->edit(bview);
// now call us again to do the above trick
// but obviously we have to start from down below ;)
- return bview->text->selectNextWord(bview, value);
+ return bview->text->selectNextWordToSpellcheck(bview, value);
}
// Update the value if we changed paragraphs
if (!IsInsetChar(c) && !IsHfillChar(c)) {
switch (action) {
case text_lowercase:
- c = tolower(c);
+ c = lowercase(c);
break;
case text_capitalization:
- c = toupper(c);
+ c = uppercase(c);
action = text_lowercase;
break;
case text_uppercase:
- c = toupper(c);
+ c = uppercase(c);
break;
}
}
/* returns the column near the specified x-coordinate of the row
* x is set to the real beginning of this column */
-int LyXText::getColumnNearX(BufferView * bview, Row * row, int & x,
- bool & boundary) const
+Paragraph::size_type
+LyXText::getColumnNearX(BufferView * bview, Row * row, int & x,
+ bool & boundary) const
{
float tmpx = 0.0;
float fill_separator;
projects / lyx.git / blobdiff