Quellcode-Bibliothek

^© Kompilation durch diese Firma

[Weder Korrektheit noch Funktionsfähigkeit der Software werden zugesichert.]

Datei: text2.C Sprache: C

Original von: Lyx^©

/* This file is part of
* ======================================================
*
*           LyX, The Document Processor
*
*     Copyright (C) 1995 Matthias Ettrich
*           Copyright (C) 1995-1998 The LyX Team.
*
*======================================================*/

#include <config.h>

#include <ctype.h>
#include FORMS_H_LOCATION

#ifdef __GNUG__
#pragma implementation "lyxtext.h"
#pragma implementation "undo.h"
#endif

#include "LString.h"
#include "lyxparagraph.h"
#include "inseterror.h"
#include "layout.h"
#include "LyXView.h"
#include "textutils.h"
#include "lyx_cb.h"
#include "undo.h"
#include "minibuffer.h"
#include "buffer.h"
#include "bufferparams.h"
#include "lyx_gui_misc.h"
#include "lyxtext.h"
#include "gettext.h"

// $Id: text2.C,v 1.5 1998/10/21 08:50:00 lasgoutt Exp $

#if !defined(lint) && !defined(WITH_WARNINGS)
static char vcid[] = "$Id: text2.C,v 1.5 1998/10/21 08:50:00 lasgoutt Exp $";
#endif /* lint */

extern MiniBuffer *minibuffer;

// Constructor
LyXText::LyXText(int pw, Buffer *p)
{
firstrow = NULL;
lastrow = NULL;
currentrow = NULL;
currentrow_y = 0;
paperwidth = pw;
parameters = &p->params;
params = p;
number_of_rows = 0;
refresh_y= 0;
status = LyXText::UNCHANGED;
LyXParagraph *par = p->paragraph;
current_font = GetFont(par, 0);

height = 0;

while (par) {
  InsertParagraph(par, lastrow);
  par = par->Next();
}
/* set cursor at the very top position */
selection = true;         /* these setting is necessary
* because of the delete-empty-
* paragraph mechanism in
* SetCursor */
SetCursor(firstrow->par, 0);
sel_cursor = cursor;
selection = false;
mark_set = false;

/* no rebreak necessary */
need_break_row = NULL;

undo_finished = true;
undo_frozen = false;

// Default layouttype for copy environment type
copylayouttype = 0;
}

// Destructor
LyXText::~LyXText()
{
// Delete all rows, this does not touch the paragraphs!
Row *tmprow = firstrow;
while (firstrow) {
  tmprow = firstrow->next;
  delete firstrow;
  firstrow = tmprow;
}
}

// Gets the fully instantiated font at a given position in a paragraph
// Basically the same routine as LyXParagraph::getFont() in paragraph.C.
// The difference is that this one is used for displaying, and thus we
// are allowed to make cosmetic improvements. For instance make footnotes
// smaller. (Asger)
// If position is -1, we get the layout font of the paragraph.
// If position is -2, we get the font of the manual label of the paragraph.
LyXFont LyXText::GetFont(LyXParagraph* par, int pos)
{
LyXLayout *layout =
  lyxstyle.Style(parameters->textclass, par->GetLayout());

char par_depth = par->GetDepth();
// We specialize the 95% common case:
if (par->footnoteflag == LyXParagraph::NO_FOOTNOTE && !par_depth) {
  if (pos >= 0){
   // 95% goes here
   if (layout->labeltype == LABEL_MANUAL
       && pos < BeginningOfMainBody(par)) {
    // 1% goes here
    return par->GetFontSettings(pos).
      realize(layout->reslabelfont);
   } else
    return par->GetFontSettings(pos).
      realize(layout->resfont);
  } else {
   // 5% goes here.
   // process layoutfont for pos == -1 and labelfont for pos < -1
   if (pos == -1)
    return layout->resfont;
   else
    return layout->reslabelfont;
  }
}

// The uncommon case need not be optimized as much

LyXFont layoutfont, tmpfont;

if (pos >= 0){
  // 95% goes here
  if (pos < BeginningOfMainBody(par)) {
   // 1% goes here
   layoutfont = layout->labelfont;
  } else {
   // 99% goes here
   layoutfont = layout->font;
  }
  tmpfont = par->GetFontSettings(pos);
  tmpfont.realize(layoutfont);
} else{
  // 5% goes here.
  // process layoutfont for pos == -1 and labelfont for pos < -1
  if (pos == -1)
   tmpfont = layout->font;
  else
   tmpfont = layout->labelfont;
}

// Resolve against environment font information
//if (par->GetDepth()){ // already in while condition
  while (par && par_depth && !tmpfont.resolved()) {
   par = par->DepthHook(par_depth - 1);
   if (par) {
    tmpfont.realize(lyxstyle.
      Style(parameters->textclass,
            par->GetLayout())->font);
    par_depth = par->GetDepth();
   }
  }
//}

tmpfont.realize(lyxstyle.TextClass(parameters->textclass)->defaultfont);

// Cosmetic improvement: If this is an open footnote, make the font
// smaller.
if (par->footnoteflag == LyXParagraph::OPEN_FOOTNOTE
     && par->footnotekind == LyXParagraph::FOOTNOTE) {
  tmpfont.decSize();
}

return tmpfont;
}

void LyXText::SetCharFont(LyXParagraph *par, int pos, LyXFont font)
{
/* let the insets convert their font */
if (par->GetChar(pos) == LYX_META_INSET) {
  if (par->GetInset(pos))
   font = par->GetInset(pos)->ConvertFont(font);
}

LyXLayout *layout = lyxstyle.Style(parameters->textclass,
        par->GetLayout());

// Get concrete layout font to reduce against
LyXFont layoutfont;

if (pos < BeginningOfMainBody(par))
  layoutfont = layout->labelfont;
else
  layoutfont = layout->font;

// Realize against environment font information
if (par->GetDepth()){
  LyXParagraph * tp = par;
  while (!layoutfont.resolved() && tp && tp->GetDepth()) {
   tp = tp->DepthHook(tp->GetDepth()-1);
   if (tp)
    layoutfont.realize(lyxstyle.
      Style(parameters->textclass,
            tp->GetLayout())->font);
  }
}

layoutfont.realize(lyxstyle.TextClass(parameters->textclass)->defaultfont);

if (par->footnoteflag == LyXParagraph::OPEN_FOOTNOTE
     && par->footnotekind == LyXParagraph::FOOTNOTE) {
  layoutfont.decSize();
}

// Now, reduce font against full layout font
font.reduce(layoutfont);

par->SetFont(pos, font);
}

/* inserts a new row behind the specified row, increments
* the touched counters */
void LyXText::InsertRow(Row *row, LyXParagraph *par, int pos)
{
Row *tmprow = new Row;
if (!row) {
  tmprow->previous = NULL;
  tmprow->next = firstrow;
  firstrow = tmprow;
}
else {
  tmprow->previous = row;
  tmprow->next = row->next;
  row->next = tmprow;
}

if (tmprow->next)
  tmprow->next->previous = tmprow;

if (tmprow->previous)
  tmprow->previous->next = tmprow;


tmprow->par = par;
tmprow->pos = pos;

if (row == lastrow)
  lastrow = tmprow;
number_of_rows++;          /* one more row  */
}

/* removes the row and reset the touched counters */
void LyXText::RemoveRow(Row *row)
{
/* this must not happen before the currentrow for clear reasons.
   so the trick is just to set the current row onto the previous
   row of this row */
long unused_y;
GetRow(row->par, row->pos, unused_y);
currentrow = currentrow->previous;
if (currentrow)
  currentrow_y -= currentrow->height;
else
  currentrow_y = 0;

if (row->next)
  row->next->previous = row->previous;
if (!row->previous) {
  firstrow = row->next;
}
else  {
  row->previous->next = row->next;
}
if (row == lastrow)
  lastrow = row->previous;

height -= row->height;        /* the text becomes smaller  */

delete row;
number_of_rows--;          /* one row less  */
}

/* remove all following rows of the paragraph of the specified row. */
void LyXText::RemoveParagraph(Row *row)
{
LyXParagraph *tmppar;
Row *tmprow;

tmppar = row->par;
row = row->next;

while (row && row->par == tmppar) {
  tmprow = row->next;
  RemoveRow(row);
  row = tmprow;
}
}


/* insert the specified paragraph behind the specified row */
void LyXText::InsertParagraph(LyXParagraph *par, Row *row)
{
InsertRow(row, par, 0);        /* insert a new row, starting
* at postition 0 */

SetCounter(par);         /* set the counters  */

/* and now append the whole paragraph behind the new row */
if (!row) {
  firstrow->height = 0;
  AppendParagraph(firstrow);
}
else {
  row->next->height = 0;
  AppendParagraph(row->next);
}
}


void LyXText::ToggleFootnote()
{
LyXParagraph *par;

par = cursor.par->ParFromPos(cursor.pos);
if (par->next && par->next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE){
  OpenFootnote();
  minibuffer->Set(_("Opened float"));
}
else {
  minibuffer->Set(_("Closed float"));
  CloseFootnote();
}
}

void LyXText::OpenStuff()
{
      if (cursor.pos == 0 && cursor.par->bibkey){
  cursor.par->bibkey->Edit(0,0);
}
else if (cursor.pos < cursor.par->Last()
   && cursor.par->GetChar(cursor.pos) == LYX_META_INSET
   && cursor.par->GetInset(cursor.pos)->Editable()) {
  minibuffer->Set(cursor.par->GetInset(cursor.pos)->EditMessage());
  if (cursor.par->GetInset(cursor.pos)->Editable() != 2)
   SetCursorParUndo();
  cursor.par->GetInset(cursor.pos)->Edit(0,0);
}
else {
  ToggleFootnote();
}
}

