#include <cctype>
#include <algorithm>
-#ifdef __GNUG__
-#pragma implementation "table.h"
-#endif
-
#include "layout.h"
#include "lyxparagraph.h"
#include "lyxtext.h"
#include "tracer.h"
#include "font.h"
#include "encoding.h"
+#include "lyxscreen.h"
using std::max;
using std::min;
using std::pair;
static const int LYX_PAPER_MARGIN = 20;
+
extern int bibitemMaxWidth(BufferView *, LyXFont const &);
break;
}
- if (Encoding::is_arabic(next_char))
+ if (Encoding::is_arabic(next_char)) {
if (Encoding::is_arabic(prev_char))
return Encoding::TransformChar(c, Encoding::FORM_MEDIAL);
else
return Encoding::TransformChar(c, Encoding::FORM_INITIAL);
- else
+ } else {
if (Encoding::is_arabic(prev_char))
return Encoding::TransformChar(c, Encoding::FORM_FINAL);
else
return Encoding::TransformChar(c, Encoding::FORM_ISOLATED);
+ }
}
// This is the comments that some of the warnings below refers to.
int LyXText::SingleWidth(BufferView * bview, LyXParagraph * par,
LyXParagraph::size_type pos) const
{
- char c = par->GetChar(pos);
+ char const c = par->GetChar(pos);
return SingleWidth(bview, par, pos, c);
}
LyXParagraph::size_type pos =
(is_space && lpos + 1 <= bidi_end &&
!row->par()->IsLineSeparator(lpos + 1) &&
- (!row->par()->table
- || !row->par()->IsNewline(lpos + 1)) )
+ !row->par()->IsNewline(lpos + 1))
? lpos + 1 : lpos;
LyXFont font = row->par()->GetFontSettings(buf->params, pos);
bool new_rtl = font.isVisibleRightToLeft();
bool new_rtl0 = font.isRightToLeft();
int new_level;
-#ifndef NEW_TABULAR
- if (row->par()->table && row->par()->IsNewline(lpos)) {
- new_level = 0;
- new_rtl = new_rtl0 = false;
- } else
-#endif
- if (lpos == main_body - 1
- && row->pos() < main_body - 1
- && row->par()->IsLineSeparator(lpos)) {
+ if (lpos == main_body - 1
+ && row->pos() < main_body - 1
+ && row->par()->IsLineSeparator(lpos)) {
new_level = (rtl_par) ? 1 : 0;
new_rtl = new_rtl0 = rtl_par;
} else if (new_rtl0)
}
LyXParagraph::size_type vpos = bidi_start - 1;
- for (LyXParagraph::size_type lpos = bidi_start; lpos <= bidi_end; ++lpos) {
+ for (LyXParagraph::size_type lpos = bidi_start;
+ lpos <= bidi_end; ++lpos) {
vpos += log2vis_list[lpos - bidi_start];
vis2log_list[vpos - bidi_start] = lpos;
log2vis_list[lpos - bidi_start] = vpos;
if (!lyxrc.rtl_support)
return false; // This is just for speedup
- if (!bidi_InRange(pos - 1) ||
- (par->table && par->IsNewline(pos-1)) )
+ if (!bidi_InRange(pos - 1))
return false;
- bool rtl = bidi_level(pos - 1) % 2;
+ bool const rtl = bidi_level(pos - 1) % 2;
bool rtl2 = rtl;
- if (pos == par->Last() ||
- (par->table && par->IsNewline(pos)))
+ if (pos == par->Last())
rtl2 = par->isRightToLeftPar(buf->params);
else if (bidi_InRange(pos))
rtl2 = bidi_level(pos) % 2;
if (!lyxrc.rtl_support)
return false; // This is just for speedup
- bool rtl = font.isVisibleRightToLeft();
+ bool const rtl = font.isVisibleRightToLeft();
bool rtl2 = rtl;
- if (pos == par->Last() ||
- (par->table && par->IsNewline(pos)))
+ if (pos == par->Last())
rtl2 = par->isRightToLeftPar(buf->params);
else if (bidi_InRange(pos))
rtl2 = bidi_level(pos) % 2;
// tmpinset->update(bview, font, false);
tmpinset->draw(bview, font, offset+row->baseline(), x,
cleared);
- if (status == CHANGED_IN_DRAW)
+ if (status == CHANGED_IN_DRAW) {
UpdateInset(bview, tmpinset);
+ status = CHANGED_IN_DRAW;
+ }
}
++vpos;
string parindent = layout.parindent;
-#ifndef NEW_TABULAR
- /* table stuff -- begin */
- if (row->par()->table)
- parindent.erase();
- /* table stuff -- end */
-#endif
int x = LYX_PAPER_MARGIN;
x += lyxfont::signedWidth(textclasslist
if (!row->par()->GetDepth()) {
if (!row->par()->GetLayout()) {
// find the previous same level paragraph
+#ifndef NEW_INSETS
if (row->par()->FirstPhysicalPar()->Previous()) {
+#else
+ if (row->par()->Previous()) {
+#endif
LyXParagraph * newpar = row->par()
->DepthHook(row->par()->GetDepth());
if (newpar &&
// make a corresponding row. Needed to call LeftMargin()
// check wether it is a sufficent paragraph
- if (newpar && newpar->footnoteflag == row->par()->footnoteflag
+ if (newpar
+#ifndef NEW_INSETS
+ && newpar->footnoteflag == row->par()->footnoteflag
+#endif
&& textclasslist
.Style(bview->buffer()->params.textclass,
newpar->GetLayout()).isEnvironment()) {
// is used to clear impossible depths after changing
// a layout. Since there is always a redo,
// LeftMargin() is always called
+#ifndef NEW_INSETS
row->par()->FirstPhysicalPar()->depth = 0;
+#else
+ row->par()->depth = 0;
+#endif
}
if (newpar && !row->par()->GetLayout()) {
+#ifndef NEW_INSETS
if (newpar->FirstPhysicalPar()->noindent)
+#else
+ if (newpar->noindent)
+#endif
parindent.erase();
else
parindent = textclasslist
}
- LyXFont labelfont = GetFont(bview->buffer(), row->par(), -2);
+ LyXFont const labelfont = GetFont(bview->buffer(), row->par(), -2);
switch (layout.margintype) {
case MARGIN_DYNAMIC:
if (!layout.leftmargin.empty()) {
break;
}
if ((workWidth(bview) > 0) &&
- (row->par()->pextra_type == LyXParagraph::PEXTRA_INDENT))
- {
+ (row->par()->pextra_type == LyXParagraph::PEXTRA_INDENT)) {
if (!row->par()->pextra_widthp.empty()) {
x += workWidth(bview) *
- atoi(row->par()->pextra_widthp.c_str()) / 100;
+ lyx::atoi(row->par()->pextra_widthp) / 100;
} else if (!row->par()->pextra_width.empty()) {
int xx = VSpace(row->par()->pextra_width).inPixels(bview);
if (xx > workWidth(bview))
}
int align; // wrong type
+#ifndef NEW_INSETS
if (row->par()->FirstPhysicalPar()->align == LYX_ALIGN_LAYOUT)
align = layout.align;
else
align = row->par()->FirstPhysicalPar()->align;
-
+#else
+ if (row->par()->align == LYX_ALIGN_LAYOUT)
+ align = layout.align;
+ else
+ align = row->par()->align;
+#endif
// set the correct parindent
if (row->pos() == 0) {
if ((layout.labeltype == LABEL_NO_LABEL
|| (layout.labeltype == LABEL_STATIC
&& layout.latextype == LATEX_ENVIRONMENT
&& ! row->par()->IsFirstInSequence()))
+#ifndef NEW_INSETS
&& row->par() == row->par()->FirstPhysicalPar()
+#endif
&& align == LYX_ALIGN_BLOCK
&& !row->par()->noindent
&& (row->par()->layout ||
LyXParagraph * newpar = row->par();
+#ifndef NEW_INSETS
do {
newpar = newpar->FirstPhysicalPar()->Previous();
if (newpar)
newpar = newpar->FirstPhysicalPar();
} while (newpar && newpar->GetDepth() >= row->par()->GetDepth()
&& newpar->footnoteflag == row->par()->footnoteflag);
+#else
+ do {
+ newpar = newpar->Previous();
+ } while (newpar
+ && newpar->GetDepth() >= row->par()->GetDepth());
+#endif
// make a corresponding row. Needed to call LeftMargin()
// check wether it is a sufficent paragraph
- if (newpar && newpar->footnoteflag == row->par()->footnoteflag
+ if (newpar
+#ifndef NEW_INSETS
+ && newpar->footnoteflag == row->par()->footnoteflag
+#endif
&& textclasslist.Style(buf->params.textclass,
newpar->GetLayout())
.isEnvironment()) {
// is used to clear impossible depths after changing
// a layout. Since there is always a redo,
// LeftMargin() is always called
+#ifndef NEW_INSETS
row->par()->FirstPhysicalPar()->depth = 0;
+#else
+ row->par()->depth = 0;
+#endif
}
}
}
-#ifndef NEW_TABULAR
-/* table stuff -- begin*/
-int LyXText::NumberOfCell(LyXParagraph * par,
- LyXParagraph::size_type pos) const
-{
- int cell = 0;
- LyXParagraph::size_type tmp_pos = 0;
- while (tmp_pos < pos) {
- if (par->IsNewline(tmp_pos))
- ++cell;
- ++tmp_pos;
- }
- return cell;
-}
-
-
-int LyXText::WidthOfCell(BufferView * bview, LyXParagraph * par,
- LyXParagraph::size_type & pos) const
-{
- int w = 0;
- while (pos < par->Last() && !par->IsNewline(pos)) {
- w += SingleWidth(bview, par, pos);
- ++pos;
- }
- if (par->IsNewline(pos))
- ++pos;
- return w;
-}
-
-
-bool LyXText::HitInTable(BufferView * bview, Row * row, int x) const
-{
- float tmpx;
- float fill_separator, fill_hfill, fill_label_hfill;
- if (!row->par()->table)
- return false;
- PrepareToPrint(bview, row, tmpx, fill_separator,
- fill_hfill, fill_label_hfill, false);
- return (x > tmpx && x < tmpx + row->par()->table->WidthOfTable());
-}
-
-
-bool LyXText::MouseHitInTable(BufferView * bview, int x, long y) const
-{
- Row * row = GetRowNearY(y);
- return HitInTable(bview, row, x);
-}
-
-
-/* table stuff -- end*/
-#endif
-
-
// get the next breakpoint in a given paragraph
LyXParagraph::size_type
LyXText::NextBreakPoint(BufferView * bview, Row const * row, int width) const
if (width < 0)
return par->Last();
-#ifndef NEW_TABULAR
- /* table stuff -- begin*/
- if (par->table) {
- while (pos < par->size()
- && (!par->IsNewline(pos)
- || !par->table->IsFirstCell(NumberOfCell(par, pos + 1)))) {
- if (par->GetChar(pos) == LyXParagraph::META_INSET &&
- par->GetInset(pos) && par->GetInset(pos)->display()){
- par->GetInset(pos)->display(false);
- }
- ++pos;
- }
- return pos;
- }
- /* table stuff -- end*/
-#endif
+
// position of the last possible breakpoint
// -1 isn't a suitable value, but a flag
LyXParagraph::size_type last_separator = -1;
if (paper_width < 0)
return 0;
- int w, fill;
+ int w;
// get the pure distance
LyXParagraph::size_type last = RowLastPrintable(row);
-#ifndef NEW_TABULAR
- /* table stuff -- begin */
- if (row->par()->table) {
- // for tables FILL does calculate the widthes of each cell in
- // the row
- LyXParagraph::size_type pos = row->pos();
- int cell = NumberOfCell(row->par(), pos);
- w = 0;
- do {
- row->par()->table->SetWidthOfCell(cell,
- WidthOfCell(bview,
- row->par(),
- pos));
- ++cell;
- } while (pos <= last && !row->par()->table->IsFirstCell(cell));
- // don't forget the very last table cell without characters
- if (cell == row->par()->table->GetNumberOfCells() - 1)
- row->par()->table->SetWidthOfCell(cell,
- WidthOfCell(bview,
- row->par(),
- pos));
-
- return 0; /* width of table cannot be returned since
- * we cannot guarantee its correct value at
- * this point. */
- }
- /* table stuff -- end*/
-#endif
// special handling of the right address boxes
if (textclasslist.Style(bview->buffer()->params.textclass,
w = left_margin;
}
- fill = paper_width - w - RightMargin(bview->buffer(), row);
+ int const fill = paper_width - w - RightMargin(bview->buffer(), row);
return fill;
}
// returns the minimum space a manual label needs on the screen in pixel
int LyXText::LabelFill(BufferView * bview, Row const * row) const
{
- LyXParagraph::size_type last = BeginningOfMainBody(bview->buffer(), row->par())-1;
+ LyXParagraph::size_type last = BeginningOfMainBody(bview->buffer(), row->par()) - 1;
// -1 because a label ends either with a space that is in the label,
// or with the beginning of a footnote that is outside the label.
// on the very last column doesnt count
int LyXText::NumberOfSeparators(Buffer const * buf, Row const * row) const
{
- int last = RowLast(row);
- int p = max(row->pos(), BeginningOfMainBody(buf, row->par()));
+ LyXParagraph::size_type const last = RowLast(row);
+ LyXParagraph::size_type p =
+ max(row->pos(), BeginningOfMainBody(buf, row->par()));
int n = 0;
for (; p < last; ++p) {
if (row->par()->IsSeparator(p)) {
// ignored. This is *MUCH* more usefull than not to ignore!
int LyXText::NumberOfHfills(Buffer const * buf, Row const * row) const
{
- int last = RowLast(row);
- int first = row->pos();
+ LyXParagraph::size_type const last = RowLast(row);
+ LyXParagraph::size_type first = row->pos();
if (first) { /* hfill *DO* count at the beginning
* of paragraphs! */
while(first <= last && row->par()->IsHfill(first))
void LyXText::SetHeightOfRow(BufferView * bview, Row * row_ptr) const
{
/* get the maximum ascent and the maximum descent */
- int asc = 0, desc = 0, pos = 0;
+ int asc = 0;
+ int desc = 0;
float layoutasc = 0;
float layoutdesc = 0;
float tmptop = 0;
/* this must not happen before the currentrow for clear reasons.
so the trick is just to set the current row onto this row */
- long unused_y;
+ int unused_y;
GetRow(row_ptr->par(), row_ptr->pos(), unused_y);
/* ok , let us initialize the maxasc and maxdesc value.
/* Correction: only the fontsize count. The other properties
are taken from the layoutfont. Nicer on the screen :) */
-
+#ifndef NEW_INSETS
LyXParagraph * par = row_ptr->par()->LastPhysicalPar();
LyXParagraph * firstpar = row_ptr->par()->FirstPhysicalPar();
+#else
+ LyXParagraph * par = row_ptr->par();
+ LyXParagraph * firstpar = row_ptr->par();
+#endif
LyXLayout const & layout = textclasslist.Style(bview->buffer()->params.textclass,
firstpar->GetLayout());
int maxwidth = 0;
// Check if any insets are larger
- for (pos = row_ptr->pos(); pos <= pos_end; ++pos) {
+ for (int pos = row_ptr->pos(); pos <= pos_end; ++pos) {
if (row_ptr->par()->GetChar(pos) == LyXParagraph::META_INSET) {
tmpfont = GetFont(bview->buffer(), row_ptr->par(), pos);
tmpinset = row_ptr->par()->GetInset(pos);
maxdesc = desc;
}
-#ifndef NEW_TABULAR
- /* table stuff -- begin*/
- if (row_ptr->par()->table){
- // stretch the rows a bit
- maxasc += 1;
- maxdesc += 1;
- }
- /* table stuff -- end*/
-#endif
-
// This is nicer with box insets:
++maxasc;
++maxdesc;
}
/* is it a bottom line? */
- if (row_ptr->par()->ParFromPos(RowLast(row_ptr) + 1) == par
+ if (
+#ifndef NEW_INSETS
+ row_ptr->par()->ParFromPos(RowLast(row_ptr) + 1) == par
+#else
+ row_ptr->par() == par
+#endif
&& (!row_ptr->next() || row_ptr->next()->par() != row_ptr->par())) {
/* the paper margins */
LyXParagraph * nextpar = row_ptr->par()->Next();
LyXParagraph * comparepar = row_ptr->par();
float usual = 0;
- float unusual = 0;
+ float unusual = 0;
if (comparepar->GetDepth() > nextpar->GetDepth()) {
usual = (textclasslist.Style(bview->buffer()->params.textclass, comparepar->GetLayout()).bottomsep * DefaultHeight());
maxasc += int(layoutasc * 2 / (2 + firstpar->GetDepth()));
maxdesc += int(layoutdesc * 2 / (2 + firstpar->GetDepth()));
-#ifndef NEW_TABULAR
- /* table stuff -- begin*/
- if (row_ptr->par()->table){
- maxasc += row_ptr->par()->table->
- AdditionalHeight(NumberOfCell(row_ptr->par(), row_ptr->pos()));
- }
- /* table stuff -- end*/
-#endif
/* calculate the new height of the text */
height -= row_ptr->height();
height += row_ptr->height();
float x, dummy;
- PrepareToPrint(bview, row_ptr, x, dummy, dummy, dummy);
- row_ptr->width(maxwidth+x);
+ PrepareToPrint(bview, row_ptr, x, dummy, dummy, dummy, false);
+ row_ptr->width(int(maxwidth + x));
if (inset_owner) {
Row * r = firstrow;
width = max(0,workWidth(bview));
// The last character position of a paragraph is an invariant so we can
// safely get it here. (Asger)
- int lastposition = row->par()->Last();
+ int const lastposition = row->par()->Last();
do {
// Get the next breakpoint
void LyXText::BreakParagraph(BufferView * bview, char keep_layout)
{
- LyXLayout const & layout = textclasslist.Style(bview->buffer()->params.textclass,
- cursor.par()->GetLayout());
-#ifndef NEW_TABULAR
- /* table stuff -- begin */
- if (cursor.par()->table) {
- // breaking of tables is only allowed at the beginning or the end */
- if (cursor.pos() && cursor.pos() < cursor.par()->size() &&
- !cursor.par()->table->ShouldBeVeryLastCell(NumberOfCell(cursor.par(), cursor.pos())))
- return; // no breaking of tables allowed
- }
- /* table stuff -- end */
-#endif
+ LyXLayout const & layout =
+ textclasslist.Style(bview->buffer()->params.textclass,
+ cursor.par()->GetLayout());
+
// this is only allowed, if the current paragraph is not empty or caption
- if ((cursor.par()->Last() <= 0 && !cursor.par()->IsDummy())
+ if ((cursor.par()->Last() <= 0
+#ifndef NEW_INSETS
+ && !cursor.par()->IsDummy()
+#endif
+ )
&&
layout.labeltype!= LABEL_SENSITIVE)
return;
- SetUndo(bview->buffer(), Undo::INSERT,
+ SetUndo(bview->buffer(), Undo::INSERT,
+#ifndef NEW_INSETS
cursor.par()->ParFromPos(cursor.pos())->previous,
- cursor.par()->ParFromPos(cursor.pos())->next);
-
-#ifndef NEW_TABULAR
- /* table stuff -- begin */
- if (cursor.par()->table) {
- int cell = NumberOfCell(cursor.par(), cursor.pos());
- if (cursor.par()->table->ShouldBeVeryLastCell(cell))
- SetCursor(bview, cursor.par(), cursor.par()->size());
- }
- /* table stuff -- end */
+ cursor.par()->ParFromPos(cursor.pos())->next
+#else
+ cursor.par()->previous,
+ cursor.par()->next
#endif
+ );
+
// please break always behind a space
if (cursor.pos() < cursor.par()->Last()
&& cursor.par()->IsLineSeparator(cursor.pos()))
keep_layout = layout.isEnvironment();
cursor.par()->BreakParagraph(bview->buffer()->params, cursor.pos(),
keep_layout);
-#ifndef NEW_TABULAR
- /* table stuff -- begin */
- if (cursor.par()->table){
- // the table should stay with the contents
- if (!cursor.pos()){
- cursor.par()->Next()->table = cursor.par()->table;
- cursor.par()->table = 0;
- }
- }
- /* table stuff -- end */
-#endif
+
// well this is the caption hack since one caption is really enough
if (layout.labeltype == LABEL_SENSITIVE) {
if (!cursor.pos())
SetHeightOfRow(bview, cursor.row());
- while (!cursor.par()->Next()->table && cursor.par()->Next()->Last()
+ while (cursor.par()->Next()->Last()
&& cursor.par()->Next()->IsNewline(0))
cursor.par()->Next()->Erase(0);
#endif
-#ifndef NEW_TABULAR
-/* table stuff -- begin*/
-
-void LyXText::TableFeatures(BufferView * bview, int feature, string const & val) const
-{
- if (!cursor.par()->table)
- return; /* this should never happen */
-
- int actCell = NumberOfCell(cursor.par(), cursor.pos());
- SetUndo(bview->buffer(), Undo::FINISH,
- cursor.par()->ParFromPos(cursor.pos())->previous,
- cursor.par()->ParFromPos(cursor.pos())->next);
-
- switch (feature){
- case LyXTable::SET_PWIDTH:
- cursor.par()->table->SetPWidth(actCell, val);
- break;
- case LyXTable::SET_SPECIAL_COLUMN:
- case LyXTable::SET_SPECIAL_MULTI:
- cursor.par()->table->SetAlignSpecial(actCell, val, feature);
- break;
- default:
- break;
- }
- RedoParagraph(bview);
-}
-
-
-void LyXText::TableFeatures(BufferView * bview, int feature) const
-{
- int setLines = 0;
- int setAlign = LYX_ALIGN_LEFT;
- int lineSet;
- bool what;
-
- if (!cursor.par()->table)
- return; /* this should never happen */
-
- int actCell = NumberOfCell(cursor.par(), cursor.pos());
- SetUndo(bview->buffer(), Undo::FINISH,
- cursor.par()->ParFromPos(cursor.pos())->previous,
- cursor.par()->ParFromPos(cursor.pos())->next);
-
- switch (feature){
- case LyXTable::ALIGN_LEFT:
- setAlign= LYX_ALIGN_LEFT;
- break;
- case LyXTable::ALIGN_RIGHT:
- setAlign= LYX_ALIGN_RIGHT;
- break;
- case LyXTable::ALIGN_CENTER:
- setAlign= LYX_ALIGN_CENTER;
- break;
- default:
- break;
- }
- switch (feature){
- case LyXTable::APPEND_ROW: {
- LyXParagraph::size_type pos = cursor.pos();
-
- /* move to the next row */
- int cell_org = actCell;
- int cell = cell_org;
-
- // if there is a ContRow following this row I have to add
- // the row after the ContRow's
- if ((pos < cursor.par()->Last()) &&
- cursor.par()->table->RowHasContRow(cell_org)) {
- while((pos < cursor.par()->Last()) &&
- !cursor.par()->table->IsContRow(cell)) {
- while (pos < cursor.par()->Last() &&
- !cursor.par()->IsNewline(pos))
- ++pos;
- if (pos < cursor.par()->Last())
- ++pos;
- ++cell;
- }
- while((pos < cursor.par()->Last()) &&
- cursor.par()->table->IsContRow(cell)) {
- while (pos < cursor.par()->Last() &&
- !cursor.par()->IsNewline(pos))
- ++pos;
- if (pos < cursor.par()->Last())
- ++pos;
- ++cell;
- }
- cell_org = --cell;
- if (pos < cursor.par()->Last())
- --pos;
- }
- while (pos < cursor.par()->Last() &&
- (cell == cell_org || !cursor.par()->table->IsFirstCell(cell))){
- while (pos < cursor.par()->Last() && !cursor.par()->IsNewline(pos))
- ++pos;
- if (pos < cursor.par()->Last())
- ++pos;
- ++cell;
- }
-
- /* insert the new cells */
- int number = cursor.par()->table->NumberOfCellsInRow(cell_org);
- Language const * lang = cursor.par()->getParLanguage(bview->buffer()->params);
- LyXFont font(LyXFont::ALL_INHERIT,lang);
- for (int i = 0; i < number; ++i) {
- cursor.par()->InsertChar(pos, LyXParagraph::META_NEWLINE, font);
- }
-
- /* append the row into the table */
- cursor.par()->table->AppendRow(cell_org);
- RedoParagraph(bview);
- return;
- }
- case LyXTable::APPEND_CONT_ROW: {
- LyXParagraph::size_type pos = cursor.pos();
- /* move to the next row */
- int cell_org = actCell;
- int cell = cell_org;
-
- // if there is already a controw but not for this cell
- // the AppendContRow sets only the right values but does
- // not actually add a row
- if (cursor.par()->table->RowHasContRow(cell_org) &&
- (cursor.par()->table->CellHasContRow(cell_org)<0)) {
- cursor.par()->table->AppendContRow(cell_org);
- RedoParagraph(bview);
- return;
- }
- while (pos < cursor.par()->Last() &&
- (cell == cell_org
- || !cursor.par()->table->IsFirstCell(cell))){
- while (pos < cursor.par()->Last() && !cursor.par()->IsNewline(pos))
- ++pos;
- if (pos < cursor.par()->Last())
- ++pos;
- ++cell;
- }
-
- /* insert the new cells */
- int number = cursor.par()->table->NumberOfCellsInRow(cell_org);
- Language const * lang = cursor.par()->getParLanguage(bview->buffer()->params);
- LyXFont font(LyXFont::ALL_INHERIT,lang);
- for (int i = 0; i < number; ++i) {
- cursor.par()->InsertChar(pos, LyXParagraph::META_NEWLINE, font);
- }
-
- /* append the row into the table */
- cursor.par()->table->AppendContRow(cell_org);
- RedoParagraph(bview);
- return;
- }
- case LyXTable::APPEND_COLUMN: {
- LyXParagraph::size_type pos = 0;
- int cell_org = actCell;
- int cell = 0;
- Language const * lang = cursor.par()->getParLanguage(bview->buffer()->params);
- LyXFont font(LyXFont::ALL_INHERIT,lang);
- do{
- if (pos && (cursor.par()->IsNewline(pos-1))){
- if (cursor.par()->table->AppendCellAfterCell(cell_org, cell)) {
- cursor.par()->InsertChar(pos,
- LyXParagraph::META_NEWLINE,
- font);
- if (pos <= cursor.pos())
- cursor.pos(cursor.pos() + 1);
- ++pos;
- }
- ++cell;
- }
- ++pos;
- } while (pos <= cursor.par()->Last());
- /* remember that the very last cell doesn't end with a newline.
- This saves one byte memory per table ;-) */
- if (cursor.par()->table->AppendCellAfterCell(cell_org, cell)) {
- LyXParagraph::size_type last = cursor.par()->Last();
- cursor.par()->InsertChar(last,
- LyXParagraph::META_NEWLINE, font);
- }
-
- /* append the column into the table */
- cursor.par()->table->AppendColumn(cell_org);
-
- RedoParagraph(bview);
- return;
- }
- case LyXTable::DELETE_ROW:
- if (bview->the_locking_inset)
- bview->unlockInset(bview->the_locking_inset);
- RemoveTableRow(cursor);
- RedoParagraph(bview);
- return;
-
- case LyXTable::DELETE_COLUMN: {
- LyXParagraph::size_type pos = 0;
- int cell_org = actCell;
- int cell = 0;
- if (bview->the_locking_inset)
- bview->unlockInset(bview->the_locking_inset);
- do {
- if (!pos || (cursor.par()->IsNewline(pos-1))){
- if (cursor.par()->table->DeleteCellIfColumnIsDeleted(cell, cell_org)){
- // delete one cell
- while (pos < cursor.par()->Last() && !cursor.par()->IsNewline(pos))
- cursor.par()->Erase(pos);
- if (pos < cursor.par()->Last())
- cursor.par()->Erase(pos);
- else
- cursor.par()->Erase(pos - 1); // the missing newline at the end of a table
- --pos; // because of pos++ below
- }
- ++cell;
- }
- ++pos;
- } while (pos <= cursor.par()->Last());
-
- /* delete the column from the table */
- cursor.par()->table->DeleteColumn(cell_org);
-
- /* set the cursor to the beginning of the table, where else? */
- cursor.pos(0);
- RedoParagraph(bview);
- return;
- }
- case LyXTable::TOGGLE_LINE_TOP:
- lineSet = !cursor.par()->table->TopLine(actCell);
- if (!selection){
- cursor.par()->table->SetTopLine(actCell, lineSet);
- } else {
- LyXParagraph::size_type i;
- int n = -1, m = -2;
- for (i = sel_start_cursor.pos(); i <= sel_end_cursor.pos(); ++i){
- if ((n = NumberOfCell(sel_start_cursor.par(), i)) != m) {
- cursor.par()->table->SetTopLine(n, lineSet);
- m = n;
- }
- }
- }
- RedoParagraph(bview);
- return;
-
- case LyXTable::TOGGLE_LINE_BOTTOM:
- lineSet = !cursor.par()->table->BottomLine(actCell);
- if (!selection){
- cursor.par()->table->SetBottomLine(actCell, lineSet);
- } else {
- LyXParagraph::size_type i;
- int n = -1, m = -2;
- for (i = sel_start_cursor.pos(); i <= sel_end_cursor.pos(); ++i) {
- if ((n = NumberOfCell(sel_start_cursor.par(), i)) != m) {
- cursor.par()->table->SetBottomLine(n, lineSet);
- m = n;
- }
- }
- }
- RedoParagraph(bview);
- return;
-
- case LyXTable::TOGGLE_LINE_LEFT:
- lineSet = !cursor.par()->table->LeftLine(actCell);
- if (!selection){
- cursor.par()->table->SetLeftLine(actCell, lineSet);
- } else {
- LyXParagraph::size_type i;
- int n = -1, m = -2;
- for (i = sel_start_cursor.pos(); i <= sel_end_cursor.pos(); ++i){
- if ((n= NumberOfCell(sel_start_cursor.par(), i)) != m) {
- cursor.par()->table->SetLeftLine(n, lineSet);
- m = n;
- }
- }
- }
- RedoParagraph(bview);
- return;
-
- case LyXTable::TOGGLE_LINE_RIGHT:
- lineSet = !cursor.par()->table->RightLine(actCell);
- if (!selection){
- cursor.par()->table->SetRightLine(actCell, lineSet);
- } else {
- int n = -1, m = -2;
- LyXParagraph::size_type i = sel_start_cursor.pos();
- for (; i <= sel_end_cursor.pos(); ++i) {
- if ((n= NumberOfCell(sel_start_cursor.par(), i)) != m) {
- cursor.par()->table->SetRightLine(n, lineSet);
- m = n;
- }
- }
- }
- RedoParagraph(bview);
- return;
-
- case LyXTable::ALIGN_LEFT:
- case LyXTable::ALIGN_RIGHT:
- case LyXTable::ALIGN_CENTER:
- if (!selection){
- cursor.par()->table->SetAlignment(actCell, setAlign);
- } else {
- int n = -1, m = -2;
- LyXParagraph::size_type i = sel_start_cursor.pos();
- for (; i <= sel_end_cursor.pos(); ++i) {
- if ((n= NumberOfCell(sel_start_cursor.par(), i)) != m) {
- cursor.par()->table->SetAlignment(n, setAlign);
- m = n;
- }
- }
- }
- RedoParagraph(bview);
- return;
-
- case LyXTable::DELETE_TABLE:
- SetCursorIntern(bview, cursor.par(), 0);
- delete cursor.par()->table;
- cursor.par()->table = 0;
- // temporary: Should put table in simple_cut_buffer (with before and after
- // dummy-paragraph !!
- // not necessar anymore with UNDO :)
- for (LyXParagraph::size_type i =
- cursor.par()->size() - 1; i >= 0; --i)
- cursor.par()->Erase(i);
- RedoParagraph(bview);
- return;
-
- case LyXTable::MULTICOLUMN: {
- int number = 0;
- // check wether we are completly in a multicol
- int multicol = cursor.par()->table->IsMultiColumn(actCell);
- if (multicol && selection && sel_start_cursor.row() == sel_end_cursor.row()) {
- multicol = NumberOfCell(sel_start_cursor.par(), sel_start_cursor.pos())
- == NumberOfCell(sel_end_cursor.par(), sel_end_cursor.pos());
- }
-
- if (multicol){
- int newlines = cursor.par()->table->UnsetMultiColumn(actCell);
- LyXParagraph::size_type pos = cursor.pos();
- while (pos < cursor.par()->Last() && !cursor.par()->IsNewline(pos))
- ++pos;
- for (; newlines; --newlines)
- cursor.par()->InsertChar(pos, LyXParagraph::META_NEWLINE);
- RedoParagraph(bview);
- return;
- }
- else {
- // selection must be in one row (or no selection)
- if (!selection){
- cursor.par()->table->SetMultiColumn(NumberOfCell(cursor.par(),
- cursor.pos()),
- 1);
- RedoParagraph(bview);
- return;
- }
- else {
- if (sel_start_cursor.row() == sel_end_cursor.row()){
- LyXParagraph::size_type i;
- number = 1;
- for (i = sel_start_cursor.pos();
- i < sel_end_cursor.pos(); ++i){
- if (sel_start_cursor.par()->IsNewline(i)){
- sel_start_cursor.par()->Erase(i);
- // check for double-blanks
- if ((i && !sel_start_cursor.par()->IsLineSeparator(i-1))
- &&
- (i < sel_start_cursor.par()->Last()
- && !sel_start_cursor.par()->IsLineSeparator(i)))
- sel_start_cursor.par()->InsertChar(i, ' ');
- else {
- sel_end_cursor.pos(sel_end_cursor.pos() - 1);
- --i;
- }
- ++number;
- }
- }
- cursor.par()->table->
- SetMultiColumn(NumberOfCell(sel_start_cursor.par(),
- sel_start_cursor.pos()),
- number);
- cursor.pos(sel_start_cursor.pos());
- RedoParagraph(bview);
- return;
- }
- else {
- WriteAlert(_("Impossible Operation!"),
- _("Multicolumns can only be horizontally."),
- _("Sorry."));
- }
- }
- }
- break;
- }
- case LyXTable::SET_ALL_LINES:
- setLines = 1;
- case LyXTable::UNSET_ALL_LINES:
- if (!selection){
- cursor.par()->table->SetAllLines(NumberOfCell(cursor.par(),
- cursor.pos()),
- setLines);
- } else {
- LyXParagraph::size_type i;
- int n = -1, m = -2;
- for (i = sel_start_cursor.pos(); i <= sel_end_cursor.pos(); ++i) {
- if ((n= NumberOfCell(sel_start_cursor.par(), i)) != m) {
- cursor.par()->table->SetAllLines(n, setLines);
- m = n;
- }
- }
- }
- RedoParagraph(bview);
- return;
- case LyXTable::SET_LONGTABLE:
- cursor.par()->table->SetLongTable(true);
- return;
- case LyXTable::UNSET_LONGTABLE:
- cursor.par()->table->SetLongTable(false);
- return;
- case LyXTable::SET_ROTATE_TABLE:
- cursor.par()->table->SetRotateTable(true);
- return;
- case LyXTable::UNSET_ROTATE_TABLE:
- cursor.par()->table->SetRotateTable(false);
- return;
- case LyXTable::SET_ROTATE_CELL:
- if (!selection){
- cursor.par()->table->SetRotateCell(actCell, true);
- } else {
- LyXParagraph::size_type i;
- int n = -1, m = -2;
- for (i = sel_start_cursor.pos(); i <= sel_end_cursor.pos(); ++i){
- if ((n = NumberOfCell(sel_start_cursor.par(), i)) != m) {
- cursor.par()->table->SetRotateCell(n, true);
- m = n;
- }
- }
- }
- return;
- case LyXTable::UNSET_ROTATE_CELL:
- if (!selection){
- cursor.par()->table->SetRotateCell(actCell, false);
- } else {
- int n = -1, m = -2;
- LyXParagraph::size_type i = sel_start_cursor.pos();
- for (; i <= sel_end_cursor.pos(); ++i) {
- if ((n= NumberOfCell(sel_start_cursor.par(), i)) != m) {
- cursor.par()->table->SetRotateCell(n, false);
- m = n;
- }
- }
- }
- return;
- case LyXTable::SET_LINEBREAKS:
- what = !cursor.par()->table->Linebreaks(cursor.par()->table->FirstVirtualCell(actCell));
- if (!selection){
- cursor.par()->table->SetLinebreaks(actCell, what);
- } else {
- LyXParagraph::size_type i;
- int n = -1, m = -2;
- for (i = sel_start_cursor.pos(); i <= sel_end_cursor.pos(); ++i) {
- if ((n = NumberOfCell(sel_start_cursor.par(), i)) != m) {
- cursor.par()->table->SetLinebreaks(n, what);
- m = n;
- }
- }
- }
- return;
- case LyXTable::SET_LTFIRSTHEAD:
- cursor.par()->table->SetLTHead(actCell, true);
- return;
- case LyXTable::SET_LTHEAD:
- cursor.par()->table->SetLTHead(actCell, false);
- return;
- case LyXTable::SET_LTFOOT:
- cursor.par()->table->SetLTFoot(actCell, false);
- return;
- case LyXTable::SET_LTLASTFOOT:
- cursor.par()->table->SetLTFoot(actCell, true);
- return;
- case LyXTable::SET_LTNEWPAGE:
- what = !cursor.par()->table->LTNewPage(actCell);
- cursor.par()->table->SetLTNewPage(actCell, what);
- return;
- }
-}
-
-
-void LyXText::InsertCharInTable(BufferView * bview, char c)
-{
- Row * row = 0;
- Row * tmprow = 0;
- long y;
- bool jumped_over_space;
-
- /* first check, if there will be two blanks together or a blank at
- * the beginning of a paragraph.
- * I decided to handle blanks like normal characters, the main
- * difference are the special checks when calculating the row.fill
- * (blank does not count at the end of a row) and the check here */
-
- LyXFont realtmpfont = real_current_font;
- LyXFont rawtmpfont = current_font; /* store the current font.
- * This is because of the use
- * of cursor movements. The moving
- * cursor would refresh the
- * current font */
-
- // Get the font that is used to calculate the baselineskip
- LyXParagraph::size_type const lastpos =
- cursor.par()->Last();
- LyXFont rawparfont = cursor.par()->GetFontSettings(bview->buffer()->params,
- lastpos - 1);
-
- jumped_over_space = false;
- if (IsLineSeparatorChar(c)) {
- if ((cursor.pos() > 0 &&
- cursor.par()->IsLineSeparator(cursor.pos() - 1))
- || (cursor.pos() > 0 && cursor.par()->IsNewline(cursor.pos() - 1))
- || (cursor.pos() == 0 &&
- !(cursor.par()->Previous()
- && cursor.par()->Previous()->footnoteflag
- == LyXParagraph::OPEN_FOOTNOTE)))
- return;
- } else if (IsNewlineChar(c)) {
- if (!IsEmptyTableCell()) {
- TableFeatures(bview, LyXTable::APPEND_CONT_ROW);
- CursorDown(bview);
- }
- return;
- }
-
- row = cursor.row();
- y = cursor.y() - row->baseline();
- if (c != LyXParagraph::META_INSET) /* in this case LyXText::InsertInset
- * already inserted the character */
- cursor.par()->InsertChar(cursor.pos(), c);
- SetCharFont(bview->buffer(), cursor.par(), cursor.pos(), rawtmpfont);
-
- if (!jumped_over_space) {
- /* refresh the positions */
- tmprow = row;
- while (tmprow->next() && tmprow->next()->par() == row->par()) {
- tmprow = tmprow->next();
- tmprow->pos(tmprow->pos() + 1);
- }
- }
-
- cursor.pos(cursor.pos() + 1);
-
- CheckParagraphInTable(bview, cursor.par(), cursor.pos());
-
- current_font = rawtmpfont;
- real_current_font = realtmpfont;
-
- /* check, whether the last character's font has changed. */
- if (cursor.pos() && cursor.pos() == cursor.par()->Last()
- && rawparfont != rawtmpfont)
- RedoHeightOfParagraph(bview, cursor);
-}
-
-
-void LyXText::CheckParagraphInTable(BufferView * bview, LyXParagraph * par,
- LyXParagraph::size_type pos)
-{
-
- if (par->GetChar(pos) == LyXParagraph::META_INSET &&
- par->GetInset(pos) && par->GetInset(pos)->display()){
- par->GetInset(pos)->display(false);
- }
-
- long y;
- Row * row = GetRow(par, pos, y);
-
- int tmpheight = row->height();
- SetHeightOfRow(bview, row);
-
- LyXParagraph::size_type tmp_pos = pos;
- /* update the table information */
- while (tmp_pos && !par->IsNewline(tmp_pos - 1))
- --tmp_pos;
- if (par->table->SetWidthOfCell(NumberOfCell(par, pos),
- WidthOfCell(bview, par, tmp_pos))) {
- LyXCursor tmpcursor = cursor;
- SetCursorIntern(bview, par, pos, false);
- /* make a complete redraw */
- RedoDrawingOfParagraph(bview, cursor);
- cursor = tmpcursor;
- }
- else {
- /* redraw only the row */
- LyXCursor tmpcursor = cursor;
- SetCursorIntern(bview, par, pos);
- //CHECK See comment on top of text.C
- refresh_y = y;
- refresh_x = cursor.x();
- refresh_row = row;
- refresh_pos = cursor.pos();
- cursor = tmpcursor;
-
- if (tmpheight == row->height())
- status = LyXText::NEED_VERY_LITTLE_REFRESH;
- else
- status = LyXText::NEED_MORE_REFRESH;
- }
- SetCursorIntern(bview, cursor.par(), cursor.pos(), false,
- cursor.boundary());
-}
-
-
-void LyXText::BackspaceInTable(BufferView * bview)
-{
- Row * tmprow, * row;
- long y;
-
- LyXFont rawtmpfont = current_font;
- LyXFont realtmpfont = real_current_font;
-
- // Get the font that is used to calculate the baselineskip
- int const lastpos = cursor.par()->Last();
- LyXFont rawparfont = cursor.par()->GetFontSettings(bview->buffer()->params,
- lastpos - 1);
-
- if (cursor.pos() == 0) {
- /* no pasting of table paragraphs */
-
- CursorLeft(bview);
- } else {
- /* this is the code for a normal backspace, not pasting
- * any paragraphs */
- SetUndo(bview->buffer(), Undo::DELETE,
- cursor.par()->ParFromPos(cursor.pos())->previous,
- cursor.par()->ParFromPos(cursor.pos())->next);
-
- CursorLeftIntern(bview);
-
- /* some insets are undeletable here */
- if (cursor.par()->GetChar(cursor.pos()) == LyXParagraph::META_INSET) {
- if (!cursor.par()->GetInset(cursor.pos())->Deletable())
- return;
- }
-
- row = cursor.row();
- y = cursor.y() - row->baseline();
-
- /* some special code when deleting a newline. */
- if (cursor.par()->IsNewline(cursor.pos())) {
- /* nothing :-) */
- return;
- } else {
- cursor.par()->Erase(cursor.pos());
-
- /* refresh the positions */
- tmprow = row;
- while (tmprow->next()
- && tmprow->next()->par() == row->par()) {
- tmprow = tmprow->next();
- tmprow->pos(tmprow->pos() - 1);
- }
- }
-
- CheckParagraphInTable(bview, cursor.par(), cursor.pos());
-
- /* check, wether the last characters font has changed. */
- if (cursor.pos() && cursor.pos() == cursor.par()->Last()
- && rawparfont != rawtmpfont)
- RedoHeightOfParagraph(bview, cursor);
-
- /* restore the current font
- * That is what a user expects! */
- current_font = rawtmpfont;
- real_current_font = realtmpfont;
- }
- SetCursorIntern(bview, cursor.par(), cursor.pos(), true,
- cursor.boundary());
- if (IsBoundary(bview->buffer(), cursor.par(), cursor.pos()) != cursor.boundary())
- SetCursor(bview, cursor.par(), cursor.pos(), false, !cursor.boundary());
-}
-
-/* table stuff -- end*/
-#endif
-
-
// Just a macro to make some thing easier.
void LyXText::RedoParagraph(BufferView * bview) const
{
* same Paragraph one to the right and make a rebreak */
void LyXText::InsertChar(BufferView * bview, char c)
{
- SetUndo(bview->buffer(), Undo::INSERT,
+ SetUndo(bview->buffer(), Undo::INSERT,
+#ifndef NEW_INSETS
cursor.par()->ParFromPos(cursor.pos())->previous,
- cursor.par()->ParFromPos(cursor.pos())->next);
+ cursor.par()->ParFromPos(cursor.pos())->next
+#else
+ cursor.par()->previous,
+ cursor.par()->next
+#endif
+ );
// When the free-spacing option is set for the current layout,
// disable the double-space checking
textclasslist.Style(bview->buffer()->params.textclass,
cursor.row()->par()->GetLayout()).free_spacing;
-#ifndef NEW_TABULAR
- /* table stuff -- begin*/
- if (cursor.par()->table) {
- InsertCharInTable(bview, c);
- charInserted();
- return;
- }
- /* table stuff -- end*/
-#endif
/* First check, if there will be two blanks together or a blank at
the beginning of a paragraph.
I decided to handle blanks like normal characters, the main
|| (cursor.pos() > 0
&& cursor.par()->IsNewline(cursor.pos() - 1))
|| (cursor.pos() == 0
+#ifndef NEW_INSETS
&& !(cursor.par()->Previous()
&& cursor.par()->Previous()->footnoteflag
- == LyXParagraph::OPEN_FOOTNOTE))) {
+ == LyXParagraph::OPEN_FOOTNOTE)
+#endif
+ )) {
if (cursor.pos() == 0 )
bview->owner()->getMiniBuffer()->Set(_("You cannot insert a space at the beginning of a paragraph. Please read the Tutorial."));
else
return;
}
} else if (IsNewlineChar(c)) {
+#ifndef NEW_INSETS
if (cursor.par()->FirstPhysicalPar() == cursor.par()
+#else
+ if (cursor.par() == cursor.par()
+#endif
&& cursor.pos() <= BeginningOfMainBody(bview->buffer(), cursor.par())) {
charInserted();
return;
if (cursor.pos() < cursor.par()->Last() &&
cursor.par()->IsLineSeparator(cursor.pos()))
// newline always after a blank!
- CursorRightIntern(bview);
+ CursorRight(bview);
cursor.row()->fill(-1); // to force a new break
}
// get the cursor row fist
Row * row = cursor.row();
- long y = cursor.y() - row->baseline();
+ int y = cursor.y() - row->baseline();
if (c != LyXParagraph::META_INSET) /* Here case LyXText::InsertInset
* already insertet the character */
cursor.par()->InsertChar(cursor.pos(), c);
fill_separator = 0;
fill_label_hfill = 0;
-#ifndef NEW_INSETS
bool is_rtl = row->par()->isRightToLeftPar(bview->buffer()->params);
+#ifndef NEW_INSETS
if (is_rtl) {
x = RightMargin(bview->buffer(), row);
}
// are there any hfills in the row?
- float nh = NumberOfHfills(bview->buffer(), row);
-
-#ifndef NEW_TABULAR
-/* table stuff -- begin*/
- if (row->par()->table) {
- w = workWidth(bview) - row->par()->table->WidthOfTable()
- - x - RightMargin(bview->buffer(), row);
- nh = 0; /* ignore hfills in tables */
- }
-/* table stuff -- end*/
-#endif
+ float const nh = NumberOfHfills(bview->buffer(), row);
+
if (nh)
- fill_hfill = w /nh;
+ fill_hfill = w / nh;
else {
// is it block, flushleft or flushright?
// set x how you need it
int align;
+#ifndef NEW_INSETS
if (row->par()->FirstPhysicalPar()->align == LYX_ALIGN_LAYOUT)
align = textclasslist.Style(bview->buffer()->params.textclass, row->par()->GetLayout()).align;
else
align = row->par()->FirstPhysicalPar()->align;
+#else
+ if (row->par()->align == LYX_ALIGN_LAYOUT)
+ align = textclasslist.Style(bview->buffer()->params.textclass, row->par()->GetLayout()).align;
+ else
+ align = row->par()->align;
+#endif
// center displayed insets
+ Inset * inset;
if (row->par()->GetChar(row->pos()) == LyXParagraph::META_INSET
- && row->par()->GetInset(row->pos())
- && row->par()->GetInset(row->pos())->display())
+ && (inset=row->par()->GetInset(row->pos()))
+ && (inset->display())) // || (inset->scroll() < 0)))
align = LYX_ALIGN_CENTER;
switch (align) {
void LyXText::CursorTab(BufferView * bview) const
{
-#ifndef NEW_TABULAR
- if (cursor.par()->table) {
- int cell = NumberOfCell(cursor.par(), cursor.pos());
- while(cursor.par()->table->IsContRow(cell)) {
- CursorUp(bview);
- cell = NumberOfCell(cursor.par(), cursor.pos());
- }
- if (cursor.par()->table->ShouldBeVeryLastCell(cell))
- TableFeatures(bview, LyXTable::APPEND_ROW);
- }
-#endif
LyXCursor tmpcursor = cursor;
while (tmpcursor.pos() < tmpcursor.par()->Last()
&& !tmpcursor.par()->IsNewline(tmpcursor.pos()))
} else
tmpcursor.pos(tmpcursor.pos() + 1);
SetCursor(bview, tmpcursor.par(), tmpcursor.pos());
-#ifndef NEW_TABULAR
- if (cursor.par()->table) {
- int cell = NumberOfCell(cursor.par(), cursor.pos());
- while (cursor.par()->table->IsContRow(cell) &&
- !cursor.par()->table->ShouldBeVeryLastCell(cell)) {
- tmpcursor = cursor;
- while (tmpcursor.pos() < tmpcursor.par()->Last()
- && !tmpcursor.par()->IsNewline(tmpcursor.pos()))
- tmpcursor.pos(tmpcursor.pos() + 1);
-
- if (tmpcursor.pos() == tmpcursor.par()->Last()){
- if (tmpcursor.par()->Next()) {
- tmpcursor.par(tmpcursor.par()->Next());
- tmpcursor.pos(0);
- }
- } else
- tmpcursor.pos(tmpcursor.pos() + 1);
- SetCursor(bview, tmpcursor.par(), tmpcursor.pos());
- cell = NumberOfCell(cursor.par(), cursor.pos());
- }
- }
-#endif
}
&& (tmpcursor.par()->IsSeparator(tmpcursor.pos() - 1)
|| tmpcursor.par()->IsKomma(tmpcursor.pos() - 1))
&& !(tmpcursor.par()->IsHfill(tmpcursor.pos() - 1)
+#ifndef NEW_INSETS
|| tmpcursor.par()->IsFloat(tmpcursor.pos() - 1)
+#endif
|| tmpcursor.par()->IsInset(tmpcursor.pos() - 1)))
tmpcursor.pos(tmpcursor.pos() - 1);
if (tmpcursor.pos()
&& (tmpcursor.par()->IsInset(tmpcursor.pos() - 1)
+#ifndef NEW_INSETS
|| tmpcursor.par()->IsFloat(tmpcursor.pos() - 1)
+#endif
|| tmpcursor.par()->IsHfill(tmpcursor.pos() - 1))) {
tmpcursor.pos(tmpcursor.pos() - 1);
} else if (!tmpcursor.pos()) {
// This function is only used by the spellchecker for NextWord().
// It doesn't handle LYX_ACCENTs and probably never will.
-char * LyXText::SelectNextWord(BufferView * bview, float & value)
+string const LyXText::SelectNextWord(BufferView * bview,
+ float & value) const
{
LyXParagraph * tmppar = cursor.par();
// Start the selection from here
sel_cursor = cursor;
-#ifdef HAVE_SSTREAM
std::ostringstream latex;
-#else
- ostrstream latex;
-#endif
+
// and find the end of the word
// (optional hyphens are part of a word)
while (cursor.pos() < cursor.par()->Last()
|| (cursor.par()->GetChar(cursor.pos()) == LyXParagraph::META_INSET
&& cursor.par()->GetInset(cursor.pos()) != 0
&& cursor.par()->GetInset(cursor.pos())->Latex(bview->buffer(), latex, false, false) == 0
-#ifdef HAVE_SSTREAM
&& latex.str() == "\\-"
-#else
- && latex.str() // protect against null pointers
- && string(latex.str(), 3) == "\\-" // this is not nice at all
-#endif
))
cursor.pos(cursor.pos() + 1);
-#ifndef HAVE_SSTREAM
- delete [] latex.str();
-#endif
// Finally, we copy the word to a string and return it
- char * str = 0;
-
+ string str;
if (sel_cursor.pos() < cursor.pos()) {
- str = new char [cursor.pos() - sel_cursor.pos() + 2];
- LyXParagraph::size_type i, j;
- for (i = sel_cursor.pos(), j = 0; i < cursor.pos(); ++i) {
+ LyXParagraph::size_type i;
+ for (i = sel_cursor.pos(); i < cursor.pos(); ++i) {
if (cursor.par()->GetChar(i) != LyXParagraph::META_INSET)
- str[j++] = cursor.par()->GetChar(i);
+ str += cursor.par()->GetChar(i);
}
- str[j] = '\0';
}
return str;
}
// set the sel cursor
sel_cursor = cursor;
-#ifdef HAVE_SSTREAM
std::ostringstream latex;
-#else
- ostrstream latex;
-#endif
// now find the end of the word
while (cursor.pos() < cursor.par()->Last()
|| (cursor.par()->GetChar(cursor.pos()) == LyXParagraph::META_INSET
&& cursor.par()->GetInset(cursor.pos()) != 0
&& cursor.par()->GetInset(cursor.pos())->Latex(bview->buffer(), latex, false, false) == 0
-#ifdef HAVE_SSTREAM
&& latex.str() == "\\-"
-#else
- && string(latex.str(), 3) == "\\-"
-#endif
)))
cursor.pos(cursor.pos() + 1);
-#ifndef HAVE_SSTREAM
- delete [] latex.str();
-#endif
SetCursor(bview, cursor.par(), cursor.pos());
// finally set the selection
// version did. (JMarc)
void LyXText::ChangeWordCase(BufferView * bview, LyXText::TextCase action)
{
+#ifndef NEW_INSETS
LyXParagraph * tmppar = cursor.par()->ParFromPos(cursor.pos());
+#else
+ LyXParagraph * tmppar = cursor.par();
+#endif
SetUndo(bview->buffer(),Undo::FINISH, tmppar->previous, tmppar->next);
+#ifndef NEW_INSETS
LyXParagraph::size_type tmppos =
cursor.par()->PositionInParFromPos(cursor.pos());
+#else
+ LyXParagraph::size_type tmppos = cursor.pos();
+#endif
while (tmppos < tmppar->size()) {
unsigned char c = tmppar->GetChar(tmppos);
if (IsKommaChar(c) || IsLineSeparatorChar(c))
old_cursor.par()->previous->id() : 0;
// just move to the right
- CursorRightIntern(bview);
+ CursorRight(bview);
// CHECK Look at the comment here.
// This check is not very good...
if (old_cursor.par() != cursor.par() || old_cursor.pos() != cursor.pos()) {
LyXCursor tmpcursor = cursor;
cursor = old_cursor; // to make sure undo gets the right cursor position
- SetUndo(bview->buffer(), Undo::DELETE,
+ SetUndo(bview->buffer(), Undo::DELETE,
+#ifndef NEW_INSETS
cursor.par()->ParFromPos(cursor.pos())->previous,
- cursor.par()->ParFromPos(cursor.pos())->next);
+ cursor.par()->ParFromPos(cursor.pos())->next
+#else
+ cursor.par()->previous,
+ cursor.par()->next
+#endif
+ );
cursor = tmpcursor;
Backspace(bview);
}
void LyXText::Backspace(BufferView * bview)
{
-#ifndef NEW_TABULAR
- /* table stuff -- begin */
- if (cursor.par()->table) {
- BackspaceInTable(bview);
- return;
- }
- /* table stuff -- end */
-#endif
- // LyXFont rawtmpfont = current_font;
- // LyXFont realtmpfont = real_current_font;
- // We don't need the above variables as calling to SetCursor() with third
- // argument eqaul to false, will not change current_font & real_current_font
-
// Get the font that is used to calculate the baselineskip
LyXParagraph::size_type lastpos = cursor.par()->Last();
LyXFont rawparfont = cursor.par()->GetFontSettings(bview->buffer()->params,
lastpos - 1);
if (cursor.pos() == 0) {
- // The cursor is at the beginning of a paragraph, so the the backspace
- // will collapse two paragraphs into one.
+ // The cursor is at the beginning of a paragraph,
+ // so the the backspace will collapse two paragraphs into one.
// we may paste some paragraphs
if ((lastpos == 0
|| (lastpos == 1 && cursor.par()->IsSeparator(0)))
+#ifndef NEW_INSETS
&& !(cursor.par()->Next()
&& cursor.par()->footnoteflag == LyXParagraph::NO_FOOTNOTE
- && cursor.par()->Next()->footnoteflag == LyXParagraph::OPEN_FOOTNOTE)) {
+ && cursor.par()->Next()->footnoteflag == LyXParagraph::OPEN_FOOTNOTE)
+#endif
+ ) {
// This is an empty paragraph and we delete it just by moving the cursor one step
// left and let the DeleteEmptyParagraphMechanism handle the actual deletion
// of the paragraph.
if (cursor.par()->previous) {
+#ifndef NEW_INSETS
LyXParagraph * tmppar = cursor.par()->previous->FirstPhysicalPar();
+#else
+ LyXParagraph * tmppar = cursor.par()->previous;
+#endif
if (cursor.par()->GetLayout() == tmppar->GetLayout()
+#ifndef NEW_INSETS
&& cursor.par()->footnoteflag == tmppar->footnoteflag
+#endif
&& cursor.par()->GetAlign() == tmppar->GetAlign()) {
// Inherit botom DTD from the paragraph below.
// (the one we are deleting)
tmppar->pagebreak_bottom = cursor.par()->pagebreak_bottom;
}
- CursorLeftIntern(bview);
+ CursorLeft(bview);
// the layout things can change the height of a row !
int tmpheight = cursor.row()->height();
return;
}
}
-
+
+#ifndef NEW_INSETS
if (cursor.par()->ParFromPos(cursor.pos())->previous){
SetUndo(bview->buffer(), Undo::DELETE,
cursor.par()->ParFromPos(cursor.pos())->previous->previous,
cursor.par()->ParFromPos(cursor.pos())->next);
}
+#else
+ if (cursor.par()->previous) {
+ SetUndo(bview->buffer(), Undo::DELETE,
+ cursor.par()->previous->previous,
+ cursor.par()->next);
+ }
+#endif
LyXParagraph * tmppar = cursor.par();
Row * tmprow = cursor.row();
if (cursor.par() != tmppar
&& (cursor.par()->GetLayout() == tmppar->GetLayout()
|| tmppar->GetLayout() == 0 /*standard*/)
+#ifndef NEW_INSETS
&& cursor.par()->footnoteflag == tmppar->footnoteflag
-#ifndef NEW_TABULAR
- /* table stuff -- begin*/
- && !cursor.par()->table /* no pasting of tables */
- /* table stuff -- end*/
#endif
&& cursor.par()->GetAlign() == tmppar->GetAlign()) {
} else {
/* this is the code for a normal backspace, not pasting
* any paragraphs */
- SetUndo(bview->buffer(), Undo::DELETE,
+ SetUndo(bview->buffer(), Undo::DELETE,
+#ifndef NEW_INSETS
cursor.par()->ParFromPos(cursor.pos())->previous,
- cursor.par()->ParFromPos(cursor.pos())->next);
+ cursor.par()->ParFromPos(cursor.pos())->next
+#else
+ cursor.par()->previous,
+ cursor.par()->next
+#endif
+ );
// We used to do CursorLeftIntern() here, but it is
// not a good idea since it triggers the auto-delete
// mechanism. So we do a CursorLeftIntern()-lite,
}
Row * row = cursor.row();
- long y = cursor.y() - row->baseline();
+ int y = cursor.y() - row->baseline();
LyXParagraph::size_type z;
/* remember that a space at the end of a row doesnt count
* when calculating the fill */
}
// break the cursor row again
- z = NextBreakPoint(bview, row, workWidth(bview));
-
- if (z != RowLast(row) ||
- (row->next() && row->next()->par() == row->par() &&
- RowLast(row) == row->par()->Last() - 1)){
+ if (row->next() && row->next()->par() == row->par() &&
+ (RowLast(row) == row->par()->Last() - 1 ||
+ NextBreakPoint(bview, row, workWidth(bview)) != RowLast(row))) {
/* it can happen that a paragraph loses one row
* without a real breakup. This is when a word
* is to long to be broken. Well, I don t care this
* hack ;-) */
- if (row->next() && row->next()->par() == row->par() &&
- RowLast(row) == row->par()->Last() - 1)
+ if (RowLast(row) == row->par()->Last() - 1)
RemoveRow(row->next());
refresh_y = y;
SetCursor(bview, cursor.par(), cursor.pos(), false, cursor.boundary());
// cursor MUST be in row now
- if (row->next() && row->next()->par() == row->par())
- need_break_row = row->next();
- else
- need_break_row = 0;
+ need_break_row = row->next();
} else {
// set the dimensions of the row
row->fill(Fill(bview, row, workWidth(bview)));
lastpos = cursor.par()->Last();
if (cursor.pos() == lastpos) {
- SetCurrentFont(bview);
if (IsBoundary(bview->buffer(), cursor.par(), cursor.pos()) != cursor.boundary())
SetCursor(bview, cursor.par(), cursor.pos(), false, !cursor.boundary());
+ SetCurrentFont(bview);
}
// check, wether the last characters font has changed.
void LyXText::GetVisibleRow(BufferView * bview, int y_offset, int x_offset,
- Row * row_ptr, long y, bool cleared)
+ Row * row_ptr, int y, bool cleared)
{
/* returns a printed row */
Painter & pain = bview->painter();
LyXParagraph::size_type last = RowLastPrintable(row_ptr);
LyXParagraph::size_type vpos, pos;
- float x, tmpx;
- int y_top, y_bottom;
- float fill_separator, fill_hfill, fill_label_hfill;
+ float x;
+ float tmpx;
+ int y_top;
+ int y_bottom;
LyXFont font(LyXFont::ALL_SANE);
int maxdesc;
<< row_ptr->height() << endl;
return;
}
+
+ float fill_separator;
+ float fill_hfill;
+ float fill_label_hfill;
PrepareToPrint(bview, row_ptr, x, fill_separator,
fill_hfill, fill_label_hfill);
x += x_offset;
// clear the area where we want to paint/print
- int ww;
- ww = bview->workWidth();
+ int ww = bview->workWidth();
bool clear_area = true;
Inset * inset = 0;
- if ((last == row_ptr->pos()) &&
+ if (!bview->screen()->forceClear() && (last == row_ptr->pos()) &&
(row_ptr->par()->GetChar(row_ptr->pos()) == LyXParagraph::META_INSET) &&
- (inset=row_ptr->par()->GetInset(row_ptr->pos())))
- {
+ (inset = row_ptr->par()->GetInset(row_ptr->pos()))) {
clear_area = inset->doClearArea();
}
- if (cleared) { // we don't need to clear it's already done!!!
+ // we don't need to clear it's already done!!!
+ if (cleared) {
clear_area = true;
} else if (clear_area) {
- int w;
- if (inset_owner)
- w = inset_owner->width(bview, font);
- else
- w = ww;
+ int w = (inset_owner ? inset_owner->width(bview, font) : ww);
pain.fillRectangle(x_offset, y_offset, w, row_ptr->height());
} else if (inset != 0) {
int h = row_ptr->baseline() - inset->ascent(bview, font);
if (h > 0) {
- int w;
- if (inset_owner)
- w = inset_owner->width(bview, font);
- else
- w = ww;
+ int w = (inset_owner ?
+ inset_owner->width(bview, font) : ww);
pain.fillRectangle(x_offset, y_offset, w, h);
}
+ h += inset->ascent(bview, font) + inset->descent(bview, font);
+ if ((row_ptr->height() - h) > 0) {
+ int w = (inset_owner ?
+ inset_owner->width(bview, font) : ww);
+ pain.fillRectangle(x_offset,y_offset+h, w, row_ptr->height()-h);
+ }
+ if (!inset_owner && !inset->display() && !inset->needFullRow())
+ {
+ int w = inset->width(bview, font) + int(x);
+ pain.fillRectangle(w, y_offset, ww - w, row_ptr->height());
+ }
}
if (selection) {
+ int w = (inset_owner ? inset_owner->width(bview, font) : ww);
/* selection code */
if (bidi_same_direction) {
if (sel_start_cursor.row() == row_ptr &&
else
pain.fillRectangle(x_offset + sel_start_cursor.x(),
y_offset,
- ww - sel_start_cursor.x(),
+ w - sel_start_cursor.x(),
row_ptr->height(),
LColor::selection);
} else if (sel_end_cursor.row() == row_ptr) {
if (is_rtl)
pain.fillRectangle(x_offset + sel_end_cursor.x(),
y_offset,
- ww - sel_end_cursor.x(),
+ w - sel_end_cursor.x(),
row_ptr->height(),
LColor::selection);
else
sel_end_cursor.x(),
row_ptr->height(),
LColor::selection);
- } else if (y > long(sel_start_cursor.y())
- && y < long(sel_end_cursor.y())) {
- pain.fillRectangle(x_offset, y_offset, ww,
+ } else if (y > sel_start_cursor.y()
+ && y < sel_end_cursor.y()) {
+ pain.fillRectangle(x_offset, y_offset, w,
row_ptr->height(),
LColor::selection);
}
} else if ( sel_start_cursor.row() != row_ptr &&
sel_end_cursor.row() != row_ptr &&
- y > long(sel_start_cursor.y())
- && y < long(sel_end_cursor.y())) {
- pain.fillRectangle(x_offset, y_offset, ww,
+ y > sel_start_cursor.y()
+ && y < sel_end_cursor.y()) {
+ pain.fillRectangle(x_offset, y_offset, w,
row_ptr->height(),
LColor::selection);
} else if (sel_start_cursor.row() == row_ptr ||
sel_end_cursor.row() == row_ptr) {
float tmpx = x;
- int cell = 0;
-#ifndef NEW_TABULAR
- if (row_ptr->par()->table) {
- cell = NumberOfCell(row_ptr->par(), row_ptr->pos());
- tmpx += row_ptr->par()->table->GetBeginningOfTextInCell(cell);
- }
-#endif
if ( (sel_start_cursor.row() != row_ptr && !is_rtl) ||
(sel_end_cursor.row() != row_ptr && is_rtl))
pain.fillRectangle(x_offset, y_offset,
int(tmpx),
row_ptr->height(),
LColor::selection);
-#ifndef NEW_TABULAR
- if (row_ptr->par()->table) {
- float x_old = x;
- for (vpos = row_ptr->pos(); vpos <= last; ++vpos) {
- pos = vis2log(vpos);
- float old_tmpx = tmpx;
- if (row_ptr->par()->IsNewline(pos)) {
- tmpx = x_old + row_ptr->par()->table->WidthOfColumn(cell);
- x_old = tmpx;
- ++cell;
- tmpx += row_ptr->par()->table->GetBeginningOfTextInCell(cell);
- } else {
- tmpx += SingleWidth(bview, row_ptr->par(), pos);
- }
- if ( (sel_start_cursor.row() != row_ptr ||
- sel_start_cursor.pos() <= pos) &&
- (sel_end_cursor.row() != row_ptr ||
- pos < sel_end_cursor.pos()) )
- pain.fillRectangle(x_offset + int(old_tmpx),
- y_offset,
- int(tmpx - old_tmpx + 1),
- row_ptr->height(),
- LColor::selection);
+ LyXParagraph::size_type main_body =
+ BeginningOfMainBody(bview->buffer(),
+ row_ptr->par());
+
+ for (vpos = row_ptr->pos(); vpos <= last; ++vpos) {
+ pos = vis2log(vpos);
+ float old_tmpx = tmpx;
+ if (main_body > 0 && pos == main_body-1) {
+ tmpx += fill_label_hfill +
+ lyxfont::width(textclasslist.Style(bview->buffer()->params.textclass,
+ row_ptr->par()->GetLayout()).labelsep,
+ GetFont(bview->buffer(),row_ptr->par(), -2));
+ if (row_ptr->par()->IsLineSeparator(main_body-1))
+ tmpx -= SingleWidth(bview, row_ptr->par(), main_body-1);
}
- } else {
-#endif
- LyXParagraph::size_type main_body =
- BeginningOfMainBody(bview->buffer(),
- row_ptr->par());
-
- for (vpos = row_ptr->pos(); vpos <= last; ++vpos) {
- pos = vis2log(vpos);
- float old_tmpx = tmpx;
- if (main_body > 0 && pos == main_body-1) {
- tmpx += fill_label_hfill +
- lyxfont::width(textclasslist.Style(bview->buffer()->params.textclass,
- row_ptr->par()->GetLayout()).labelsep,
- GetFont(bview->buffer(),row_ptr->par(), -2));
- if (row_ptr->par()->IsLineSeparator(main_body-1))
- tmpx -= SingleWidth(bview, row_ptr->par(), main_body-1);
- }
- if (HfillExpansion(bview->buffer(), row_ptr, pos)) {
- tmpx += SingleWidth(bview, row_ptr->par(), pos);
- if (pos >= main_body)
- tmpx += fill_hfill;
- else
- tmpx += fill_label_hfill;
- }
- else if (row_ptr->par()->IsSeparator(pos)) {
- tmpx += SingleWidth(bview, row_ptr->par(), pos);
- if (pos >= main_body)
- tmpx += fill_separator;
- } else
- tmpx += SingleWidth(bview, row_ptr->par(), pos);
-
- if ( (sel_start_cursor.row() != row_ptr ||
- sel_start_cursor.pos() <= pos) &&
- (sel_end_cursor.row() != row_ptr ||
- pos < sel_end_cursor.pos()) )
- pain.fillRectangle(x_offset + int(old_tmpx),
- y_offset,
- int(tmpx - old_tmpx + 1),
- row_ptr->height(),
- LColor::selection);
+ if (HfillExpansion(bview->buffer(), row_ptr, pos)) {
+ tmpx += SingleWidth(bview, row_ptr->par(), pos);
+ if (pos >= main_body)
+ tmpx += fill_hfill;
+ else
+ tmpx += fill_label_hfill;
}
-#ifndef NEW_TABULAR
+ else if (row_ptr->par()->IsSeparator(pos)) {
+ tmpx += SingleWidth(bview, row_ptr->par(), pos);
+ if (pos >= main_body)
+ tmpx += fill_separator;
+ } else
+ tmpx += SingleWidth(bview, row_ptr->par(), pos);
+
+ if ( (sel_start_cursor.row() != row_ptr ||
+ sel_start_cursor.pos() <= pos) &&
+ (sel_end_cursor.row() != row_ptr ||
+ pos < sel_end_cursor.pos()) )
+ pain.fillRectangle(x_offset + int(old_tmpx),
+ y_offset,
+ int(tmpx - old_tmpx + 1),
+ row_ptr->height(),
+ LColor::selection);
}
-#endif
+
if ( (sel_start_cursor.row() != row_ptr && is_rtl) ||
(sel_end_cursor.row() != row_ptr && !is_rtl) )
pain.fillRectangle(x_offset + int(tmpx),
}
#endif
// Draw appendix lines
+#ifndef NEW_INSETS
LyXParagraph * firstpar = row_ptr->par()->FirstPhysicalPar();
+#else
+ LyXParagraph * firstpar = row_ptr->par();
+#endif
if (firstpar->appendix){
pain.line(1, y_offset,
1, y_offset + row_ptr->height(),
int next_depth = 0;
int prev_depth = 0;
if (row_ptr->next())
+#ifndef NEW_INSETS
if (row_ptr->par()->footnoteflag ==
row_ptr->next()->par()->footnoteflag)
next_depth = row_ptr->next()->par()->GetDepth();
else if (row_ptr->par()->footnoteflag != LyXParagraph::OPEN_FOOTNOTE)
next_depth = depth;
-
+#else
+ next_depth = row_ptr->next()->par()->GetDepth();
+#endif
if (row_ptr->previous())
+#ifndef NEW_INSETS
if (row_ptr->par()->footnoteflag ==
row_ptr->previous()->par()->footnoteflag)
prev_depth = row_ptr->previous()->par()->GetDepth();
else if (row_ptr->par()->footnoteflag != LyXParagraph::OPEN_FOOTNOTE)
prev_depth = depth;
+#else
+ prev_depth = row_ptr->previous()->par()->GetDepth();
+#endif
for (int i = 1; i <= depth; ++i) {
int line_x = (LYX_PAPER_MARGIN / 5) * (i + minipage) + box_x;
y_top += lyxfont::ascent('x',
GetFont(bview->buffer(),
row_ptr->par(), 0));
-
- pain.line(0, y_offset + y_top,
- ww, y_offset + y_top,
+ int w = (inset_owner ? inset_owner->width(bview, font) : ww);
+ int xp = static_cast<int>(inset_owner ? x : 0);
+ pain.line(xp, y_offset + y_top,
+ w, y_offset + y_top,
LColor::topline,
Painter::line_solid,
Painter::line_thick);
if (is_rtl) {
tmpx = ww - LeftMargin(bview, row_ptr)
+ lyxfont::width(layout.labelsep, font);
+#ifndef NEW_INSETS
if (row_ptr->par()->footnoteflag == LyXParagraph::OPEN_FOOTNOTE) {
LyXFont font(LyXFont::ALL_SANE);
font.setSize(LyXFont::SIZE_SMALL);
tmpx += lyxfont::width("Mwide-fixM", font);
}
+#endif
} else
tmpx = x - lyxfont::width(layout.labelsep, font)
- lyxfont::width(tmpstring, font);
}
/* is it a last row? */
+#ifndef NEW_INSETS
LyXParagraph * par = row_ptr->par()->LastPhysicalPar();
- if ((row_ptr->par()->ParFromPos(last + 1) == par) &&
- (!row_ptr->next() || (row_ptr->next()->par() != row_ptr->par())))
+#else
+ LyXParagraph * par = row_ptr->par();
+#endif
+ if (
+#ifndef NEW_INSETS
+ (row_ptr->par()->ParFromPos(last + 1) == par)
+#else
+ (row_ptr->par() == par)
+#endif
+ && (!row_ptr->next() || (row_ptr->next()->par() != row_ptr->par())))
{
/* think about the margins */
if (!row_ptr->next() && bv_owner)
/* draw a bottom line */
y_bottom -= lyxfont::ascent('x', GetFont(bview->buffer(),
par, par->Last() - 1));
- pain.line(0, y_offset + y_bottom,
- ww, y_offset + y_bottom,
+ int w = (inset_owner ? inset_owner->width(bview, font) : ww);
+ int xp = static_cast<int>(inset_owner ? x : 0);
+ pain.line(xp, y_offset + y_bottom,
+ w, y_offset + y_bottom,
LColor::topline, Painter::line_solid,
Painter::line_thick);
y_bottom -= lyxfont::ascent('x', GetFont(bview->buffer(),
int y = (y_offset + row_ptr->baseline()) - size;
int x = is_rtl ? LYX_PAPER_MARGIN
: ww - LYX_PAPER_MARGIN - size;
+#ifndef NEW_INSETS
if (row_ptr->par()->footnoteflag == LyXParagraph::OPEN_FOOTNOTE)
if (is_rtl) {
LyXFont font(LyXFont::ALL_SANE);
x += lyxfont::width("Mwide-figM", font);
} else
x -= LYX_PAPER_MARGIN/2;
+#endif
if (row_ptr->fill() <= size)
x += (size - row_ptr->fill() + 1) * (is_rtl ? -1 : 1);
if (endlabel == END_LABEL_BOX) {
/* draw the text in the pixmap */
vpos = row_ptr->pos();
-#ifndef NEW_TABULAR
- /* table stuff -- begin*/
- if (row_ptr->par()->table) {
- bool on_off;
- int cell = NumberOfCell(row_ptr->par(), row_ptr->pos());
- float x_old = x;
- x += row_ptr->par()->table->GetBeginningOfTextInCell(cell);
-
- while (vpos <= last) {
- pos = vis2log(vpos);
- if (row_ptr->par()->IsNewline(pos)) {
-
- x = x_old + row_ptr->par()->table->WidthOfColumn(cell);
- /* draw the table lines, still very simple */
- on_off = !row_ptr->par()->table->TopLine(cell);
- if ((!on_off ||
- !row_ptr->par()->table->TopAlreadyDrawed(cell)) &&
- !row_ptr->par()->table->IsContRow(cell))
- pain.line(int(x_old),
- y_offset + row_ptr->baseline() - row_ptr->ascent_of_text(),
- int(x),
- y_offset + row_ptr->baseline() - row_ptr->ascent_of_text(),
- LColor::tableline,
- on_off ? Painter::line_onoffdash : Painter::line_solid);
-
- on_off = !row_ptr->par()->table->BottomLine(cell);
- if ((!on_off && !row_ptr->par()->table->RowHasContRow(cell)) ||
- row_ptr->par()->table->VeryLastRow(cell))
+
+ LyXParagraph::size_type main_body =
+ BeginningOfMainBody(bview->buffer(), row_ptr->par());
+ if (main_body > 0 &&
+ (main_body-1 > last ||
+ !row_ptr->par()->IsLineSeparator(main_body - 1)))
+ main_body = 0;
+
+ while (vpos <= last) {
+ pos = vis2log(vpos);
+ if (main_body > 0 && pos == main_body - 1) {
+ x += fill_label_hfill
+ + lyxfont::width(layout.labelsep,
+ GetFont(bview->buffer(),
+ row_ptr->par(), -2))
+ - SingleWidth(bview,
+ row_ptr->par(),
+ main_body - 1);
+ }
+
+ if (row_ptr->par() ->IsHfill(pos)) {
+ x += 1;
+ pain.line(int(x),
+ y_offset + row_ptr->baseline() - DefaultHeight() / 2,
+ int(x),
+ y_offset + row_ptr->baseline(),
+ LColor::vfillline);
+
+ if (HfillExpansion(bview->buffer(),
+ row_ptr, pos)) {
+ if (pos >= main_body) {
+ pain.line(int(x),
+ y_offset + row_ptr->baseline() - DefaultHeight() / 4,
+ int(x + fill_hfill),
+ y_offset + row_ptr->baseline() - DefaultHeight() / 4,
+ LColor::vfillline,
+ Painter::line_onoffdash);
+ x += fill_hfill;
+ } else {
+ pain.line(int(x),
+ y_offset + row_ptr->baseline() - DefaultHeight() / 4,
+ int(x + fill_label_hfill),
+ y_offset + row_ptr->baseline() - DefaultHeight() / 4,
+ LColor::vfillline,
+ Painter::line_onoffdash);
- pain.line(int(x_old),
- y_offset + y_bottom - 1,
- int(x),
- y_offset + y_bottom - 1,
- LColor::tableline,
- on_off ? Painter::line_onoffdash : Painter::line_solid);
-
- on_off = !row_ptr->par()->table->LeftLine(cell);
-
- pain.line(int(x_old),
- y_offset + row_ptr->baseline() - row_ptr->ascent_of_text(),
- int(x_old),
- y_offset + y_bottom - 1,
- LColor::tableline,
- on_off ? Painter::line_onoffdash : Painter::line_solid);
-
- on_off = !row_ptr->par()->table->RightLine(cell);
-
- pain.line(int(x) - row_ptr->par()->table->AdditionalWidth(cell),
- y_offset + row_ptr->baseline() - row_ptr->ascent_of_text(),
- int(x) - row_ptr->par()->table->AdditionalWidth(cell),
- y_offset + y_bottom - 1,
- LColor::tableline,
- on_off ? Painter::line_onoffdash : Painter::line_solid);
-
- x_old = x;
- /* take care about the alignment and other spaces */
- ++cell;
- x += row_ptr->par()->table->GetBeginningOfTextInCell(cell);
- if (row_ptr->par()->table->IsFirstCell(cell))
- --cell; // little hack, sorry
- ++vpos;
- } else if (row_ptr->par()->IsHfill(pos)) {
- x += 1;
-
+ x += fill_label_hfill;
+ }
pain.line(int(x),
y_offset + row_ptr->baseline() - DefaultHeight() / 2,
int(x),
y_offset + row_ptr->baseline(),
LColor::vfillline);
-
- x += 2;
- ++vpos;
- } else if (row_ptr->par()->IsSeparator(pos)) {
- tmpx = x;
- x+= SingleWidth(bview,
- row_ptr->par(), pos);
- ++vpos;
- } else
- draw(bview, row_ptr, vpos, y_offset, x, clear_area);
- }
-
- /* do not forget the very last cell. This has no NEWLINE so
- * ignored by the code above*/
- if (cell == row_ptr->par()->table->GetNumberOfCells() - 1) {
- x = x_old + row_ptr->par()->table->WidthOfColumn(cell);
- on_off = !row_ptr->par()->table->TopLine(cell);
- if ((!on_off ||
- !row_ptr->par()->table->TopAlreadyDrawed(cell)) &&
- !row_ptr->par()->table->IsContRow(cell))
-
- pain.line(int(x_old),
- y_offset + row_ptr->baseline() - row_ptr->ascent_of_text(),
- int(x),
- y_offset + row_ptr->baseline() - row_ptr->ascent_of_text(),
- LColor::tableline,
- on_off ? Painter::line_onoffdash : Painter::line_solid);
- on_off = !row_ptr->par()->table->BottomLine(cell);
- if ((!on_off && !row_ptr->par()->table->RowHasContRow(cell)) ||
- row_ptr->par()->table->VeryLastRow(cell))
-
- pain.line(int(x_old),
- y_offset + y_bottom - 1,
- int(x),
- y_offset + y_bottom - 1,
- LColor::tableline,
- on_off ? Painter::line_onoffdash : Painter::line_solid);
-
- on_off = !row_ptr->par()->table->LeftLine(cell);
-
- pain.line(int(x_old),
- y_offset + row_ptr->baseline() - row_ptr->ascent_of_text(),
- int(x_old),
- y_offset + y_bottom - 1,
- LColor::tableline,
- on_off ? Painter::line_onoffdash : Painter::line_solid);
-
- on_off = !row_ptr->par()->table->RightLine(cell);
-
- pain.line(int(x) - row_ptr->par()->table->AdditionalWidth(cell),
- y_offset + row_ptr->baseline() - row_ptr->ascent_of_text(),
- int(x) - row_ptr->par()->table->AdditionalWidth(cell),
- y_offset + y_bottom - 1,
- LColor::tableline,
- on_off ? Painter::line_onoffdash : Painter::line_solid);
- }
- } else {
- /* table stuff -- end*/
-#endif
- LyXParagraph::size_type main_body =
- BeginningOfMainBody(bview->buffer(), row_ptr->par());
- if (main_body > 0 &&
- (main_body-1 > last ||
- !row_ptr->par()->IsLineSeparator(main_body - 1)))
- main_body = 0;
-
- while (vpos <= last) {
- pos = vis2log(vpos);
- if (main_body > 0 && pos == main_body - 1) {
- x += fill_label_hfill
- + lyxfont::width(layout.labelsep,
- GetFont(bview->buffer(),
- row_ptr->par(), -2))
- - SingleWidth(bview,
- row_ptr->par(),
- main_body - 1);
}
-
- if (row_ptr->par() ->IsHfill(pos)) {
- x += 1;
- pain.line(int(x),
- y_offset + row_ptr->baseline() - DefaultHeight() / 2,
- int(x),
- y_offset + row_ptr->baseline(),
- LColor::vfillline);
-
- if (HfillExpansion(bview->buffer(),
- row_ptr, pos)) {
- if (pos >= main_body) {
- pain.line(int(x),
- y_offset + row_ptr->baseline() - DefaultHeight() / 4,
- int(x + fill_hfill),
- y_offset + row_ptr->baseline() - DefaultHeight() / 4,
- LColor::vfillline,
- Painter::line_onoffdash);
- x += fill_hfill;
- } else {
- pain.line(int(x),
- y_offset + row_ptr->baseline() - DefaultHeight() / 4,
- int(x + fill_label_hfill),
- y_offset + row_ptr->baseline() - DefaultHeight() / 4,
- LColor::vfillline,
- Painter::line_onoffdash);
-
- x += fill_label_hfill;
- }
- pain.line(int(x),
- y_offset + row_ptr->baseline() - DefaultHeight() / 2,
- int(x),
- y_offset + row_ptr->baseline(),
- LColor::vfillline);
- }
- x += 2;
- ++vpos;
- } else if (row_ptr->par()->IsSeparator(pos)) {
- x += SingleWidth(bview,
- row_ptr->par(), pos);
- if (pos >= main_body)
- x += fill_separator;
- ++vpos;
- } else
- draw(bview, row_ptr, vpos, y_offset, x, clear_area);
- }
-#ifndef NEW_TABULAR
+ x += 2;
+ ++vpos;
+ } else if (row_ptr->par()->IsSeparator(pos)) {
+ x += SingleWidth(bview,
+ row_ptr->par(), pos);
+ if (pos >= main_body)
+ x += fill_separator;
+ ++vpos;
+ } else
+ draw(bview, row_ptr, vpos, y_offset, x, clear_area);
}
-#endif
}
row->par()->GetLayout());
bool left_side = false;
-#ifndef NEW_TABULAR
- /* table stuff -- begin */
- if (row->par()->table) {
- //the last row doesn't need a newline at the end
- if (row->next() && row->next()->par() == row->par()
- && row->par()->IsNewline(last))
- --last;
- int cell = NumberOfCell(row->par(), row->pos());
- float cell_x = tmpx + row->par()->table->WidthOfColumn(cell);
- tmpx += row->par()->table->GetBeginningOfTextInCell(cell);
- float last_tmpx = tmpx;
- while (vc <= last && tmpx <= x) {
- c = vis2log(vc);
- last_tmpx = tmpx;
- if (row->par()->IsNewline(c)) {
- if (cell_x <= x){
- ++cell;
- tmpx = cell_x + row->par()->table->GetBeginningOfTextInCell(cell);
- cell_x += row->par()->table->WidthOfColumn(cell);
- ++vc;
- } else
- break;
- } else {
- tmpx += SingleWidth(bview, row->par(), c);
- ++vc;
- }
- }
- if (vc > row->pos() && !row->par()->IsNewline(c) &&
- (tmpx + last_tmpx) / 2 > x) {
- tmpx = last_tmpx;
- left_side = true;
- }
- } else {
- /* table stuff -- end*/
-#endif
- LyXParagraph::size_type
- main_body = BeginningOfMainBody(bview->buffer(), row->par());
- float last_tmpx = tmpx;
-
- if (main_body > 0 &&
- (main_body-1 > last ||
- !row->par()->IsLineSeparator(main_body - 1)))
- main_body = 0;
-
- while (vc <= last && tmpx <= x) {
- c = vis2log(vc);
- last_tmpx = tmpx;
- if (main_body > 0 && c == main_body-1) {
- tmpx += fill_label_hfill +
- lyxfont::width(layout.labelsep,
+ LyXParagraph::size_type
+ main_body = BeginningOfMainBody(bview->buffer(), row->par());
+ float last_tmpx = tmpx;
+
+ if (main_body > 0 &&
+ (main_body-1 > last ||
+ !row->par()->IsLineSeparator(main_body - 1)))
+ main_body = 0;
+
+ while (vc <= last && tmpx <= x) {
+ c = vis2log(vc);
+ last_tmpx = tmpx;
+ if (main_body > 0 && c == main_body-1) {
+ tmpx += fill_label_hfill +
+ lyxfont::width(layout.labelsep,
GetFont(bview->buffer(), row->par(), -2));
- if (row->par()->IsLineSeparator(main_body - 1))
- tmpx -= SingleWidth(bview, row->par(), main_body-1);
- }
-
- if (HfillExpansion(bview->buffer(), row, c)) {
- x += SingleWidth(bview, row->par(), c);
- if (c >= main_body)
- tmpx += fill_hfill;
- else
- tmpx += fill_label_hfill;
- }
- else if (row->par()->IsSeparator(c)) {
- tmpx += SingleWidth(bview, row->par(), c);
- if (c >= main_body)
- tmpx+= fill_separator;
- } else
- tmpx += SingleWidth(bview, row->par(), c);
- ++vc;
+ if (row->par()->IsLineSeparator(main_body - 1))
+ tmpx -= SingleWidth(bview, row->par(), main_body-1);
}
-
- if (vc > row->pos() && (tmpx + last_tmpx) / 2 > x) {
- tmpx = last_tmpx;
- left_side = true;
+
+ if (HfillExpansion(bview->buffer(), row, c)) {
+ x += SingleWidth(bview, row->par(), c);
+ if (c >= main_body)
+ tmpx += fill_hfill;
+ else
+ tmpx += fill_label_hfill;
}
-#ifndef NEW_TABULAR
+ else if (row->par()->IsSeparator(c)) {
+ tmpx += SingleWidth(bview, row->par(), c);
+ if (c >= main_body)
+ tmpx+= fill_separator;
+ } else
+ tmpx += SingleWidth(bview, row->par(), c);
+ ++vc;
+ }
+
+ if (vc > row->pos() && (tmpx + last_tmpx) / 2 > x) {
+ tmpx = last_tmpx;
+ left_side = true;
}
-#endif
-
if (vc > last + 1) // This shouldn't happen.
vc = last + 1;
boundary = false;
-
+#if 0 // currently unused
+ bool lastrow = (!row->next() || row->next()->par() != row->par());
+ bool rtl = (lastrow)
+ ? row->par()->isRightToLeftPar(bview->buffer()->params)
+ : false;
+#endif
+
if (row->pos() > last) // Row is empty?
c = row->pos();
- else if (vc == row->pos() ||
- (row->par()->table
- && vc <= last && row->par()->IsNewline(vc-1)) ) {
+#warning This is wrong, please have a look Dekel (Jug)
+#if 0
+ else if (lastrow &&
+ ( (rtl && vc == row->pos()&& x < tmpx - 5) ||
+ (!rtl && vc == last + 1 && x > tmpx + 5) ))
+ c = last + 1;
+#endif
+ else if (vc == row->pos()) {
c = vis2log(vc);
if (bidi_level(c) % 2 == 1)
++c;
}
}
- if (!row->par()->table && row->pos() <= last && c > last
+ if (row->pos() <= last && c > last
&& row->par()->IsNewline(last)) {
if (bidi_level(last) % 2 == 0)
tmpx -= SingleWidth(bview, row->par(), last);
LyXParagraph * tmppar;
-#ifndef NEW_TABULAR
- if (sel_start_cursor.par()->table || sel_end_cursor.par()->table){
- WriteAlert(_("Impossible operation"), _("Cannot cut table."), _("Sorry."));
- return;
- }
-#endif
/* a test to make sure there is not already a footnote
* in the selection. */
// returns pointer to a specified row
Row * LyXText::GetRow(LyXParagraph * par,
- LyXParagraph::size_type pos, long & y) const
+ LyXParagraph::size_type pos, int & y) const
{
Row * tmprow = firstrow;
y = 0;
projects / lyx.git / blobdiff