void LyXText::CloseFootnote()
{
LyXParagraph *par, *endpar,*tmppar;
Row *row;

par = cursor.par->ParFromPos(cursor.pos);

/* if the cursor is not in an open footnote, or
* there is no open footnote in this paragraph, just return. */
if (cursor.par->footnoteflag != LyXParagraph::OPEN_FOOTNOTE) {

  if (!par->next
      || par->next->footnoteflag != LyXParagraph::OPEN_FOOTNOTE) {
   minibuffer->Set(_("Nothing to do"));
   return;
  }

  /* ok, move the cursor right before the footnote */

  /* just a little faster than using CursorRight() */
  for (cursor.pos=0; cursor.par->ParFromPos(cursor.pos)!=par; cursor.pos++);
  /* now the cursor is at the beginning of the physical par */
  SetCursor(cursor.par, cursor.pos + cursor.par->ParFromPos(cursor.pos)->last);
}
else  {
  /* we are in a footnote, so let us move at the beginning */
  /*      while (cursor.par->footnoteflag == LyXParagraph::OPEN_FOOTNOTE)
cursor.par = cursor.par->Previous();

SetCursor(cursor.par, cursor.par->Last()); */
  /* this is just faster than using just CursorLeft() */

  tmppar = cursor.par;
  while (tmppar->footnoteflag == LyXParagraph::OPEN_FOOTNOTE) {
   /* just a little bit faster than movin the cursor */
   tmppar = tmppar->Previous();
  }
  SetCursor(tmppar, tmppar->Last());
}

/* the cursor must be exactly before the footnote */
par = cursor.par->ParFromPos(cursor.pos);

status = LyXText::NEED_MORE_REFRESH;
refresh_row = cursor.row;
refresh_y = cursor.y - cursor.row->baseline;

tmppar = cursor.par;
endpar = par->NextAfterFootnote()->Next();
row = cursor.row;

tmppar->CloseFootnote(cursor.pos);

/* set the dimensions of the cursor row */
/* row->fill = Fill(row, paperwidth);
   SetHeightOfRow(row);  */

while (tmppar != endpar) {
  RemoveRow(row->next);
  if (row->next)
   tmppar = row->next->par;
  else
   tmppar = NULL;
}

AppendParagraph(cursor.row);

SetCursor(cursor.par, cursor.pos);
sel_cursor = cursor;

/* just necessary */
if (cursor.row->next)
  SetHeightOfRow(cursor.row->next);
}

/* used in setlayout */
// Asger is not sure we want to do this...
void LyXText::MakeFontEntriesLayoutSpecific(LyXParagraph *par)
{
LyXFont layoutfont, tmpfont;

int pos;

LyXLayout* layout = lyxstyle.Style(parameters->textclass, par->GetLayout());

for (pos = 0; pos < par->Last(); pos++) {
  if (pos < BeginningOfMainBody(par))
   layoutfont = layout->labelfont;
  else
   layoutfont = layout->font;

  tmpfont = par->GetFontSettings(pos);
  tmpfont.reduce(layoutfont);
  par->SetFont(pos, tmpfont);
}
}

/* set layout over selection and make a total rebreak of those paragraphs */
void  LyXText::SetLayout(char layout)
{
LyXCursor tmpcursor;

/* if there is no selection just set the layout of the current paragraph  */
if (!selection) {
  sel_start_cursor = cursor;       /* dummy selection  */
  sel_end_cursor = cursor;
}

LyXParagraph *endpar = sel_end_cursor.par->LastPhysicalPar()->Next();
LyXParagraph *undoendpar = endpar;

if (endpar && endpar->GetDepth()) {
  while (endpar && endpar->GetDepth()) {
   //endpar->depth = 0;
   endpar = endpar->LastPhysicalPar()->Next();
   undoendpar = endpar;
  }
}
else if (endpar) {
  endpar = endpar->Next();        /* because of parindents etc.  */
}

SetUndo(Undo::EDIT,
  sel_start_cursor.par->ParFromPos(sel_start_cursor.pos)->previous,
  undoendpar);

tmpcursor = cursor;         /* store the current cursor  */

/* ok we have a selection. This is always between sel_start_cursor
* and sel_end cursor */
cursor = sel_start_cursor;

LyXLayout * lyxlayout = lyxstyle.Style(parameters->textclass, layout);

while (cursor.par != sel_end_cursor.par) {
  if (cursor.par->footnoteflag ==
      sel_start_cursor.par->footnoteflag) {
   cursor.par->SetLayout(layout);
   MakeFontEntriesLayoutSpecific(cursor.par);
   LyXParagraph* fppar = cursor.par->FirstPhysicalPar();
   fppar->added_space_top = lyxlayout->fill_top ?
    VSpace::VFILL : VSpace::NONE;
   fppar->added_space_bottom = lyxlayout->fill_bottom ?
    VSpace::VFILL : VSpace::NONE;
   if (lyxlayout->margintype == MARGIN_MANUAL)
    cursor.par->SetLabelWidthString(lyxlayout->labelstring);
   if (lyxlayout->labeltype != LABEL_BIBLIO
       && fppar->bibkey) {
    delete fppar->bibkey;
    fppar->bibkey = 0;
   }
  }
  cursor.par = cursor.par->Next();
}
if (cursor.par->footnoteflag ==
     sel_start_cursor.par->footnoteflag) {
  cursor.par->SetLayout(layout);
  MakeFontEntriesLayoutSpecific(cursor.par);
  LyXParagraph* fppar = cursor.par->FirstPhysicalPar();
  fppar->added_space_top = lyxlayout->fill_top ?
   VSpace::VFILL : VSpace::NONE;
  fppar->added_space_bottom = lyxlayout->fill_bottom ?
   VSpace::VFILL : VSpace::NONE;
  if (lyxlayout->margintype == MARGIN_MANUAL)
   cursor.par->SetLabelWidthString(lyxlayout->labelstring);
  if (lyxlayout->labeltype != LABEL_BIBLIO
      && fppar->bibkey) {
   delete fppar->bibkey;
   fppar->bibkey = 0;
  }
}

RedoParagraphs(sel_start_cursor, endpar);

/* we have to reset the selection, because the
* geometry could have changed */
SetCursor(sel_start_cursor.par, sel_start_cursor.pos);
sel_cursor = cursor;
SetCursor(sel_end_cursor.par, sel_end_cursor.pos);
UpdateCounters(cursor.row);
ClearSelection();
SetSelection();
SetCursor(tmpcursor.par, tmpcursor.pos);
}

/* increment depth over selection and
* make a total rebreak of those paragraphs */
void  LyXText::IncDepth()
{
// If there is no selection, just use the current paragraph
if (!selection) {
  sel_start_cursor = cursor;       /* dummy selection */
  sel_end_cursor = cursor;
}

// We end at the next paragraph with depth 0
LyXParagraph *endpar = sel_end_cursor.par->LastPhysicalPar()->Next();
LyXParagraph *undoendpar = endpar;

if (endpar && endpar->GetDepth()) {
  while (endpar && endpar->GetDepth()) {
   endpar = endpar->LastPhysicalPar()->Next();
   undoendpar = endpar;
  }
}
else if (endpar) {
  endpar = endpar->Next();        /* because of parindents etc.  */
}

SetUndo(Undo::EDIT,
  sel_start_cursor.par->ParFromPos(sel_start_cursor.pos)->previous,
  undoendpar);

LyXCursor tmpcursor = cursor;      /* store the current cursor  */

/* ok we have a selection. This is always between sel_start_cursor
* and sel_end cursor */
cursor = sel_start_cursor;

bool anything_changed = false;

while (true) {
  // NOTE: you can't change the depth of a bibliography entry
  if (cursor.par->footnoteflag ==
      sel_start_cursor.par->footnoteflag
      && lyxstyle.Style(parameters->textclass,
          cursor.par->GetLayout()
         )->labeltype != LABEL_BIBLIO) {
   LyXParagraph * prev = cursor.par->FirstPhysicalPar()->Previous();
   if (prev
       && (prev->GetDepth() - cursor.par->GetDepth() > 0
    || (prev->GetDepth() == cursor.par->GetDepth()
        && lyxstyle.Style(parameters->textclass,
            prev->GetLayout())->isEnvironment()))) {
    cursor.par->FirstPhysicalPar()->depth++;
    anything_changed = true;
    }
  }
  if (cursor.par == sel_end_cursor.par)
                       break;
  cursor.par = cursor.par->Next();
}

/* if nothing changed set all depth to 0 */
if (!anything_changed) {
  cursor = sel_start_cursor;
  while (cursor.par != sel_end_cursor.par) {
   cursor.par->FirstPhysicalPar()->depth = 0;
   cursor.par = cursor.par->Next();
  }
  if (cursor.par->footnoteflag == sel_start_cursor.par->footnoteflag)
   cursor.par->FirstPhysicalPar()->depth = 0;
}

RedoParagraphs(sel_start_cursor, endpar);

/* we have to reset the selection, because the
* geometry could have changed */
SetCursor(sel_start_cursor.par, sel_start_cursor.pos);
sel_cursor = cursor;
SetCursor(sel_end_cursor.par, sel_end_cursor.pos);
UpdateCounters(cursor.row);
ClearSelection();
SetSelection();
SetCursor(tmpcursor.par, tmpcursor.pos);
}

/* decrement depth over selection and
* make a total rebreak of those paragraphs */
void  LyXText::DecDepth()
{
/* if there is no selection just set the layout of the current paragraph  */
if (!selection) {
  sel_start_cursor = cursor;       /* dummy selection  */
  sel_end_cursor = cursor;
}

LyXParagraph *endpar = sel_end_cursor.par->LastPhysicalPar()->Next();
LyXParagraph *undoendpar = endpar;

if (endpar && endpar->GetDepth()) {
  while (endpar && endpar->GetDepth()) {
   endpar = endpar->LastPhysicalPar()->Next();
   undoendpar = endpar;
  }
}
else if (endpar) {
  endpar = endpar->Next();        /* because of parindents etc.  */
}

SetUndo(Undo::EDIT,
  sel_start_cursor.par->ParFromPos(sel_start_cursor.pos)->previous,
  undoendpar);

LyXCursor tmpcursor = cursor;         /* store the current cursor  */

/* ok we have a selection. This is always between sel_start_cursor
* and sel_end cursor */
cursor = sel_start_cursor;

while (true) {
  if (cursor.par->footnoteflag ==
      sel_start_cursor.par->footnoteflag) {
   if (cursor.par->FirstPhysicalPar()->depth)
    cursor.par->FirstPhysicalPar()->depth--;
  }
  if (cursor.par == sel_end_cursor.par)
   break;
  cursor.par = cursor.par->Next();
}

RedoParagraphs(sel_start_cursor, endpar);

/* we have to reset the selection, because the
* geometry could have changed */
SetCursor(sel_start_cursor.par, sel_start_cursor.pos);
sel_cursor = cursor;
SetCursor(sel_end_cursor.par, sel_end_cursor.pos);
UpdateCounters(cursor.row);
ClearSelection();
SetSelection();
SetCursor(tmpcursor.par, tmpcursor.pos);
}

/* set font over selection and make a total rebreak of those paragraphs */
void  LyXText::SetFont(LyXFont font, bool toggleall)
{
/* if there is no selection just set the current_font */
if (!selection) {
  // Determine basis font
  LyXFont layoutfont;
  if (cursor.pos < BeginningOfMainBody(cursor.par))
   layoutfont = GetFont(cursor.par, -2);
  else
   layoutfont = GetFont(cursor.par, -1);

  // Update current font
  real_current_font.update(font,toggleall);

  // Reduce to implicit settings
  current_font = real_current_font;
  current_font.reduce(layoutfont);
  // And resolve it completely
  real_current_font.realize(layoutfont);
  return;
}

LyXCursor tmpcursor = cursor;         /* store the current cursor  */

/* ok we have a selection. This is always between sel_start_cursor
* and sel_end cursor */

SetUndo(Undo::EDIT,
  sel_start_cursor.par->ParFromPos(sel_start_cursor.pos)->previous,
  sel_end_cursor.par->ParFromPos(sel_end_cursor.pos)->next);
cursor = sel_start_cursor;
while (cursor.par != sel_end_cursor.par ||
        (cursor.par->footnoteflag == sel_start_cursor.par->footnoteflag
  && cursor.pos < sel_end_cursor.pos))
{
  if (cursor.pos < cursor.par->Last()
      && cursor.par->footnoteflag
      == sel_start_cursor.par->footnoteflag) {   /* an open footnote
* should behave
* like a closed */
   LyXFont newfont = GetFont(cursor.par,cursor.pos);
   newfont.update(font,toggleall);
   SetCharFont(cursor.par, cursor.pos, newfont);
   cursor.pos++;
  } else {
   cursor.pos = 0;
   cursor.par = cursor.par->Next();
  }
}

RedoParagraphs(sel_start_cursor, sel_end_cursor.par->Next());

/* we have to reset the selection, because the
* geometry could have changed */
SetCursor(sel_start_cursor.par, sel_start_cursor.pos);
sel_cursor = cursor;
SetCursor(sel_end_cursor.par, sel_end_cursor.pos);
ClearSelection();
SetSelection();
SetCursor(tmpcursor.par, tmpcursor.pos);
}

void LyXText::RedoHeightOfParagraph(LyXCursor cursor)
{
Row *tmprow;
LyXParagraph *first_phys_par;
long y;

tmprow = cursor.row;

y = cursor.y - tmprow->baseline;
SetHeightOfRow(tmprow);
first_phys_par = tmprow->par->FirstPhysicalPar();
/* find the first row of the paragraph */
if (first_phys_par != tmprow->par)
  while (tmprow->previous && tmprow->previous->par != first_phys_par)  {
   tmprow = tmprow->previous;
   y -= tmprow->height;
   SetHeightOfRow(tmprow);
  }
while (tmprow->previous && tmprow->previous->par == first_phys_par)  {
  tmprow = tmprow->previous;
  y -= tmprow->height;
  SetHeightOfRow(tmprow);
}

/* we can set the refreshing parameters now */
status = LyXText::NEED_MORE_REFRESH;
refresh_y = y;
refresh_row = tmprow;
SetCursor(cursor.par, cursor.pos);
}

void LyXText::RedoDrawingOfParagraph(LyXCursor cursor)
{
Row *tmprow;
LyXParagraph *first_phys_par;
long y;

tmprow = cursor.row;

y = cursor.y - tmprow->baseline;
SetHeightOfRow(tmprow);
first_phys_par = tmprow->par->FirstPhysicalPar();
/* find the first row of the paragraph */
if (first_phys_par != tmprow->par)
  while (tmprow->previous && tmprow->previous->par != first_phys_par)  {
   tmprow = tmprow->previous;
   y -= tmprow->height;
  }
while (tmprow->previous && tmprow->previous->par == first_phys_par)  {
  tmprow = tmprow->previous;
  y -= tmprow->height;

}

/* we can set the refreshing parameters now */
if (status == LyXText::UNCHANGED || y < refresh_y) {
  refresh_y = y;
  refresh_row = tmprow;
}
status = LyXText::NEED_MORE_REFRESH;
SetCursor(cursor.par, cursor.pos);
}

/* deletes and inserts again all paragaphs between the cursor
* and the specified par
* This function is needed after SetLayout and SetFont etc. */
void LyXText::RedoParagraphs(LyXCursor cursor, LyXParagraph *endpar)
{
Row *tmprow, *tmprow2;
LyXParagraph *tmppar, *first_phys_par;
long y;

tmprow = cursor.row;

y = cursor.y - tmprow->baseline;

if (!tmprow->previous){
  first_phys_par = FirstParagraph();   // a trick/hack for UNDO
}
else {
  first_phys_par = tmprow->par->FirstPhysicalPar();
  /* find the first row of the paragraph */
  if (first_phys_par != tmprow->par)
   while (tmprow->previous && tmprow->previous->par != first_phys_par)  {
    tmprow = tmprow->previous;
    y -= tmprow->height;
   }
  while (tmprow->previous && tmprow->previous->par == first_phys_par)  {
   tmprow = tmprow->previous;
   y -= tmprow->height;
  }
}

/* we can set the refreshing parameters now */
status = LyXText::NEED_MORE_REFRESH;
refresh_y = y;
refresh_row = tmprow->previous;        /* the real refresh row will
* be deleted, so I store
* the previous here */
/* remove it */
if (tmprow->next)
  tmppar = tmprow->next->par;
else
  tmppar = NULL;
while (tmppar != endpar) {
  RemoveRow(tmprow->next);
  if (tmprow->next)
   tmppar = tmprow->next->par;
  else
   tmppar = NULL;
}

/* remove the first one */
tmprow2 = tmprow;         /* this is because tmprow->previous
* can be NULL */
tmprow = tmprow->previous;
RemoveRow(tmprow2);

tmppar = first_phys_par;

do {
  if (tmppar) {
   InsertParagraph(tmppar, tmprow);
   if (!tmprow)
    tmprow = firstrow;
   while (tmprow->next && tmprow->next->par == tmppar)
    tmprow = tmprow->next;
   tmppar = tmppar->Next();

  }
}
while (tmppar != endpar);

/* this is because of layout changes */
if (refresh_row) {
  refresh_y -= refresh_row->height;
  SetHeightOfRow(refresh_row);
}
else {
  refresh_row = firstrow;
  refresh_y = 0;
  SetHeightOfRow(refresh_row);
}

if (tmprow && tmprow->next)
  SetHeightOfRow(tmprow->next);

/* restore the correct refresh row  */
/*    if (refresh_row)
      refresh_row = refresh_row->next;
      else
      refresh_row = firstrow;*/
}

int LyXText::FullRebreak()
{
if (need_break_row) {
  BreakAgain(need_break_row);
  need_break_row = NULL;
  return 1;
}
return 0;
}

/* important for the screen */

/* the cursor set functions have a special mechanism. When they
* realize, that you left an empty paragraph, they will delete it.
* They also delet the corresponding row */

/* need the selection cursor: */
void LyXText::SetSelection()
{
if (!selection) {
  last_sel_cursor = sel_cursor;
  sel_start_cursor = sel_cursor;
  sel_end_cursor = sel_cursor;
}

selection = True;

/* first the toggling area */
if (cursor.y < last_sel_cursor.y ||
     (cursor.y == last_sel_cursor.y && cursor.x < last_sel_cursor.x)) {
  toggle_end_cursor = last_sel_cursor;
  toggle_cursor = cursor;
}
else {
  toggle_end_cursor = cursor;
  toggle_cursor = last_sel_cursor;
}

last_sel_cursor = cursor;

/* and now the whole selection */

if (sel_cursor.y < cursor.y ||
     (sel_cursor.y == cursor.y && sel_cursor.x < cursor.x)) {
  sel_end_cursor = cursor;
  sel_start_cursor = sel_cursor;
}
else {
  sel_end_cursor = sel_cursor;
  sel_start_cursor = cursor;
}

/* a selection with no contents is not a selection */
if (sel_start_cursor.x == sel_end_cursor.x &&
     sel_start_cursor.y == sel_end_cursor.y)
  selection = false;
}

void LyXText::ClearSelection()
{
selection = false;
mark_set = false;
}

void  LyXText::CursorHome()
{
SetCursor(cursor.par, cursor.row->pos);
}

void  LyXText::CursorEnd()
{
if (!cursor.row->next || cursor.row->next->par != cursor.row->par)
  SetCursor(cursor.par, RowLast(cursor.row) + 1);
else {
  if (cursor.par->Last() &&
      (cursor.par->GetChar(RowLast(cursor.row)) == ' '
       || cursor.par->IsNewline(RowLast(cursor.row))))
   SetCursor(cursor.par, RowLast(cursor.row));
  else
   SetCursor(cursor.par, RowLast(cursor.row) + 1);
}
        if (cursor.par->table) {
                int cell = NumberOfCell(cursor.par, cursor.pos);
                if (cursor.par->table->RowHasContRow(cell) &&
                    cursor.par->table->CellHasContRow(cell)<0) {
                        if (!cursor.row->next || cursor.row->next->par != cursor.row->par)
                                SetCursor(cursor.par, RowLast(cursor.row) + 1);
                        else {
                                if (cursor.par->Last() &&
                                    (cursor.par->GetChar(RowLast(cursor.row)) == ' '
                                     || cursor.par->IsNewline(RowLast(cursor.row))))
                                        SetCursor(cursor.par, RowLast(cursor.row));
                                else
                                        SetCursor(cursor.par, RowLast(cursor.row) + 1);
                        }
                }
        }
}

void  LyXText::CursorTop()
{
while (cursor.par->Previous())
  cursor.par = cursor.par->Previous();
SetCursor(cursor.par, 0);
}

void  LyXText::CursorBottom()
{
while (cursor.par->Next())
  cursor.par = cursor.par->Next();
SetCursor(cursor.par, cursor.par->Last());
}


/* returns a pointer to the row near the specified y-coordinate
* (relative to the whole text). y is set to the real beginning
* of this row */
Row* LyXText::GetRowNearY(long& y)
{
Row* tmprow;
long tmpy;

if (currentrow){
  tmprow = currentrow;
  tmpy = currentrow_y;
}
else {
  tmprow = firstrow;
  tmpy = 0;
}

if (tmpy<=y)
  while (tmprow->next && tmpy + tmprow->height <= y) {
   tmpy += tmprow->height;
   tmprow = tmprow->next;
  }
else
  while (tmprow->previous && tmpy > y) {
   tmprow = tmprow->previous;
   tmpy -= tmprow->height;
  }

currentrow = tmprow;
currentrow_y = tmpy;

y = tmpy;          /* return the real y  */
return tmprow;
}


void LyXText::ToggleFree(LyXFont font, bool toggleall)
{
// If the mask is completely neutral, tell user
if (font == LyXFont(LyXFont::ALL_IGNORE)){
  // Could only happen with user style
  minibuffer->Set(_("No font change defined. Use Character under"
      " the Layout menu to define font change."));
  return;
}

// Try implicit word selection
LyXCursor resetCursor = cursor;
int implicitSelection = SelectWordWhenUnderCursor();

// Set font
SetFont(font,toggleall);
//minibuffer->Set(_("Font style changed"));

/* Implicit selections are cleared afterwards and cursor is set to the
   original position. */
if (implicitSelection) {
  ClearSelection();
  cursor = resetCursor;
  SetCursor( cursor.par, cursor.pos );
  sel_cursor = cursor;
}
}

int LyXText::BeginningOfMainBody(LyXParagraph *par)
{
if (lyxstyle.Style(parameters->textclass, par->GetLayout())->labeltype != LABEL_MANUAL)
  return 0;
else
  return par->BeginningOfMainBody();
}

/* if there is a selection, reset every environment you can find
* in the selection, otherwise just the environment you are in */
void LyXText::MeltFootnoteEnvironment()
{
LyXParagraph *tmppar, *firsttmppar;

ClearSelection();

/* is is only allowed, if the cursor is IN an open footnote.
* Otherwise it is too dangerous */
if (cursor.par->footnoteflag != LyXParagraph::OPEN_FOOTNOTE)
  return;

SetUndo(Undo::FINISH,
  cursor.par->PreviousBeforeFootnote()->previous,
  cursor.par->NextAfterFootnote()->next);

/* ok, move to the beginning of the footnote. */
while (cursor.par->footnoteflag == LyXParagraph::OPEN_FOOTNOTE)
  cursor.par = cursor.par->Previous();

SetCursor(cursor.par, cursor.par->Last());
/* this is just faster than using CursorLeft(); */

firsttmppar = cursor.par->ParFromPos(cursor.pos);
tmppar = firsttmppar;
/* tmppar is now the paragraph right before the footnote */

char first_footnote_par_is_not_empty = tmppar->next->last;

while (tmppar->next && tmppar->next->footnoteflag == LyXParagraph::OPEN_FOOTNOTE) {
  tmppar = tmppar->next;        /* I use next instead of Next(),
* because there cannot be any
* footnotes in a footnote
* environment */
  tmppar->footnoteflag = LyXParagraph::NO_FOOTNOTE;

  /* remember the captions and empty paragraphs */
  if ((lyxstyle.Style(parameters->textclass,
        tmppar->GetLayout())->labeltype == LABEL_SENSITIVE)
      || !tmppar->Last())
   tmppar->SetLayout(0);
}

/* now we will paste the ex-footnote, if the layouts allow it */
/* first restore the layout of the paragraph right behind the footnote*/
if (tmppar->next)
  tmppar->next->MakeSameLayout(cursor.par);

/* first the end */
if ((!tmppar->GetLayout() && !tmppar->table)
     || (tmppar->Next() && (!tmppar->Next()->Last()
       || tmppar->Next()->HasSameLayout(tmppar)))) {
  if (tmppar->Next()->Last() && tmppar->Next()->IsLineSeparator(0))
   tmppar->Next()->Erase(0);
  tmppar->PasteParagraph();
}

tmppar = tmppar->Next();        /* make shure tmppar cannot be touched
* by the pasting of the beginning */

/* then the beginning */
/* if there is no space between the text and the footnote, so we insert
* a blank
* (only if the previous par and the footnotepar are not empty!) */
if ((!firsttmppar->next->GetLayout() && !firsttmppar->next->table)
     || firsttmppar->HasSameLayout(firsttmppar->next)) {
  if (firsttmppar->last
      && !firsttmppar->IsSeparator(firsttmppar->last - 1)
      && first_footnote_par_is_not_empty) {
   firsttmppar->next->InsertChar(0, ' ');
  }
  firsttmppar->PasteParagraph();
}

/* now redo the paragaphs */
RedoParagraphs(cursor, tmppar);

SetCursor(cursor.par, cursor.pos);

/* sometimes it can happen, that there is a counter change */
Row *row = cursor.row;
while (row->next && row->par != tmppar && row->next->par != tmppar)
  row = row->next;
UpdateCounters(row);


ClearSelection();
}

/* the DTP switches for paragraphs. LyX will store them in the
* first physicla paragraph. When a paragraph is broken, the top settings
* rest, the bottom settings are given to the new one. So I can make shure,
* they do not duplicate themself and you cannnot make dirty things with
* them!  */

void LyXText::SetParagraph(bool line_top, bool line_bottom,
      bool pagebreak_top, bool pagebreak_bottom,
      VSpace space_top, VSpace space_bottom,
      char align,
      LString labelwidthstring,
      bool noindent)
{
LyXCursor tmpcursor;
tmpcursor = cursor;
LyXParagraph *tmppar;
if (!selection) {
  sel_start_cursor = cursor;
  sel_end_cursor = cursor;
}

// make sure that the depth behind the selection are restored, too
LyXParagraph *endpar = sel_end_cursor.par->LastPhysicalPar()->Next();
LyXParagraph *undoendpar = endpar;

if (endpar && endpar->GetDepth()) {
  while (endpar && endpar->GetDepth()) {
   endpar = endpar->LastPhysicalPar()->Next();
   undoendpar = endpar;
  }
}
else if (endpar) {
  endpar = endpar->Next(); /* because of parindents etc.  */
}

SetUndo(Undo::EDIT,
  sel_start_cursor.par->ParFromPos(sel_start_cursor.pos)->previous,
  undoendpar);

tmppar = sel_end_cursor.par;
while (tmppar != sel_start_cursor.par->FirstPhysicalPar()->Previous())
  {
   SetCursor(tmppar->FirstPhysicalPar(), 0);
   status = LyXText::NEED_MORE_REFRESH;
   refresh_row = cursor.row;
   refresh_y = cursor.y - cursor.row->baseline;
   if (cursor.par->footnoteflag ==
       sel_start_cursor.par->footnoteflag) {
    cursor.par->line_top = line_top;
    cursor.par->line_bottom = line_bottom;
    cursor.par->pagebreak_top = pagebreak_top;
    cursor.par->pagebreak_bottom = pagebreak_bottom;
    cursor.par->added_space_top = space_top;
    cursor.par->added_space_bottom = space_bottom;
    /* does the layout allow the new alignment? */
    if (align == LYX_ALIGN_LAYOUT)
     align = lyxstyle.Style(parameters->textclass, cursor.par->GetLayout())->align;
    if (align & lyxstyle.Style(parameters->textclass, cursor.par->GetLayout())->alignpossible) {
     if (align == lyxstyle.Style(parameters->textclass, cursor.par->GetLayout())->align)
      cursor.par->align = LYX_ALIGN_LAYOUT;
     else
      cursor.par->align = align;
    }
    cursor.par->SetLabelWidthString(labelwidthstring);
    cursor.par->noindent = noindent;
   }

   /*
   tmprow = cursor.row;
   while (tmprow->next && tmprow->next->par->previous != cursor.par->LastPhysicalPar())
   tmprow = tmprow->next;
   SetHeightOfRow(tmprow);
   SetHeightOfRow(cursor.row); */
   tmppar = cursor.par->FirstPhysicalPar()->Previous();
  }

RedoParagraphs(sel_start_cursor, endpar);

ClearSelection();
SetCursor(sel_start_cursor.par, sel_start_cursor.pos);
sel_cursor = cursor;
SetCursor(sel_end_cursor.par, sel_end_cursor.pos);
SetSelection();
SetCursor(tmpcursor.par, tmpcursor.pos);
}

void LyXText::SetParagraphExtraOpt(int type,
                                   const char *width,
                                   const char *widthp,
                                   int alignment, bool hfill,
                                   bool start_minipage)
{
LyXCursor tmpcursor;
tmpcursor = cursor;
LyXParagraph *tmppar;
if (!selection) {
  sel_start_cursor = cursor;
  sel_end_cursor = cursor;
}

// make sure that the depth behind the selection are restored, too
LyXParagraph *endpar = sel_end_cursor.par->LastPhysicalPar()->Next();
LyXParagraph *undoendpar = endpar;

if (endpar && endpar->GetDepth()) {
  while (endpar && endpar->GetDepth()) {
   endpar = endpar->LastPhysicalPar()->Next();
   undoendpar = endpar;
  }
}
else if (endpar) {
  endpar = endpar->Next(); /* because of parindents etc.  */
}

SetUndo(Undo::EDIT,
  sel_start_cursor.par->ParFromPos(sel_start_cursor.pos)->previous,
  undoendpar);

tmppar = sel_end_cursor.par;
while(tmppar != sel_start_cursor.par->FirstPhysicalPar()->Previous()) {
                SetCursor(tmppar->FirstPhysicalPar(), 0);
                status = LyXText::NEED_MORE_REFRESH;
                refresh_row = cursor.row;
                refresh_y = cursor.y - cursor.row->baseline;
                if (cursor.par->footnoteflag ==
                    sel_start_cursor.par->footnoteflag) {
                        if (type == PEXTRA_NONE) {
                                if (cursor.par->pextra_type != PEXTRA_NONE) {
                                        cursor.par->UnsetPExtraType();
                                        cursor.par->pextra_type=PEXTRA_NONE;
                                }
                        } else {
                                cursor.par->SetPExtraType(type,width,widthp);
                                cursor.par->pextra_hfill = hfill;
                                cursor.par->pextra_start_minipage = start_minipage;
                                cursor.par->pextra_alignment = alignment;
                        }
                }
                tmppar = cursor.par->FirstPhysicalPar()->Previous();
        }
RedoParagraphs(sel_start_cursor, endpar);
ClearSelection();
SetCursor(sel_start_cursor.par, sel_start_cursor.pos);
sel_cursor = cursor;
SetCursor(sel_end_cursor.par, sel_end_cursor.pos);
SetSelection();
SetCursor(tmpcursor.par, tmpcursor.pos);
}

static char*  alphaCounter(int n){
  static char result[2];
  result[1] = 0;
  if (n == 0)
    return "";
  else {
    result[0] = 64+n;
    if (n > 26)
      return "??";
  }
  return result;
}

/* set the counter of a paragraph. This includes the labels */
void LyXText::SetCounter(LyXParagraph *par)
{
int i;

/* this is only relevant for the beginning of paragraph */
par = par->FirstPhysicalPar();

LyXLayout* layout = lyxstyle.Style(parameters->textclass,
        par->GetLayout());

LyXTextClass *textclass = lyxstyle.TextClass(parameters->textclass);

/* copy the prev-counters to this one, unless this is the start of a
   footnote or of a bibliography or the very first paragraph */
if (par->Previous()
     && !(par->Previous()->footnoteflag == LyXParagraph::NO_FOOTNOTE
      && par->footnoteflag == LyXParagraph::OPEN_FOOTNOTE
      && par->footnotekind == LyXParagraph::FOOTNOTE)
     && !(lyxstyle.Style(parameters->textclass,
    par->Previous()->GetLayout()
    )->labeltype != LABEL_BIBLIO
   && layout->labeltype == LABEL_BIBLIO)) {
  for (i=0; i<10; i++) {
   par->counter[i]=par->Previous()->GetCounter(i);
  }
  par->appendix = par->Previous()->FirstPhysicalPar()->appendix;
  if (!par->appendix && par->start_of_appendix){
    par->appendix = true;
    for (i=0; i<10; i++) {
      par->counter[i]=0;
    }
  }
  par->enumdepth = par->Previous()->FirstPhysicalPar()->enumdepth;
  par->itemdepth = par->Previous()->FirstPhysicalPar()->itemdepth;
}
else {
  for (i=0; i<10; i++) {
   par->counter[i]=0;
  }
  par->appendix = par->start_of_appendix;
  par->enumdepth = 0;
  par->itemdepth = 0;
}

        // if this is an open marginnote and this is the first
        // entry in the marginnote and the enclosing
        // environment is an enum/item then correct for the
        // LaTeX behaviour (ARRae)
        if(par->footnoteflag == LyXParagraph::OPEN_FOOTNOTE
    && par->footnotekind == LyXParagraph::MARGIN
           && par->Previous()
           && par->Previous()->footnoteflag != LyXParagraph::OPEN_FOOTNOTE
           && (par->PreviousBeforeFootnote()
               && lyxstyle.Style(parameters->textclass,
                                 par->PreviousBeforeFootnote()->GetLayout()
     )->labeltype >= LABEL_COUNTER_ENUMI)) {
                // Any itemize or enumerate environment in a marginnote
                // that is embedded in an itemize or enumerate
                // paragraph is seen by LaTeX as being at a deeper
                // level within that enclosing itemization/enumeration
                // even if there is a "standard" layout at the start of
                // the marginnote.
                par->enumdepth++;
                par->itemdepth++;
        }

/* Maybe we have to increment the enumeration depth.
* BUT, enumeration in a footnote is considered in isolation from its
* surrounding paragraph so don't increment if this is the
* first line of the footnote
* AND, bibliographies can't have their depth changed ie. they
* are always of depth 0
*/
if (par->Previous()
     && par->Previous()->GetDepth() < par->GetDepth()
     && lyxstyle.Style(parameters->textclass,
         par->Previous()->GetLayout()
        )->labeltype == LABEL_COUNTER_ENUMI
     && par->enumdepth < 3
     && !(par->Previous()->footnoteflag == LyXParagraph::NO_FOOTNOTE
      && par->footnoteflag == LyXParagraph::OPEN_FOOTNOTE
      && par->footnotekind == LyXParagraph::FOOTNOTE)
     && layout->labeltype != LABEL_BIBLIO) {
  par->enumdepth++;
}

/* Maybe we have to decrement the enumeration depth, see note above */
if (par->Previous()
     && par->Previous()->GetDepth() > par->GetDepth()
     && !(par->Previous()->footnoteflag == LyXParagraph::NO_FOOTNOTE
      && par->footnoteflag == LyXParagraph::OPEN_FOOTNOTE
      && par->footnotekind == LyXParagraph::FOOTNOTE)
     && layout->labeltype != LABEL_BIBLIO) {
  par->enumdepth = par->DepthHook(par->GetDepth())->enumdepth;
  par->counter[6 + par->enumdepth] =
   par->DepthHook(par->GetDepth())->counter[6 + par->enumdepth];
  /* reset the counters.
* A depth change is like a breaking layout
*/
  for (i=6 + par->enumdepth + 1; i<10;i++)
   par->counter[i]=0;
}

if (!par->labelstring.empty()) {
  par->labelstring.clean();
}

if (layout->margintype == MARGIN_MANUAL) {
  if (par->labelwidthstring.empty()) {
   par->SetLabelWidthString(layout->labelstring);
  }
}
else {
  par->SetLabelWidthString(LString());
}

/* is it a layout that has an automatic label ? */
if (layout->labeltype >=  LABEL_FIRST_COUNTER) {

  i = layout->labeltype - LABEL_FIRST_COUNTER;
  if (i>=0 && i<=parameters->secnumdepth) {
   par->counter[i]++; // increment the counter

   char * s = new char[50];

   // Is there a label? Useful for Chapter layout
   if (!par->appendix){
    if (!layout->labelstring.empty())
     par->labelstring = layout->labelstring;
    else
     par->labelstring.clean();
                        }
   else {
    if (!layout->labelstring_appendix.empty())
     par->labelstring = layout->labelstring_appendix;
    else
     par->labelstring.clean();
   }

   if (!par->appendix){
    switch (2 * LABEL_FIRST_COUNTER -
     textclass->maxcounter + i) {
    case LABEL_COUNTER_CHAPTER:
     sprintf(s, "%d", par->counter[i]);
     break;
    case LABEL_COUNTER_SECTION:
     sprintf(s, "%d.%d", par->counter[i - 1], par->counter[i]);
     break;
    case LABEL_COUNTER_SUBSECTION:
     sprintf(s, "%d.%d.%d", par->counter[i-2], par->counter[i-1],par->counter[i]);
     break;
    case LABEL_COUNTER_SUBSUBSECTION:
     sprintf(s, "%d.%d.%d.%d", par->counter[i-3], par->counter[i-2],par->counter[i-1],par->counter[i]);
     break;
    case LABEL_COUNTER_PARAGRAPH:
     sprintf(s, "%d.%d.%d.%d.%d", par->counter[i-4], par->counter[i-3], par->counter[i-2],par->counter[i-1],par->counter[i]);
     break;
    case LABEL_COUNTER_SUBPARAGRAPH:
     sprintf(s, "%d.%d.%d.%d.%d.%d", par->counter[i-5], par->counter[i-4], par->counter[i-3], par->counter[i-2],par->counter[i-1],par->counter[i]);
     break;
    default:
     sprintf(s, "%d.", par->counter[i]);
                                        break;
    }
   }
   else {
    switch (2 * LABEL_FIRST_COUNTER - textclass->maxcounter+ i) {
    case LABEL_COUNTER_CHAPTER:
     sprintf(s, "%s", alphaCounter(par->counter[i]));
     break;
    case LABEL_COUNTER_SECTION:
     sprintf(s, "%s.%d", alphaCounter(par->counter[i - 1]), par->counter[i]);
     break;
    case LABEL_COUNTER_SUBSECTION:
     sprintf(s, "%s.%d.%d", alphaCounter(par->counter[i-2]), par->counter[i-1],par->counter[i]);
     break;
    case LABEL_COUNTER_SUBSUBSECTION:
     sprintf(s, "%s.%d.%d.%d", alphaCounter(par->counter[i-3]), par->counter[i-2],par->counter[i-1],par->counter[i]);
     break;
    case LABEL_COUNTER_PARAGRAPH:
     sprintf(s, "%s.%d.%d.%d.%d", alphaCounter(par->counter[i-4]), par->counter[i-3], par->counter[i-2],par->counter[i-1],par->counter[i]);
     break;
    case LABEL_COUNTER_SUBPARAGRAPH:
     sprintf(s, "%s.%d.%d.%d.%d.%d", alphaCounter(par->counter[i-5]), par->counter[i-4], par->counter[i-3], par->counter[i-2],par->counter[i-1],par->counter[i]);
     break;
    default:
     sprintf(s, "%c.", par->counter[i]);
     break;
    }
   }

   par->labelstring += s;
   delete[] s;

   for (i++; i<10; i++) {
    /* reset the following counters  */
    par->counter[i]=0;
   }
  } else if (layout->labeltype < LABEL_COUNTER_ENUMI) {
   for (i++; i<10; i++) {
    /* reset the following counters  */
    par->counter[i]=0;
   }
  } else if (layout->labeltype == LABEL_COUNTER_ENUMI) {
   par->counter[i + par->enumdepth]++;
   char * s = new char[25];
   int number = par->counter[i + par->enumdepth];
   switch (par->enumdepth) {
   case 1:
    sprintf(s, "(%c)", (number % 27) + 'a' - 1);
    break;
   case 2:
    switch (number) {
    case 1: sprintf(s, "i."); break;
    case 2: sprintf(s, "ii."); break;
    case 3: sprintf(s, "iii."); break;
    case 4: sprintf(s, "iv."); break;
    case 5: sprintf(s, "v."); break;
    case 6: sprintf(s, "vi."); break;
    case 7: sprintf(s, "vii."); break;
    case 8: sprintf(s, "viii."); break;
    case 9: sprintf(s, "ix."); break;
    case 10: sprintf(s, "x."); break;
    case 11: sprintf(s, "xi."); break;
    case 12: sprintf(s, "xii."); break;
    case 13: sprintf(s, "xiii."); break;
    default:
     sprintf(s, "\\roman{%d}.", number);
     break;
    }
    break;
   case 3:
    sprintf(s, "%c.", (number % 27) + 'A' - 1);
    break;
   default:
    sprintf(s, "%d.", number);
    break;
   }
   par->labelstring = s;
   delete[] s;

   for (i += par->enumdepth + 1;i<10;i++)
    par->counter[i]=0;      /* reset the following counters  */

  }
} else if (layout->labeltype == LABEL_BIBLIO) {// ale970302
     i = LABEL_COUNTER_ENUMI - LABEL_FIRST_COUNTER + par->enumdepth;
     par->counter[i]++;
     int number = par->counter[i];
     if (!par->bibkey)
       par->bibkey = new InsetBibKey();
     par->bibkey->setCounter(number);
     par->labelstring = layout->labelstring;

     // In biblio should't be following counters but...
}
else  {
  LString s = layout->labelstring;

  /* the caption hack: */

  if (layout->labeltype == LABEL_SENSITIVE) {
   if (par->footnoteflag != LyXParagraph::NO_FOOTNOTE
       && (par->footnotekind == LyXParagraph::FIG
       || par->footnotekind == LyXParagraph::WIDE_FIG))
    s = "Figure:";
   else if (par->footnoteflag != LyXParagraph::NO_FOOTNOTE
     && (par->footnotekind == LyXParagraph::TAB
     || par->footnotekind == LyXParagraph::WIDE_TAB))
    s = "Table:";
   else if (par->footnoteflag != LyXParagraph::NO_FOOTNOTE
     && par->footnotekind == LyXParagraph::ALGORITHM)
    s = "Algorithm:";
   else {
    /* par->SetLayout(0);
   s = layout->labelstring;  */
    s = "Senseless: ";

   }
  }
  par->labelstring = s;

  /* reset the enumeration counter. They are always resetted
* when there is any other layout between */
  for (i=6 + par->enumdepth; i<10;i++)
   par->counter[i]=0;
}
}

/* Updates all counters BEHIND the row. Changed paragraphs
* with a dynamic left margin will be rebroken. */
void LyXText::UpdateCounters(Row *row)
{
LyXParagraph *par;
if (!row) {
  row = firstrow;
  par = row->par;
}
else {
  if (row->par->next && row->par->next->footnoteflag != LyXParagraph::OPEN_FOOTNOTE) {
   par = row->par->LastPhysicalPar()->Next();
  } else {
   par = row->par->next;
  }
}

while (par) {
  while (row->par != par)
   row = row->next;

  SetCounter(par);

  /* now  check for the headline layouts. remember that they
* have a dynamic left margin */
  if (!par->IsDummy()
      && ( lyxstyle.Style(parameters->textclass, par->layout)->margintype == MARGIN_DYNAMIC
    || lyxstyle.Style(parameters->textclass, par->layout)->labeltype == LABEL_SENSITIVE)
   ){

   /* Rebreak the paragraph */
   RemoveParagraph(row);
   AppendParagraph(row);

   /* think about the damned open footnotes! */
   while (par->Next() &&
          (par->Next()->footnoteflag == LyXParagraph::OPEN_FOOTNOTE
    || par->Next()->IsDummy())){
    par = par->Next();
    if (par->IsDummy()) {
     while (row->par != par)
      row = row->next;
     RemoveParagraph(row);
     AppendParagraph(row);
    }
   }
  }

  par = par->LastPhysicalPar()->Next();

}
}

/* insets an inset. */
void LyXText::InsertInset(Inset *inset)
{
SetUndo(Undo::INSERT,
  cursor.par->ParFromPos(cursor.pos)->previous,
  cursor.par->ParFromPos(cursor.pos)->next);
cursor.par->InsertChar(cursor.pos, LYX_META_INSET);
cursor.par->InsertInset(cursor.pos, inset);
InsertChar(LYX_META_INSET);  /* just to rebreak and refresh correctly.
      * The character will not be inserted a
      * second time */
}

/* this is for the simple cut and paste mechanism */
static LyXParagraph *simple_cut_buffer = NULL;
static char simple_cut_buffer_textclass = 0;

void DeleteSimpleCutBuffer()
{
if (!simple_cut_buffer)
  return;
LyXParagraph *tmppar;

while (simple_cut_buffer) {
  tmppar =  simple_cut_buffer;
  simple_cut_buffer = simple_cut_buffer->next;
  delete tmppar;
}
simple_cut_buffer = NULL;
}

void LyXText::copyEnvironmentType()
{
copylayouttype = cursor.par->GetLayout();
}

void LyXText::pasteEnvironmentType()
{
SetLayout(copylayouttype);
}

void LyXText::CutSelection(bool doclear)
{
/* This doesn't make sense, if there is no selection */
if (!selection) {
  return;
}

/* OK, we have a selection. This is always between sel_start_cursor
* and sel_end cursor */
LyXParagraph *tmppar;
int i;

/* Check whether there are half footnotes in the selection */
if (sel_start_cursor.par->footnoteflag != LyXParagraph::NO_FOOTNOTE
     || sel_end_cursor.par->footnoteflag != LyXParagraph::NO_FOOTNOTE){
  tmppar = sel_start_cursor.par;
  while (tmppar != sel_end_cursor.par){
   if (tmppar->footnoteflag != sel_end_cursor.par->footnoteflag){
    WriteAlert(_("Impossible operation"), _("Don't know what to do with half floats."), _("sorry."));
    return;
   }
   tmppar = tmppar->Next();
  }
}

/* table stuff -- begin*/
if (sel_start_cursor.par->table || sel_end_cursor.par->table){
  if ( sel_start_cursor.par != sel_end_cursor.par){
   WriteAlert(_("Impossible operation"), _("Don't know what to do with half tables."), _("sorry."));
   return;
  }
  sel_start_cursor.par->table->Reinit();
}
/* table stuff -- end*/

// make sure that the depth behind the selection are restored, too
LyXParagraph *endpar = sel_end_cursor.par->LastPhysicalPar()->Next();
LyXParagraph *undoendpar = endpar;

if (endpar && endpar->GetDepth()) {
  while (endpar && endpar->GetDepth()) {
   endpar = endpar->LastPhysicalPar()->Next();
   undoendpar = endpar;
  }
}
else if (endpar) {
  endpar = endpar->Next();        /* because of parindents etc.  */
}

SetUndo(Undo::DELETE,
  sel_start_cursor.par->ParFromPos(sel_start_cursor.pos)->previous,
  undoendpar);

/* delete the simple_cut_buffer */
DeleteSimpleCutBuffer();

/* set the textclass */
simple_cut_buffer_textclass = parameters->textclass;

#ifdef WITH_WARNINGS
#warning Asger: Make cut more intelligent here.
#endif
/*
White paper for "intelligent" cutting:

Example: "This is our text."
Using " our " as selection, cutting will give "This istext.".
Using "our" as selection, cutting will give "This is text.".
Using " our" as selection, cutting will give "This is text.".
Using "our " as selection, cutting will give "This is text.".

All those four selections will (however) paste identically:
Pasting with the cursor right after the "is" will give the
original text with all four selections.

The rationale is to be intelligent such that words are copied,
cut and pasted in a functional manner.

This is not implemented yet.
*/

char space_wrapped =
  sel_end_cursor.par->IsLineSeparator(sel_end_cursor.pos);
if (sel_end_cursor.pos > 0
     && sel_end_cursor.par->IsLineSeparator(sel_end_cursor.pos - 1)) {
  sel_end_cursor.pos--;  /* please break before a space at
* the end */
  space_wrapped = True;
}

// cut behind a space if there is one
while (sel_start_cursor.par->Last() > sel_start_cursor.pos
        && sel_start_cursor.par->IsLineSeparator(sel_start_cursor.pos)
        && (sel_start_cursor.par != sel_end_cursor.par
     || sel_start_cursor.pos < sel_end_cursor.pos))
  sel_start_cursor.pos++;

/* there are two cases: cut only within one paragraph or
* more than one paragraph */

if (sel_start_cursor.par->ParFromPos(sel_start_cursor.pos)
     == sel_end_cursor.par->ParFromPos(sel_end_cursor.pos)) {
  /* only within one paragraph */
  simple_cut_buffer = new LyXParagraph();
  for (i=sel_start_cursor.pos; i< sel_end_cursor.pos; i++){
   /* table stuff -- begin*/
   if (sel_start_cursor.par->table
       && sel_start_cursor.par->IsNewline(sel_start_cursor.pos)){
    sel_start_cursor.par->CopyIntoMinibuffer(sel_start_cursor.pos);
    sel_start_cursor.pos++;
   } else {
    /* table stuff -- end*/
    sel_start_cursor.par->CopyIntoMinibuffer(sel_start_cursor.pos);
    sel_start_cursor.par->Erase(sel_start_cursor.pos);
   }
   simple_cut_buffer->InsertFromMinibuffer(simple_cut_buffer->Last());
  }
  /* check for double spaces */
  if (sel_start_cursor.pos &&
      sel_start_cursor.par->Last()>sel_start_cursor.pos &&
      sel_start_cursor.par->IsLineSeparator(sel_start_cursor.pos - 1) &&
      sel_start_cursor.par->IsLineSeparator(sel_start_cursor.pos)){
   sel_start_cursor.par->Erase(sel_start_cursor.pos);
  }
  if (space_wrapped)
   simple_cut_buffer->InsertChar(i - sel_start_cursor.pos, ' ');
  endpar = sel_end_cursor.par->Next();
}
else {
  /* cut more than one paragraph */

  sel_end_cursor.par->BreakParagraphConservative(sel_end_cursor.pos);
  /* insert a space at the end if there was one */
  if (space_wrapped)
   sel_end_cursor.par->InsertChar(sel_end_cursor.par->Last(), ' ');

  sel_end_cursor.par = sel_end_cursor.par->Next();
  sel_end_cursor.pos = 0;

  cursor = sel_end_cursor;

  /* please break behind a space, if there is one. The space should
* be copied too */
  if (sel_start_cursor.par->IsLineSeparator(sel_start_cursor.pos))
   sel_start_cursor.pos++;

  sel_start_cursor.par->BreakParagraphConservative(sel_start_cursor.pos);
  if (!sel_start_cursor.pos
      || sel_start_cursor.par->IsLineSeparator(sel_start_cursor.pos - 1)
      || sel_start_cursor.par->IsNewline(sel_start_cursor.pos - 1)) {
   sel_start_cursor.par->Next()->InsertChar(0, ' ');
  }

  /* store the endparagraph for redoing later */
  endpar = sel_end_cursor.par->Next();   /* needed because
* the sel_end_
* cursor.par
* will be pasted!*/

  /*store the selection */
  simple_cut_buffer = sel_start_cursor.par->ParFromPos(sel_start_cursor.pos)->next;
  simple_cut_buffer->previous = NULL;
  sel_end_cursor.par->previous->next = NULL;

  /* cut the selection */
  sel_start_cursor.par->ParFromPos(sel_start_cursor.pos)->next
   = sel_end_cursor.par;

  sel_end_cursor.par->previous
   = sel_start_cursor.par->ParFromPos(sel_start_cursor.pos);

  /* care about footnotes */
  if (simple_cut_buffer->footnoteflag) {
   LyXParagraph *tmppar = simple_cut_buffer;
   while (tmppar){
    tmppar->footnoteflag = LyXParagraph::NO_FOOTNOTE;
    tmppar = tmppar->next;
   }
  }

  /* the cut selection should begin with standard layout */
  simple_cut_buffer->Clear();

  /* paste the paragraphs again, if possible  */
  if (doclear)
   sel_start_cursor.par->Next()->ClearParagraph();
  if (sel_start_cursor.par->FirstPhysicalPar()->HasSameLayout(sel_start_cursor.par->Next())
      ||
      !sel_start_cursor.par->Next()->Last())
   sel_start_cursor.par->ParFromPos(sel_start_cursor.pos)->PasteParagraph();


  /* maybe a forgotten blank */
  if (sel_start_cursor.pos
      && sel_start_cursor.par->IsLineSeparator(sel_start_cursor.pos)
      && sel_start_cursor.par->IsLineSeparator(sel_start_cursor.pos - 1)) {
   sel_start_cursor.par->Erase(sel_start_cursor.pos);
  }
}

/* sometimes necessary */
if (doclear)
  sel_start_cursor.par->ClearParagraph();

RedoParagraphs(sel_start_cursor, endpar);

ClearSelection();
cursor = sel_start_cursor;
SetCursor(cursor.par, cursor.pos);
sel_cursor = cursor;
UpdateCounters(cursor.row);
}


void LyXText::CopySelection()
{
int i=0;

/* this doesnt make sense, if there is no selection */
if (!selection) {
  return;
}

/* ok we have a selection. This is always between sel_start_cursor
* and sel_end cursor */
LyXParagraph *tmppar;

/* check wether there are half footnotes in the selection */
if (sel_start_cursor.par->footnoteflag != LyXParagraph::NO_FOOTNOTE
     || sel_end_cursor.par->footnoteflag != LyXParagraph::NO_FOOTNOTE){
  tmppar = sel_start_cursor.par;
  while (tmppar != sel_end_cursor.par){
   if (tmppar->footnoteflag != sel_end_cursor.par->footnoteflag){
    WriteAlert(_("Impossible operation"), _("Don't know what to do with half floats."), _("sorry."));
    return;
   }
   tmppar = tmppar->Next();
  }
}

/* table stuff -- begin*/
if (sel_start_cursor.par->table || sel_end_cursor.par->table){
  if ( sel_start_cursor.par != sel_end_cursor.par){
   WriteAlert(_("Impossible operation"), _("Don't know what to do with half tables."), _("sorry."));
   return;
  }
}
/* table stuff -- end*/

/* delete the simple_cut_buffer */
DeleteSimpleCutBuffer();

/* set the textclass */
simple_cut_buffer_textclass = parameters->textclass;

// copy behind a space if there is one
while (sel_start_cursor.par->Last() > sel_start_cursor.pos
        && sel_start_cursor.par->IsLineSeparator(sel_start_cursor.pos)
        && (sel_start_cursor.par != sel_end_cursor.par
     || sel_start_cursor.pos < sel_end_cursor.pos))
  sel_start_cursor.pos++;

/* there are two cases: copy only within one paragraph or more than one paragraph */
if (sel_start_cursor.par->ParFromPos(sel_start_cursor.pos)
     == sel_end_cursor.par->ParFromPos(sel_end_cursor.pos)) {
  /* only within one paragraph */
  simple_cut_buffer = new LyXParagraph();
  for (i=sel_start_cursor.pos; i< sel_end_cursor.pos; i++){
   sel_start_cursor.par->CopyIntoMinibuffer(i);
   simple_cut_buffer->InsertFromMinibuffer(i - sel_start_cursor.pos);
  }
}
else {
  /* copy more than one paragraph */
  /* clone the paragraphs within the selection*/
  tmppar = sel_start_cursor.par->ParFromPos(sel_start_cursor.pos);
  simple_cut_buffer = tmppar->Clone();
  LyXParagraph *tmppar2 = simple_cut_buffer;

  while (tmppar != sel_end_cursor.par->ParFromPos(sel_end_cursor.pos)
         && tmppar->next) {
   tmppar = tmppar->next;
   tmppar2->next = tmppar->Clone();
   tmppar2->next->previous = tmppar2;
   tmppar2=tmppar2->next;
  }
  tmppar2->next = NULL;

  /* care about footnotes */
  if (simple_cut_buffer->footnoteflag) {
   tmppar = simple_cut_buffer;
   while (tmppar){
    tmppar->footnoteflag = LyXParagraph::NO_FOOTNOTE;
    tmppar = tmppar->next;
   }
  }

  /* the simple_cut_buffer paragraph is too big */
  int tmpi2;

  tmpi2 = sel_start_cursor.par->PositionInParFromPos(sel_start_cursor.pos);
  for (;tmpi2;tmpi2--)
   simple_cut_buffer->Erase(0);

  /* now tmppar 2 is too big, delete all after sel_end_cursor.pos */

  tmpi2 = sel_end_cursor.par->PositionInParFromPos(sel_end_cursor.pos);
  while (tmppar2->last > tmpi2) {
   tmppar2->Erase(tmppar2->last-1);
  }

}
}


void LyXText::PasteSelection()
{
/* this does not make sense, if there is nothing to paste */
if (!simple_cut_buffer)
  return;

LyXParagraph *tmppar;
LyXParagraph *endpar;

LyXCursor tmpcursor;

/* be carefull with footnotes in footnotes */
if (cursor.par->footnoteflag != LyXParagraph::NO_FOOTNOTE) {

  /* check whether the cut_buffer includes a footnote */
  tmppar = simple_cut_buffer;
  while (tmppar && tmppar->footnoteflag == LyXParagraph::NO_FOOTNOTE)
   tmppar = tmppar->next;

  if (tmppar) {
   WriteAlert(_("Impossible operation"),
       _("Can't paste float into float!"), _("Sorry."));
   return;
  }
}

/* table stuff -- begin*/
if (cursor.par->table){
  if (simple_cut_buffer->next){
   WriteAlert(_("Impossible operation"),
       _("Table cell cannot include more than one paragraph!"),
       _("Sorry."));
   return;
  }
}
/* table stuff -- end*/

SetUndo(Undo::INSERT,
  cursor.par->ParFromPos(cursor.pos)->previous,
  cursor.par->ParFromPos(cursor.pos)->next);

tmpcursor = cursor;

/* There are two cases: cutbuffer only one paragraph or many */
if (!simple_cut_buffer->next) {
  /* only within a paragraph */

  /* please break behind a space, if there is one */
  while (tmpcursor.par->Last() > tmpcursor.pos
         && tmpcursor.par->IsLineSeparator(tmpcursor.pos))
   tmpcursor.pos++;

  tmppar = simple_cut_buffer->Clone();
  /* table stuff -- begin*/
  bool table_too_small = false;
  if (tmpcursor.par->table) {
   while (simple_cut_buffer->last && !table_too_small){
    if (simple_cut_buffer->IsNewline(0)){
     while(tmpcursor.pos < tmpcursor.par->Last() && !tmpcursor.par->IsNewline(tmpcursor.pos))
      tmpcursor.pos++;
     simple_cut_buffer->Erase(0);
     if (tmpcursor.pos < tmpcursor.par->Last())
      tmpcursor.pos++;
     else
      table_too_small = true;
    } else {
     simple_cut_buffer->CutIntoMinibuffer(0);
     simple_cut_buffer->Erase(0);
     tmpcursor.par->InsertFromMinibuffer(tmpcursor.pos);
     tmpcursor.pos++;
    }
   }
  } else {
   /* table stuff -- end*/
   while (simple_cut_buffer->last){
    simple_cut_buffer->CutIntoMinibuffer(0);
    simple_cut_buffer->Erase(0);
    tmpcursor.par->InsertFromMinibuffer(tmpcursor.pos);
    tmpcursor.pos++;
   }
  }

  delete simple_cut_buffer;
  simple_cut_buffer = tmppar;
  endpar = tmpcursor.par->Next();
} else {
  /* many paragraphs */

  /* make a copy of the simple cut_buffer */
  tmppar = simple_cut_buffer;
  LyXParagraph *simple_cut_clone = tmppar->Clone();
  LyXParagraph *tmppar2 = simple_cut_clone;
  if (cursor.par->footnoteflag){
   tmppar->footnoteflag = cursor.par->footnoteflag;
   tmppar->footnotekind = cursor.par->footnotekind;
  }
  while (tmppar->next) {
   tmppar = tmppar->next;
   tmppar2->next = tmppar->Clone();
   tmppar2->next->previous = tmppar2;
   tmppar2=tmppar2->next;
   if (cursor.par->footnoteflag){
    tmppar->footnoteflag = cursor.par->footnoteflag;
    tmppar->footnotekind = cursor.par->footnotekind;
   }
  }

  /* make sure there is no class difference */
  SwitchLayoutsBetweenClasses(simple_cut_buffer_textclass,
         parameters->textclass,
         simple_cut_buffer);

  /* make the simple_cut_buffer exactly the same layout than
   the cursor paragraph */
  simple_cut_buffer->MakeSameLayout(cursor.par);

  /* find the end of the buffer */
  LyXParagraph *lastbuffer = simple_cut_buffer;
  while (lastbuffer->Next())
   lastbuffer=lastbuffer->Next();

  /* find the physical end of the buffer */
  lastbuffer = simple_cut_buffer;
  while (lastbuffer->Next())
   lastbuffer=lastbuffer->Next();

  /* please break behind a space, if there is one. The space
* should be copied too */
  if (cursor.par->Last() > cursor.pos && cursor.par->IsLineSeparator(cursor.pos))
   cursor.pos++;

  bool paste_the_end = false;

  /* open the paragraph for inserting the simple_cut_buffer
   if necessary */
  if (cursor.par->Last() > cursor.pos || !cursor.par->Next()){
   cursor.par->BreakParagraphConservative(cursor.pos);
   paste_the_end = true;
  }

  /* be careful with double spaces */
  if ((!cursor.par->Last()
       || cursor.par->IsLineSeparator(cursor.pos - 1)
       || cursor.par->IsNewline(cursor.pos - 1))
      && simple_cut_buffer->last
      && simple_cut_buffer->IsLineSeparator(0))
   simple_cut_buffer->Erase(0);

  /* set the end for redoing later */
  endpar = cursor.par->ParFromPos(cursor.pos)->next->Next();

  /* paste it! */
  lastbuffer->ParFromPos(lastbuffer->Last())->next = cursor.par->ParFromPos(cursor.pos)->next;
  cursor.par->ParFromPos(cursor.pos)->next->previous = lastbuffer->ParFromPos(lastbuffer->Last());

  cursor.par->ParFromPos(cursor.pos)->next = simple_cut_buffer;
  simple_cut_buffer->previous = cursor.par->ParFromPos(cursor.pos);

  if (cursor.par->ParFromPos(cursor.pos)->Next() == lastbuffer)
   lastbuffer = cursor.par;

  cursor.par->ParFromPos(cursor.pos)->PasteParagraph();

  /* store the new cursor position  */
  tmpcursor.par = lastbuffer;
  tmpcursor.pos = lastbuffer->Last();

  /* maybe some pasting */
  if (lastbuffer->Next() && paste_the_end) {
   if (lastbuffer->Next()->HasSameLayout(lastbuffer)) {

    /* be careful witth double spaces */
    if ((!lastbuffer->Last()
         || lastbuffer->IsLineSeparator(lastbuffer->Last() - 1)
         || lastbuffer->IsNewline(lastbuffer->Last() - 1))
        && lastbuffer->Next()->Last()
        && lastbuffer->Next()->IsLineSeparator(0))
     lastbuffer->Next()->Erase(0);

    lastbuffer->ParFromPos(lastbuffer->Last())->PasteParagraph();

   }
   else if (!lastbuffer->Next()->Last()) {
    lastbuffer->Next()->MakeSameLayout(lastbuffer);

    /* be careful witth double spaces */
    if ((!lastbuffer->Last()
         || lastbuffer->IsLineSeparator(lastbuffer->Last() - 1)
         || lastbuffer->IsNewline(lastbuffer->Last() - 1))
        && lastbuffer->Next()->Last()
        && lastbuffer->Next()->IsLineSeparator(0))
     lastbuffer->Next()->Erase(0);

--> --------------------

--> maximum size reached

--> --------------------

¤ Dauer der Verarbeitung: 0.64 Sekunden (vorverarbeitet) ¤

Download des Quellennavigators
Download des sprechenden Kalenders
in der Quellcodebibliothek suchen

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.